From c1cf3f321c95f85993d4a0709cf8d92cf3ab598a Mon Sep 17 00:00:00 2001
From: Redstoneur <alfa.aog36@gmail.com>
Date: Mon, 16 Feb 2026 17:25:00 +0100
Subject: [PATCH 01/20] Update .gitignore to exclude JetBrains IDEs
 configuration and improve README with English description

---
 .gitignore | 3 +++
 README.md  | 2 +-
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/.gitignore b/.gitignore
index b7faf40..21ac12b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -205,3 +205,6 @@ cython_debug/
 marimo/_static/
 marimo/_lsp/
 __marimo__/
+
+# JetBrains IDEs
+/.idea/
diff --git a/README.md b/README.md
index d8a505f..2c95ac9 100644
--- a/README.md
+++ b/README.md
@@ -1,2 +1,2 @@
 # PyMacroRecorder
-Application Python multiplateforme (Windows/Linux) pour enregistrer, rejouer et sauvegarder des macros clavier et souris en temps réel.
+Cross-platform Python application (Windows/Linux) for recording, replaying and saving keyboard and mouse macros in real time.

From 679a97b32e7e2e0525661471a22f85abc6399868 Mon Sep 17 00:00:00 2001
From: Redstoneur <alfa.aog36@gmail.com>
Date: Mon, 16 Feb 2026 23:00:22 +0100
Subject: [PATCH 02/20] Add CONTRIBUTING.md to guide new contributors

---
 CONTRIBUTING.md | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 CONTRIBUTING.md

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
new file mode 100644
index 0000000..5bb3c56
--- /dev/null
+++ b/CONTRIBUTING.md
@@ -0,0 +1,28 @@
+# Contributing to PyMacroRecorder
+
+Thanks for your interest in improving PyMacroRecorder!
+
+## Getting started
+1. Install Python 3.10+.
+2. Create a virtual environment and install dependencies:
+   ```bash
+   python -m venv .venv
+   . .venv/Scripts/activate  # Windows: .venv\Scripts\activate
+   pip install -r requirements.txt
+   ```
+3. Run the app locally:
+   ```bash
+   python main.py
+   ```
+
+## Development guidelines
+- Keep `main.py` limited to application bootstrap; place logic inside `pymacrorecorder/`.
+- Prefer small, focused classes and functions with clear responsibilities.
+- Ensure new features work on both Windows and Linux.
+- When adding storage or settings, keep JSON format and update `pymacrorecorder/config.py` as needed.
+
+## Submitting changes
+- Create a feature branch for your work.
+- Add or update documentation for new behavior.
+- Open a pull request summarizing the change, testing performed, and any platform-specific notes.
+

From 0f8f2a9dce57d2d689ba5631530e59d30855ec97 Mon Sep 17 00:00:00 2001
From: Redstoneur <alfa.aog36@gmail.com>
Date: Mon, 16 Feb 2026 23:00:35 +0100
Subject: [PATCH 03/20] Add pyproject.toml and requirements.txt; enhance README
 with features and usage instructions

---
 README.md        | 60 +++++++++++++++++++++++++++++++++++++++++++++++-
 pyproject.toml   | 23 +++++++++++++++++++
 requirements.txt |  4 ++++
 3 files changed, 86 insertions(+), 1 deletion(-)
 create mode 100644 pyproject.toml
 create mode 100644 requirements.txt

diff --git a/README.md b/README.md
index 2c95ac9..0dcf62a 100644
--- a/README.md
+++ b/README.md
@@ -1,2 +1,60 @@
 # PyMacroRecorder
-Cross-platform Python application (Windows/Linux) for recording, replaying and saving keyboard and mouse macros in real time.
+
+Tkinter app to record, play, and save keyboard/mouse macros.
+
+## Features
+- Global recording (pynput) with live log.
+- Buttons: Start/Stop Record, Start/Stop Macro, Save Macro, Load Macro.
+- Configurable global hotkeys (minimum 2 keys). Control combos are ignored during recording.
+- Save/load macros as CSV (name + events JSON). The displayed preview is what is replayed.
+- Playback with repeat count (0 = infinite) and immediate stop.
+
+## Structure
+```
+PyMacroRecorder/
+├─ main.py
+├─ requirements.txt
+├─ pyproject.toml
+├─ README.md
+├─ LICENSE
+├─ CONTRIBUTING.md
+├─ build.ps1
+├─ build.sh
+├─ .gitignore
+├─ .github/
+│  └─ workflows/
+│     ├─ ci.yml 
+│     └─ release.yml
+└─ pymacrorecorder/
+   ├─ __init__.py
+   ├─ app.py
+   ├─ config.py
+   ├─ hotkeys.py
+   ├─ models.py
+   ├─ player.py
+   ├─ recorder.py
+   ├─ storage.py
+   └─ utils.py
+```
+
+## Quick start
+```bash
+python -m venv .venv
+. .venv/Scripts/activate  # Windows: .venv\Scripts\activate
+pip install -r requirements.txt
+python main.py
+```
+
+## Save & config
+- Macros: CSV chosen via the UI (columns `name`, `events`).
+- Hotkeys: `config.json` in the user data directory (see `pymacrorecorder/config.py`).
+
+## Default hotkeys
+- Start Record: Ctrl+Alt+R
+- Stop Record: Ctrl+Alt+S
+- Start Macro: Ctrl+Alt+P
+- Stop Macro: Ctrl+Alt+O
+- Save Macro: Ctrl+Alt+E
+- Load Macro: Ctrl+Alt+L
+
+Click a hotkey label in the UI, press a new combination (≥2 keys) to save it.
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 0000000..6850ba9
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,23 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pymacrorecorder"
+version = "0.1.1"
+description = "Cross-platform Tkinter macro recorder for keyboard and mouse."
+readme = "README.md"
+requires-python = ">=3.10"
+authors = [{ name = "PyMacroRecorder" }]
+license = { file = "LICENSE" }
+dependencies = [
+  "pynput>=1.7.6",
+  "appdirs>=1.4.4",
+]
+
+[project.urls]
+Homepage = "https://github.com/Redstoneur/PyMacroRecorder"
+Repository = "https://github.com/Redstoneur/PyMacroRecorder.git"
+
+[tool.setuptools]
+packages = ["pymacrorecorder"]
diff --git a/requirements.txt b/requirements.txt
new file mode 100644
index 0000000..7d59ce0
--- /dev/null
+++ b/requirements.txt
@@ -0,0 +1,4 @@
+pynput>=1.7.6
+appdirs>=1.4.4
+pyinstaller>=5.1.0
+pyinstaller-hooks-contrib>=2024.6.0

From 44b287a643284b83a357ba6c94645bf7fe12e9c6 Mon Sep 17 00:00:00 2001
From: Redstoneur <alfa.aog36@gmail.com>
Date: Mon, 16 Feb 2026 23:00:48 +0100
Subject: [PATCH 04/20] Implement core functionality for PyMacroRecorder with
 main application, configuration, and event handling

---
 build.ps1                   |  24 ++++
 build.sh                    |  26 ++++
 main.py                     |  11 ++
 pymacrorecorder/__init__.py |   7 +
 pymacrorecorder/app.py      | 255 ++++++++++++++++++++++++++++++++++++
 pymacrorecorder/config.py   |  52 ++++++++
 pymacrorecorder/hotkeys.py  |  71 ++++++++++
 pymacrorecorder/models.py   |  24 ++++
 pymacrorecorder/player.py   |  77 +++++++++++
 pymacrorecorder/recorder.py | 102 +++++++++++++++
 pymacrorecorder/storage.py  |  38 ++++++
 pymacrorecorder/utils.py    |  63 +++++++++
 12 files changed, 750 insertions(+)
 create mode 100644 build.ps1
 create mode 100644 build.sh
 create mode 100644 main.py
 create mode 100644 pymacrorecorder/__init__.py
 create mode 100644 pymacrorecorder/app.py
 create mode 100644 pymacrorecorder/config.py
 create mode 100644 pymacrorecorder/hotkeys.py
 create mode 100644 pymacrorecorder/models.py
 create mode 100644 pymacrorecorder/player.py
 create mode 100644 pymacrorecorder/recorder.py
 create mode 100644 pymacrorecorder/storage.py
 create mode 100644 pymacrorecorder/utils.py

diff --git a/build.ps1 b/build.ps1
new file mode 100644
index 0000000..3ff3c87
--- /dev/null
+++ b/build.ps1
@@ -0,0 +1,24 @@
+#!/usr/bin/env pwsh
+# Build PyMacroRecorder standalone binary using pyinstaller (Windows)
+$ErrorActionPreference = "Stop"
+
+$ProjectRoot = Split-Path -Parent $MyInvocation.MyCommand.Definition
+$DistDir = Join-Path $ProjectRoot "dist"
+$BuildDir = Join-Path $ProjectRoot "build"
+$SpecFile = Join-Path $ProjectRoot "PyMacroRecorder.spec"
+$EntryPoint = Join-Path $ProjectRoot "main.py"
+$AppName = "PyMacroRecorder"
+
+# Clean previous outputs
+Remove-Item -Recurse -Force -ErrorAction SilentlyContinue $DistDir, $BuildDir, $SpecFile
+
+# Run pyinstaller
+pyinstaller \
+  --onefile \
+  --name "$AppName" \
+  --distpath "$DistDir" \
+  --workpath "$BuildDir" \
+  "$EntryPoint"
+
+Write-Host "Build complete. Binary located at: $DistDir\$AppName.exe"
+
diff --git a/build.sh b/build.sh
new file mode 100644
index 0000000..6798dd5
--- /dev/null
+++ b/build.sh
@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Build PyMacroRecorder standalone binary using pyinstaller (Linux/macOS)
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$SCRIPT_DIR"
+DIST_DIR="$PROJECT_ROOT/dist"
+BUILD_DIR="$PROJECT_ROOT/build"
+SPEC_FILE="$PROJECT_ROOT/PyMacroRecorder.spec"
+ENTRYPOINT="$PROJECT_ROOT/main.py"
+APP_NAME="PyMacroRecorder"
+
+# Clean previous outputs
+rm -rf "$DIST_DIR" "$BUILD_DIR" "$SPEC_FILE"
+
+# Run pyinstaller
+pyinstaller \
+  --onefile \
+  --name "$APP_NAME" \
+  --distpath "$DIST_DIR" \
+  --workpath "$BUILD_DIR" \
+  "$ENTRYPOINT"
+
+# Print result path
+echo "Build complete. Binary located at: $DIST_DIR/$APP_NAME"
+
diff --git a/main.py b/main.py
new file mode 100644
index 0000000..28912c6
--- /dev/null
+++ b/main.py
@@ -0,0 +1,11 @@
+from pymacrorecorder.app import App
+
+
+def main() -> None:
+    app = App()
+    app.mainloop()
+
+
+if __name__ == "__main__":
+    main()
+
diff --git a/pymacrorecorder/__init__.py b/pymacrorecorder/__init__.py
new file mode 100644
index 0000000..aa72291
--- /dev/null
+++ b/pymacrorecorder/__init__.py
@@ -0,0 +1,7 @@
+"""PyMacroRecorder package initialization."""
+
+from .app import App
+
+__all__ = [
+    "App",
+]
diff --git a/pymacrorecorder/app.py b/pymacrorecorder/app.py
new file mode 100644
index 0000000..ee6bbaf
--- /dev/null
+++ b/pymacrorecorder/app.py
@@ -0,0 +1,255 @@
+"""Tkinter application entry point for PyMacroRecorder."""
+
+import threading
+import tkinter as tk
+from pathlib import Path
+from tkinter import filedialog, messagebox, simpledialog, ttk
+from typing import Dict, List, Optional
+
+from .config import DEFAULT_HOTKEYS, load_config, save_config
+from .hotkeys import HotkeyManager, capture_hotkey_blocking
+from .models import Macro
+from .player import Player
+from .recorder import Recorder
+from .storage import load_macros_from_csv, save_macro_to_csv
+from .utils import format_combo
+
+
+class App(tk.Tk):
+    def __init__(self) -> None:
+        super().__init__()
+        self.title("PyMacroRecorder")
+        self.geometry("900x600")
+
+        cfg = load_config()
+        self.hotkeys: Dict[str, List[str]] = cfg.get("hotkeys", DEFAULT_HOTKEYS)
+        self.recorder = Recorder(self._log)
+        self.player = Player(self._log)
+        self.current_macro: Optional[Macro] = None
+
+        self._build_ui()
+        self._refresh_hotkey_labels()
+        self.hotkey_manager = HotkeyManager(self.hotkeys, self._dispatch_hotkey)
+        self.hotkey_manager.start()
+
+    def _build_ui(self) -> None:
+        controls = ttk.Frame(self)
+        controls.pack(fill="x", padx=10, pady=5)
+
+        self.start_rec_btn = ttk.Button(controls, text="Start Record", command=self.start_recording)
+        self.stop_rec_btn = ttk.Button(controls, text="Stop Record", command=self.stop_recording, state="disabled")
+        self.start_play_btn = ttk.Button(controls, text="Start Macro", command=self.start_playback)
+        self.stop_play_btn = ttk.Button(controls, text="Stop Macro", command=self.stop_playback, state="disabled")
+        self.save_btn = ttk.Button(controls, text="Save Macro", command=self.save_macro)
+        self.load_btn = ttk.Button(controls, text="Load Macro", command=self.load_macro)
+        self.delete_btn = ttk.Button(controls, text="Delete Selected", command=self._delete_selected_events)
+
+        self.start_rec_btn.grid(row=0, column=0, padx=5, pady=2)
+        self.stop_rec_btn.grid(row=0, column=1, padx=5, pady=2)
+        self.start_play_btn.grid(row=0, column=2, padx=5, pady=2)
+        self.stop_play_btn.grid(row=0, column=3, padx=5, pady=2)
+        self.save_btn.grid(row=0, column=4, padx=5, pady=2)
+        self.load_btn.grid(row=0, column=5, padx=5, pady=2)
+        self.delete_btn.grid(row=0, column=6, padx=5, pady=2)
+
+        repeat_frame = ttk.Frame(self)
+        repeat_frame.pack(fill="x", padx=10, pady=2)
+        ttk.Label(repeat_frame, text="Repeats (0 = infinite):").pack(side="left")
+        self.repeat_var = tk.StringVar(value="1")
+        self.repeat_entry = ttk.Entry(repeat_frame, textvariable=self.repeat_var, width=6)
+        self.repeat_entry.pack(side="left", padx=5)
+
+        preview_frame = ttk.LabelFrame(self, text="Event preview")
+        preview_frame.pack(fill="both", expand=True, padx=10, pady=5)
+        columns = ("#", "type", "details", "delay")
+        self.preview = ttk.Treeview(preview_frame, columns=columns, show="headings", height=12)
+        self.preview.heading("#", text="#")
+        self.preview.heading("type", text="Type")
+        self.preview.heading("details", text="Details")
+        self.preview.heading("delay", text="Delay (ms)")
+        for col in columns:
+            self.preview.column(col, width=150, anchor="w")
+        self.preview.pack(fill="both", expand=True)
+        self.preview.bind("<Delete>", self._delete_selected_events)
+
+        log_frame = ttk.LabelFrame(self, text="Log")
+        log_frame.pack(fill="both", expand=True, padx=10, pady=5)
+        self.log_text = tk.Text(log_frame, height=8, state="disabled")
+        self.log_text.pack(fill="both", expand=True)
+
+        hotkey_frame = ttk.LabelFrame(self, text="Hotkeys")
+        hotkey_frame.pack(fill="x", padx=10, pady=5)
+        self.hotkey_labels: Dict[str, tk.Label] = {}
+        row = 0
+        for action, label in [
+            ("start_record", "Start Record"),
+            ("stop_record", "Stop Record"),
+            ("start_macro", "Start Macro"),
+            ("stop_macro", "Stop Macro"),
+            ("save_macro", "Save Macro"),
+            ("load_macro", "Load Macro"),
+        ]:
+            ttk.Label(hotkey_frame, text=label).grid(row=row, column=0, sticky="w", padx=4, pady=2)
+            l = tk.Label(hotkey_frame, text="", relief=tk.SOLID, borderwidth=1, padx=4, pady=2, cursor="hand2")
+            l.grid(row=row, column=1, sticky="w", padx=4, pady=2)
+            l.bind("<Button-1>", lambda _e, act=action: self._start_hotkey_capture(act))
+            self.hotkey_labels[action] = l
+            row += 1
+
+    def _log(self, msg: str) -> None:
+        self.log_text.configure(state="normal")
+        self.log_text.insert("end", msg + "\n")
+        self.log_text.see("end")
+        self.log_text.configure(state="disabled")
+
+    def _refresh_hotkey_labels(self) -> None:
+        for action, label in self.hotkey_labels.items():
+            combo = self.hotkeys.get(action, [])
+            label.configure(text=format_combo(combo) if combo else "(none)")
+
+    def _dispatch_hotkey(self, action: str) -> None:
+        self.after(0, self._handle_hotkey, action)
+
+    def _handle_hotkey(self, action: str) -> None:
+        if action == "start_record":
+            self.start_recording()
+        elif action == "stop_record":
+            self.stop_recording()
+        elif action == "start_macro":
+            self.start_playback()
+        elif action == "stop_macro":
+            self.stop_playback()
+        elif action == "save_macro":
+            self.save_macro()
+        elif action == "load_macro":
+            self.load_macro()
+
+    def start_recording(self) -> None:
+        if self.recorder:
+            self.start_rec_btn.configure(state="disabled")
+            self.stop_rec_btn.configure(state="normal")
+            self.recorder.start(list(self.hotkeys.values()))
+
+    def stop_recording(self) -> None:
+        self.start_rec_btn.configure(state="normal")
+        self.stop_rec_btn.configure(state="disabled")
+        events = self.recorder.stop()
+        if events:
+            self.current_macro = Macro(name="macro", events=events)
+            self._populate_preview(self.current_macro)
+        else:
+            self._populate_preview(None)
+
+    def _populate_preview(self, macro: Optional[Macro]) -> None:
+        for item in self.preview.get_children():
+            self.preview.delete(item)
+        if not macro:
+            return
+        for idx, evt in enumerate(macro.events, start=1):
+            detail = ", ".join(f"{k}={v}" for k, v in evt.payload.items())
+            self.preview.insert("", "end", values=(idx, evt.event_type, detail, evt.delay_ms))
+
+    def _delete_selected_events(self, _event: Optional[tk.Event] = None) -> None:
+        if not self.current_macro or self.current_macro.is_empty():
+            self._log("No macro to edit")
+            return
+        selection = list(self.preview.selection())
+        if not selection:
+            self._log("No rows selected for deletion")
+            return
+        # Remove events in reverse order to keep indexes stable while popping
+        indexes = sorted((self.preview.index(item) for item in selection), reverse=True)
+        for idx in indexes:
+            if 0 <= idx < len(self.current_macro.events):
+                self.current_macro.events.pop(idx)
+        if self.current_macro.is_empty():
+            self._log("All events deleted from macro")
+        else:
+            self._log(f"Deleted {len(indexes)} event(s) from macro")
+        self._populate_preview(self.current_macro if not self.current_macro.is_empty() else None)
+
+    def start_playback(self) -> None:
+        if not self.current_macro or self.current_macro.is_empty():
+            messagebox.showwarning("Macro", "No macro loaded")
+            return
+        try:
+            repeats = int(self.repeat_var.get())
+        except ValueError:
+            messagebox.showerror("Macro", "Repeat count must be an integer")
+            return
+        if repeats < 0:
+            messagebox.showerror("Macro", "Repeat count must be >= 0")
+            return
+        self.start_play_btn.configure(state="disabled")
+        self.stop_play_btn.configure(state="normal")
+        self.player.play(self.current_macro, repeats)
+
+    def stop_playback(self) -> None:
+        self.player.stop()
+        self.start_play_btn.configure(state="normal")
+        self.stop_play_btn.configure(state="disabled")
+
+    def save_macro(self) -> None:
+        if not self.current_macro or self.current_macro.is_empty():
+            messagebox.showwarning("Save", "No macro to save")
+            return
+        name = simpledialog.askstring("Name", "Macro name", initialvalue=self.current_macro.name)
+        if not name:
+            return
+        self.current_macro.name = name
+        path_str = filedialog.asksaveasfilename(defaultextension=".csv", filetypes=[("CSV", "*.csv")], title="Save macro")
+        if not path_str:
+            return
+        save_macro_to_csv(Path(path_str), self.current_macro)
+        self._log(f"Macro '{name}' saved to {path_str}")
+
+    def load_macro(self) -> None:
+        path_str = filedialog.askopenfilename(filetypes=[("CSV", "*.csv")], title="Load macro")
+        if not path_str:
+            return
+        macros = load_macros_from_csv(Path(path_str))
+        if not macros:
+            messagebox.showerror("Load", "No macro found")
+            return
+        macro = macros[0]
+        if len(macros) > 1:
+            names = [m.name for m in macros]
+            choice = simpledialog.askstring("Selection", f"Available macros: {', '.join(names)}\nName to load:")
+            if choice:
+                for m in macros:
+                    if m.name == choice:
+                        macro = m
+                        break
+        self.current_macro = macro
+        self._populate_preview(macro)
+        self._log(f"Macro '{macro.name}' loaded")
+
+    def _start_hotkey_capture(self, action: str) -> None:
+        self._log(f"Capturing hotkey for {action}...")
+        self.hotkey_manager.stop()
+
+        def worker() -> None:
+            combo = capture_hotkey_blocking()
+            self.after(0, self._finish_capture, action, combo)
+
+        threading.Thread(target=worker, daemon=True).start()
+
+    def _finish_capture(self, action: str, combo: Optional[List[str]]) -> None:
+        if not combo or len(combo) < 2:
+            self._log("Hotkey ignored (minimum 2 keys)")
+        else:
+            self.hotkeys[action] = combo
+            save_config({"hotkeys": self.hotkeys})
+            self.hotkey_manager.update(self.hotkeys)
+            self._refresh_hotkey_labels()
+            self._log(f"Hotkey '{action}' updated: {format_combo(combo)}")
+        self.hotkey_manager.start()
+
+
+def main() -> None:
+    app = App()
+    app.mainloop()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/pymacrorecorder/config.py b/pymacrorecorder/config.py
new file mode 100644
index 0000000..9a913f1
--- /dev/null
+++ b/pymacrorecorder/config.py
@@ -0,0 +1,52 @@
+"""Configuration helpers for PyMacroRecorder."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Dict, List
+
+from appdirs import user_data_dir
+
+APP_NAME = "PyMacroRecorder"
+APP_AUTHOR = "PyMacroRecorder"
+CONFIG_NAME = "config.json"
+
+DEFAULT_HOTKEYS: Dict[str, List[str]] = {
+    "start_record": ["<ctrl>", "<alt>", "r"],
+    "stop_record": ["<ctrl>", "<alt>", "s"],
+    "start_macro": ["<ctrl>", "<alt>", "p"],
+    "stop_macro": ["<ctrl>", "<alt>", "o"],
+    "save_macro": ["<ctrl>", "<alt>", "e"],
+    "load_macro": ["<ctrl>", "<alt>", "l"],
+}
+
+
+def _config_path() -> Path:
+    data_dir = Path(user_data_dir(APP_NAME, APP_AUTHOR))
+    data_dir.mkdir(parents=True, exist_ok=True)
+    return data_dir / CONFIG_NAME
+
+
+def load_config() -> Dict[str, Dict[str, List[str]]]:
+    path = _config_path()
+    if not path.exists():
+        return {"hotkeys": DEFAULT_HOTKEYS.copy()}
+    try:
+        with path.open("r", encoding="utf-8") as fh:
+            data = json.load(fh)
+    except Exception:
+        return {"hotkeys": DEFAULT_HOTKEYS.copy()}
+    hotkeys = data.get("hotkeys", {})
+    merged = DEFAULT_HOTKEYS.copy()
+    merged.update({k: v for k, v in hotkeys.items() if isinstance(v, list)})
+    return {"hotkeys": merged}
+
+
+def save_config(config: Dict[str, Dict[str, List[str]]]) -> None:
+    path = _config_path()
+    payload = {"hotkeys": config.get("hotkeys", DEFAULT_HOTKEYS)}
+    with path.open("w", encoding="utf-8") as fh:
+        json.dump(payload, fh, indent=2)
+
+
diff --git a/pymacrorecorder/hotkeys.py b/pymacrorecorder/hotkeys.py
new file mode 100644
index 0000000..223e69f
--- /dev/null
+++ b/pymacrorecorder/hotkeys.py
@@ -0,0 +1,71 @@
+"""Global hotkey management."""
+
+from __future__ import annotations
+
+import threading
+from typing import Callable, Dict, List, Optional
+
+from pynput import keyboard
+
+from .utils import format_combo
+
+HotkeyCallback = Callable[[str], None]
+
+
+class HotkeyManager:
+    def __init__(self, mapping: Dict[str, List[str]], dispatcher: HotkeyCallback):
+        self.mapping = mapping
+        self.dispatcher = dispatcher
+        self._listener: Optional[keyboard.GlobalHotKeys] = None
+        self._lock = threading.Lock()
+
+    def start(self) -> None:
+        with self._lock:
+            self._restart()
+
+    def stop(self) -> None:
+        with self._lock:
+            if self._listener:
+                self._listener.stop()
+                self._listener = None
+
+    def update(self, mapping: Dict[str, List[str]]) -> None:
+        with self._lock:
+            self.mapping = mapping
+            self._restart()
+
+    def _restart(self) -> None:
+        if self._listener:
+            self._listener.stop()
+        hotkey_map = {format_combo(v): (lambda action=k: self.dispatcher(action)) for k, v in self.mapping.items() if len(v) >= 2}
+        if hotkey_map:
+            self._listener = keyboard.GlobalHotKeys(hotkey_map)
+            self._listener.start()
+        else:
+            self._listener = None
+
+
+def capture_hotkey_blocking(min_keys: int = 2, timeout: int = 10) -> Optional[List[str]]:
+    combo: List[str] = []
+    done = threading.Event()
+
+    def on_press(key: keyboard.Key | keyboard.KeyCode) -> None:
+        label = key.char if isinstance(key, keyboard.KeyCode) and key.char else f"<{key.name}>"
+        if label and label not in combo:
+            combo.append(label)
+
+    def on_release(_key: keyboard.Key | keyboard.KeyCode) -> bool | None:
+        if len(combo) >= min_keys:
+            done.set()
+            return False
+        return None
+
+    listener = keyboard.Listener(on_press=on_press, on_release=on_release)
+    listener.start()
+    done.wait(timeout=timeout)
+    listener.stop()
+    listener.join()
+    if len(combo) >= min_keys:
+        return combo
+    return None
+
diff --git a/pymacrorecorder/models.py b/pymacrorecorder/models.py
new file mode 100644
index 0000000..ecb61e1
--- /dev/null
+++ b/pymacrorecorder/models.py
@@ -0,0 +1,24 @@
+"""Core models for macro recording and playback."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Dict, List
+
+
+@dataclass
+class MacroEvent:
+    event_type: str
+    payload: Dict[str, object]
+    delay_ms: int
+
+
+@dataclass
+class Macro:
+    name: str
+    events: List[MacroEvent] = field(default_factory=list)
+
+    def is_empty(self) -> bool:
+        return len(self.events) == 0
+
+
diff --git a/pymacrorecorder/player.py b/pymacrorecorder/player.py
new file mode 100644
index 0000000..0a1eaf8
--- /dev/null
+++ b/pymacrorecorder/player.py
@@ -0,0 +1,77 @@
+"""Playback engine for macros."""
+
+from __future__ import annotations
+
+import threading
+import time
+from typing import Callable, Optional
+
+from pynput import keyboard, mouse
+
+from .models import Macro
+from .utils import str_to_button, str_to_key
+
+LogFn = Callable[[str], None]
+
+
+class Player:
+    def __init__(self, log_fn: Optional[LogFn] = None) -> None:
+        self.log = log_fn or (lambda _: None)
+        self._keyboard = keyboard.Controller()
+        self._mouse = mouse.Controller()
+        self._thread: Optional[threading.Thread] = None
+        self._stop_event = threading.Event()
+
+    def play(self, macro: Macro, repeats: int) -> None:
+        if self.is_running():
+            return
+        self._stop_event.clear()
+        self._thread = threading.Thread(target=self._run, args=(macro, repeats), daemon=True)
+        self._thread.start()
+        self.log(f"Playing macro '{macro.name}' (repeats: {'infinite' if repeats == 0 else repeats})")
+
+    def stop(self) -> None:
+        self._stop_event.set()
+        if self._thread and self._thread.is_alive():
+            self._thread.join(timeout=1.0)
+        self.log("Playback stopped")
+
+    def is_running(self) -> bool:
+        return self._thread is not None and self._thread.is_alive()
+
+    def _run(self, macro: Macro, repeats: int) -> None:
+        count = 0
+        while repeats == 0 or count < repeats:
+            if self._stop_event.is_set():
+                break
+            for event in macro.events:
+                if self._stop_event.is_set():
+                    break
+                time.sleep(max(event.delay_ms / 1000.0, 0))
+                self._apply_event(event)
+            count += 1
+        self._stop_event.clear()
+
+    def _apply_event(self, event) -> None:
+        etype = event.event_type
+        data = event.payload
+        if etype == "key_down":
+            self._keyboard.press(str_to_key(data.get("key", "")))
+        elif etype == "key_up":
+            self._keyboard.release(str_to_key(data.get("key", "")))
+        elif etype == "mouse_click":
+            button = str_to_button(data.get("button", "left"))
+            action = data.get("action", "press")
+            x = data.get("x")
+            y = data.get("y")
+            if x is not None and y is not None:
+                self._mouse.position = (x, y)
+            if action == "press":
+                self._mouse.press(button)
+            else:
+                self._mouse.release(button)
+        elif etype == "mouse_scroll":
+            self._mouse.position = (data.get("x", 0), data.get("y", 0))
+            self._mouse.scroll(data.get("dx", 0), data.get("dy", 0))
+        elif etype == "mouse_move":
+            self._mouse.position = (data.get("x", 0), data.get("y", 0))
diff --git a/pymacrorecorder/recorder.py b/pymacrorecorder/recorder.py
new file mode 100644
index 0000000..e1d5836
--- /dev/null
+++ b/pymacrorecorder/recorder.py
@@ -0,0 +1,102 @@
+"""Global recorder for keyboard and mouse events."""
+
+from __future__ import annotations
+
+import threading
+import time
+from typing import Callable, List, Optional, Set
+
+from pynput import keyboard, mouse
+
+from .models import MacroEvent
+from .utils import button_to_str, key_to_str, pressed_matches_hotkey, combos_as_sets
+
+LogFn = Callable[[str], None]
+
+
+class Recorder:
+    def __init__(self, log_fn: Optional[LogFn] = None) -> None:
+        self.log = log_fn or (lambda _: None)
+        self._keyboard_listener: Optional[keyboard.Listener] = None
+        self._mouse_listener: Optional[mouse.Listener] = None
+        self._last_time: float = 0.0
+        self._events: List[MacroEvent] = []
+        self._running = threading.Event()
+        self._pressed: Set[str] = set()
+        self._hotkeys: List[Set[str]] = []
+
+    def start(self, ignored_hotkeys: List[List[str]]) -> None:
+        if self._running.is_set():
+            return
+        self._hotkeys = combos_as_sets(ignored_hotkeys)
+        self._events = []
+        self._last_time = time.time()
+        self._running.set()
+        self._pressed.clear()
+        self._keyboard_listener = keyboard.Listener(on_press=self._on_key_press, on_release=self._on_key_release)
+        self._mouse_listener = mouse.Listener(on_click=self._on_click, on_scroll=self._on_scroll, on_move=self._on_move)
+        self._keyboard_listener.start()
+        self._mouse_listener.start()
+        self.log("Recording started")
+
+    def stop(self) -> List[MacroEvent]:
+        if not self._running.is_set():
+            return []
+        self._running.clear()
+        if self._keyboard_listener:
+            self._keyboard_listener.stop()
+            self._keyboard_listener = None
+        if self._mouse_listener:
+            self._mouse_listener.stop()
+            self._mouse_listener = None
+        self.log(f"Recording stopped ({len(self._events)} events)")
+        return list(self._events)
+
+    def _add_event(self, event_type: str, payload: dict) -> None:
+        now = time.time()
+        delay_ms = 0 if not self._events else int((now - self._last_time) * 1000)
+        self._last_time = now
+        self._events.append(MacroEvent(event_type=event_type, payload=payload, delay_ms=delay_ms))
+
+    def _should_ignore(self, pressed_snapshot: Set[str]) -> bool:
+        return pressed_matches_hotkey(pressed_snapshot, self._hotkeys)
+
+    def _on_key_press(self, key: keyboard.Key | keyboard.KeyCode) -> None:
+        if not self._running.is_set():
+            return
+        label = key_to_str(key)
+        self._pressed.add(label)
+        if self._should_ignore(self._pressed):
+            return
+        self._add_event("key_down", {"key": label})
+
+    def _on_key_release(self, key: keyboard.Key | keyboard.KeyCode) -> None:
+        if not self._running.is_set():
+            return
+        label = key_to_str(key)
+        if self._should_ignore(self._pressed):
+            self._pressed.discard(label)
+            return
+        self._add_event("key_up", {"key": label})
+        self._pressed.discard(label)
+
+    def _on_click(self, x: int, y: int, button: mouse.Button, pressed: bool) -> None:
+        if not self._running.is_set():
+            return
+        if self._should_ignore(self._pressed):
+            return
+        self._add_event("mouse_click", {"x": x, "y": y, "button": button_to_str(button), "action": "press" if pressed else "release"})
+
+    def _on_scroll(self, x: int, y: int, dx: int, dy: int) -> None:
+        if not self._running.is_set():
+            return
+        if self._should_ignore(self._pressed):
+            return
+        self._add_event("mouse_scroll", {"x": x, "y": y, "dx": dx, "dy": dy})
+
+    def _on_move(self, x: int, y: int) -> None:
+        if not self._running.is_set():
+            return
+        if self._should_ignore(self._pressed):
+            return
+        self._add_event("mouse_move", {"x": x, "y": y})
diff --git a/pymacrorecorder/storage.py b/pymacrorecorder/storage.py
new file mode 100644
index 0000000..721405a
--- /dev/null
+++ b/pymacrorecorder/storage.py
@@ -0,0 +1,38 @@
+"""CSV persistence for macros and hotkeys."""
+
+from __future__ import annotations
+
+import csv
+import json
+from pathlib import Path
+from typing import List
+
+from .models import Macro, MacroEvent
+
+CSV_FIELDS = ["name", "events"]
+
+
+def save_macro_to_csv(path: Path, macro: Macro) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("w", newline="", encoding="utf-8") as fh:
+        writer = csv.DictWriter(fh, fieldnames=CSV_FIELDS)
+        writer.writeheader()
+        writer.writerow({
+            "name": macro.name,
+            "events": json.dumps([event.__dict__ for event in macro.events]),
+        })
+
+
+def load_macros_from_csv(path: Path) -> List[Macro]:
+    macros: List[Macro] = []
+    if not path.exists():
+        return macros
+    with path.open("r", newline="", encoding="utf-8") as fh:
+        reader = csv.DictReader(fh)
+        for row in reader:
+            raw_events = json.loads(row.get("events", "[]"))
+            events = [MacroEvent(**evt) for evt in raw_events]
+            macros.append(Macro(name=row.get("name", "macro"), events=events))
+    return macros
+
+
diff --git a/pymacrorecorder/utils.py b/pymacrorecorder/utils.py
new file mode 100644
index 0000000..9244afe
--- /dev/null
+++ b/pymacrorecorder/utils.py
@@ -0,0 +1,63 @@
+"""Utility helpers for key/button normalization and formatting."""
+
+from __future__ import annotations
+
+from typing import Iterable, List, Set
+
+from pynput import keyboard, mouse
+
+
+def key_to_str(key: keyboard.Key | keyboard.KeyCode) -> str:
+    if isinstance(key, keyboard.KeyCode):
+        if key.char:
+            return key.char
+        if key.vk is not None:
+            return f"<vk_{key.vk}>"
+        return ""
+    return f"<{key.name}>" if key.name else ""
+
+
+def button_to_str(btn: mouse.Button) -> str:
+    return btn.name if hasattr(btn, "name") else str(btn)
+
+
+def str_to_key(label: str) -> keyboard.Key | keyboard.KeyCode:
+    if not label:
+        return keyboard.KeyCode.from_char(" ")
+    if label.startswith("<") and label.endswith(">"):
+        name = label[1:-1]
+        if name.startswith("vk_"):
+            try:
+                return keyboard.KeyCode.from_vk(int(name.replace("vk_", "")))
+            except ValueError:
+                return keyboard.KeyCode.from_char(" ")
+        try:
+            return keyboard.Key[name]
+        except KeyError:
+            return keyboard.KeyCode.from_char(name[0])
+    if len(label) == 1:
+        return keyboard.KeyCode.from_char(label)
+    # Fallback: take first char to avoid crashes on invalid labels
+    return keyboard.KeyCode.from_char(label[0])
+
+
+def str_to_button(label: str) -> mouse.Button:
+    try:
+        return mouse.Button[label]
+    except KeyError:
+        try:
+            return mouse.Button(int(label))  # handle numeric value
+        except Exception:
+            return mouse.Button.left
+
+
+def format_combo(combo: Iterable[str]) -> str:
+    return "+".join(combo)
+
+
+def combos_as_sets(mapping: Iterable[List[str]]) -> List[Set[str]]:
+    return [set(x) for x in mapping]
+
+
+def pressed_matches_hotkey(pressed: Set[str], hotkeys: List[Set[str]]) -> bool:
+    return any(hk.issubset(pressed) for hk in hotkeys)

From 6b6dd981b6fe515041ab57125936accedac89e50 Mon Sep 17 00:00:00 2001
From: Redstoneur <alfa.aog36@gmail.com>
Date: Mon, 16 Feb 2026 23:00:55 +0100
Subject: [PATCH 05/20] Add CI and Release workflows for automated testing and
 packaging

---
 .github/workflows/ci.yml      | 38 +++++++++++++++++++++
 .github/workflows/release.yml | 64 +++++++++++++++++++++++++++++++++++
 2 files changed, 102 insertions(+)
 create mode 100644 .github/workflows/ci.yml
 create mode 100644 .github/workflows/release.yml

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
new file mode 100644
index 0000000..b7b7e60
--- /dev/null
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,38 @@
+name: CI
+
+on:
+  pull_request:
+    branches:
+      - dev
+      - master
+
+jobs:
+  lint-and-test:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          python -m pip install -r requirements.txt
+          python -m pip install pylint ruff pytest
+
+      - name: Run pylint
+        run: |
+          pylint pymacrorecorder main.py
+
+      - name: Run ruff
+        run: |
+          ruff check pymacrorecorder main.py
+
+      - name: Run pytest
+        run: |
+          pytest
+
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
new file mode 100644
index 0000000..9f3622a
--- /dev/null
+++ b/.github/workflows/release.yml
@@ -0,0 +1,64 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+jobs:
+  build:
+    name: Build (${{ matrix.os }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        include:
+          - os: ubuntu-latest
+            pyinstaller_os: linux
+            extension: ""
+          - os: windows-latest
+            pyinstaller_os: windows
+            extension: .exe
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          python -m pip install -r requirements.txt
+          python -m pip install pyinstaller
+
+      - name: Build binary
+        run: |
+          pyinstaller --onefile --name PyMacroRecorder main.py
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: PyMacroRecorder-${{ matrix.pyinstaller_os }}${{ matrix.extension }}
+          path: dist/PyMacroRecorder${{ matrix.extension }}
+
+  release:
+    name: Publish Release
+    runs-on: ubuntu-latest
+    needs: build
+    steps:
+      - name: Download artifacts
+        uses: actions/download-artifact@v4
+        with:
+          path: ./artifacts
+
+      - name: Create GitHub Release
+        uses: softprops/action-gh-release@v2
+        with:
+          files: |
+            artifacts/**/PyMacroRecorder
+            artifacts/**/PyMacroRecorder.exe
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+

From 5e700d97f7be22db712cde46752fbc781a1f7c71 Mon Sep 17 00:00:00 2001
From: Redstoneur <alfa.aog36@gmail.com>
Date: Mon, 16 Feb 2026 23:28:09 +0100
Subject: [PATCH 06/20] Refactor code for improved readability and
 maintainability; normalize hotkey handling and enhance event logging

---
 pymacrorecorder/app.py      | 34 ++++++++++++++++++++++------------
 pymacrorecorder/config.py   | 18 ++++++++++++++----
 pymacrorecorder/hotkeys.py  | 17 ++++++++++++-----
 pymacrorecorder/player.py   |  4 +++-
 pymacrorecorder/recorder.py | 18 +++++++++++++++---
 pymacrorecorder/utils.py    | 30 ++++++++++++++++++++++++++++++
 6 files changed, 96 insertions(+), 25 deletions(-)

diff --git a/pymacrorecorder/app.py b/pymacrorecorder/app.py
index ee6bbaf..5014d90 100644
--- a/pymacrorecorder/app.py
+++ b/pymacrorecorder/app.py
@@ -37,12 +37,15 @@ def _build_ui(self) -> None:
         controls.pack(fill="x", padx=10, pady=5)
 
         self.start_rec_btn = ttk.Button(controls, text="Start Record", command=self.start_recording)
-        self.stop_rec_btn = ttk.Button(controls, text="Stop Record", command=self.stop_recording, state="disabled")
+        self.stop_rec_btn = ttk.Button(controls, text="Stop Record", command=self.stop_recording,
+                                       state="disabled")
         self.start_play_btn = ttk.Button(controls, text="Start Macro", command=self.start_playback)
-        self.stop_play_btn = ttk.Button(controls, text="Stop Macro", command=self.stop_playback, state="disabled")
+        self.stop_play_btn = ttk.Button(controls, text="Stop Macro", command=self.stop_playback,
+                                        state="disabled")
         self.save_btn = ttk.Button(controls, text="Save Macro", command=self.save_macro)
         self.load_btn = ttk.Button(controls, text="Load Macro", command=self.load_macro)
-        self.delete_btn = ttk.Button(controls, text="Delete Selected", command=self._delete_selected_events)
+        self.delete_btn = ttk.Button(controls, text="Delete Selected",
+                                     command=self._delete_selected_events)
 
         self.start_rec_btn.grid(row=0, column=0, padx=5, pady=2)
         self.stop_rec_btn.grid(row=0, column=1, padx=5, pady=2)
@@ -70,7 +73,7 @@ def _build_ui(self) -> None:
         for col in columns:
             self.preview.column(col, width=150, anchor="w")
         self.preview.pack(fill="both", expand=True)
-        self.preview.bind("<Delete>", self._delete_selected_events)
+        self.preview.bind("<Delete>", lambda e: self._delete_selected_events())
 
         log_frame = ttk.LabelFrame(self, text="Log")
         log_frame.pack(fill="both", expand=True, padx=10, pady=5)
@@ -90,10 +93,11 @@ def _build_ui(self) -> None:
             ("load_macro", "Load Macro"),
         ]:
             ttk.Label(hotkey_frame, text=label).grid(row=row, column=0, sticky="w", padx=4, pady=2)
-            l = tk.Label(hotkey_frame, text="", relief=tk.SOLID, borderwidth=1, padx=4, pady=2, cursor="hand2")
-            l.grid(row=row, column=1, sticky="w", padx=4, pady=2)
-            l.bind("<Button-1>", lambda _e, act=action: self._start_hotkey_capture(act))
-            self.hotkey_labels[action] = l
+            hotkey_label = tk.Label(hotkey_frame, text="", relief="solid", borderwidth=1,
+                                    padx=4, pady=2, cursor="hand2")
+            hotkey_label.grid(row=row, column=1, sticky="w", padx=4, pady=2)
+            hotkey_label.bind("<Button-1>", lambda _e, act=action: self._start_hotkey_capture(act))
+            self.hotkey_labels[action] = hotkey_label
             row += 1
 
     def _log(self, msg: str) -> None:
@@ -147,7 +151,8 @@ def _populate_preview(self, macro: Optional[Macro]) -> None:
             return
         for idx, evt in enumerate(macro.events, start=1):
             detail = ", ".join(f"{k}={v}" for k, v in evt.payload.items())
-            self.preview.insert("", "end", values=(idx, evt.event_type, detail, evt.delay_ms))
+            self.preview.insert("", "end", values=(idx, evt.event_type, detail,
+                                                   evt.delay_ms))
 
     def _delete_selected_events(self, _event: Optional[tk.Event] = None) -> None:
         if not self.current_macro or self.current_macro.is_empty():
@@ -193,11 +198,13 @@ def save_macro(self) -> None:
         if not self.current_macro or self.current_macro.is_empty():
             messagebox.showwarning("Save", "No macro to save")
             return
-        name = simpledialog.askstring("Name", "Macro name", initialvalue=self.current_macro.name)
+        name = simpledialog.askstring("Name", "Macro name",
+                                      initialvalue=self.current_macro.name)
         if not name:
             return
         self.current_macro.name = name
-        path_str = filedialog.asksaveasfilename(defaultextension=".csv", filetypes=[("CSV", "*.csv")], title="Save macro")
+        path_str = filedialog.asksaveasfilename(defaultextension=".csv",
+                                                filetypes=[("CSV", "*.csv")], title="Save macro")
         if not path_str:
             return
         save_macro_to_csv(Path(path_str), self.current_macro)
@@ -214,7 +221,10 @@ def load_macro(self) -> None:
         macro = macros[0]
         if len(macros) > 1:
             names = [m.name for m in macros]
-            choice = simpledialog.askstring("Selection", f"Available macros: {', '.join(names)}\nName to load:")
+            choice = simpledialog.askstring(
+                "Selection",
+                f"Available macros: {', '.join(names)}\nName to load:"
+            )
             if choice:
                 for m in macros:
                     if m.name == choice:
diff --git a/pymacrorecorder/config.py b/pymacrorecorder/config.py
index 9a913f1..d69c949 100644
--- a/pymacrorecorder/config.py
+++ b/pymacrorecorder/config.py
@@ -8,6 +8,8 @@
 
 from appdirs import user_data_dir
 
+from .utils import format_combo, is_parseable_hotkey, normalize_combo
+
 APP_NAME = "PyMacroRecorder"
 APP_AUTHOR = "PyMacroRecorder"
 CONFIG_NAME = "config.json"
@@ -40,13 +42,21 @@ def load_config() -> Dict[str, Dict[str, List[str]]]:
     hotkeys = data.get("hotkeys", {})
     merged = DEFAULT_HOTKEYS.copy()
     merged.update({k: v for k, v in hotkeys.items() if isinstance(v, list)})
-    return {"hotkeys": merged}
+    sanitized: Dict[str, List[str]] = {}
+    for action, combo in merged.items():
+        normalized = normalize_combo(combo)
+        combo_str = format_combo(normalized)
+        if is_parseable_hotkey(combo_str):
+            sanitized[action] = normalized
+        else:
+            sanitized[action] = DEFAULT_HOTKEYS.get(action, DEFAULT_HOTKEYS["start_record"])
+    return {"hotkeys": sanitized}
 
 
 def save_config(config: Dict[str, Dict[str, List[str]]]) -> None:
     path = _config_path()
-    payload = {"hotkeys": config.get("hotkeys", DEFAULT_HOTKEYS)}
+    hotkeys = config.get("hotkeys", DEFAULT_HOTKEYS)
+    normalized = {k: normalize_combo(v) for k, v in hotkeys.items()}
+    payload = {"hotkeys": normalized}
     with path.open("w", encoding="utf-8") as fh:
         json.dump(payload, fh, indent=2)
-
-
diff --git a/pymacrorecorder/hotkeys.py b/pymacrorecorder/hotkeys.py
index 223e69f..4713a11 100644
--- a/pymacrorecorder/hotkeys.py
+++ b/pymacrorecorder/hotkeys.py
@@ -7,7 +7,7 @@
 
 from pynput import keyboard
 
-from .utils import format_combo
+from .utils import format_combo, is_parseable_hotkey, key_to_str, normalize_combo
 
 HotkeyCallback = Callable[[str], None]
 
@@ -37,7 +37,15 @@ def update(self, mapping: Dict[str, List[str]]) -> None:
     def _restart(self) -> None:
         if self._listener:
             self._listener.stop()
-        hotkey_map = {format_combo(v): (lambda action=k: self.dispatcher(action)) for k, v in self.mapping.items() if len(v) >= 2}
+        hotkey_map: Dict[str, Callable[[], None]] = {}
+        for action, combo in self.mapping.items():
+            if len(combo) < 2:
+                continue
+            normalized = normalize_combo(combo)
+            combo_str = format_combo(normalized)
+            if not is_parseable_hotkey(combo_str):
+                continue
+            hotkey_map[combo_str] = lambda action=action: self.dispatcher(action)
         if hotkey_map:
             self._listener = keyboard.GlobalHotKeys(hotkey_map)
             self._listener.start()
@@ -50,7 +58,7 @@ def capture_hotkey_blocking(min_keys: int = 2, timeout: int = 10) -> Optional[Li
     done = threading.Event()
 
     def on_press(key: keyboard.Key | keyboard.KeyCode) -> None:
-        label = key.char if isinstance(key, keyboard.KeyCode) and key.char else f"<{key.name}>"
+        label = key_to_str(key)
         if label and label not in combo:
             combo.append(label)
 
@@ -66,6 +74,5 @@ def on_release(_key: keyboard.Key | keyboard.KeyCode) -> bool | None:
     listener.stop()
     listener.join()
     if len(combo) >= min_keys:
-        return combo
+        return normalize_combo(combo)
     return None
-
diff --git a/pymacrorecorder/player.py b/pymacrorecorder/player.py
index 0a1eaf8..6906bd2 100644
--- a/pymacrorecorder/player.py
+++ b/pymacrorecorder/player.py
@@ -28,7 +28,9 @@ def play(self, macro: Macro, repeats: int) -> None:
         self._stop_event.clear()
         self._thread = threading.Thread(target=self._run, args=(macro, repeats), daemon=True)
         self._thread.start()
-        self.log(f"Playing macro '{macro.name}' (repeats: {'infinite' if repeats == 0 else repeats})")
+        self.log(
+            f"Playing macro '{macro.name}' (repeats: {'infinite' if repeats == 0 else repeats})"
+        )
 
     def stop(self) -> None:
         self._stop_event.set()
diff --git a/pymacrorecorder/recorder.py b/pymacrorecorder/recorder.py
index e1d5836..646e26f 100644
--- a/pymacrorecorder/recorder.py
+++ b/pymacrorecorder/recorder.py
@@ -33,8 +33,12 @@ def start(self, ignored_hotkeys: List[List[str]]) -> None:
         self._last_time = time.time()
         self._running.set()
         self._pressed.clear()
-        self._keyboard_listener = keyboard.Listener(on_press=self._on_key_press, on_release=self._on_key_release)
-        self._mouse_listener = mouse.Listener(on_click=self._on_click, on_scroll=self._on_scroll, on_move=self._on_move)
+        self._keyboard_listener = keyboard.Listener(
+            on_press=self._on_key_press, on_release=self._on_key_release
+        )
+        self._mouse_listener = mouse.Listener(
+            on_click=self._on_click, on_scroll=self._on_scroll, on_move=self._on_move
+        )
         self._keyboard_listener.start()
         self._mouse_listener.start()
         self.log("Recording started")
@@ -85,7 +89,15 @@ def _on_click(self, x: int, y: int, button: mouse.Button, pressed: bool) -> None
             return
         if self._should_ignore(self._pressed):
             return
-        self._add_event("mouse_click", {"x": x, "y": y, "button": button_to_str(button), "action": "press" if pressed else "release"})
+        self._add_event(
+            "mouse_click",
+            {
+                "x": x,
+                "y": y,
+                "button": button_to_str(button),
+                "action": "press" if pressed else "release"
+            }
+        )
 
     def _on_scroll(self, x: int, y: int, dx: int, dy: int) -> None:
         if not self._running.is_set():
diff --git a/pymacrorecorder/utils.py b/pymacrorecorder/utils.py
index 9244afe..6e171f2 100644
--- a/pymacrorecorder/utils.py
+++ b/pymacrorecorder/utils.py
@@ -21,6 +21,36 @@ def button_to_str(btn: mouse.Button) -> str:
     return btn.name if hasattr(btn, "name") else str(btn)
 
 
+def normalize_label(label: str) -> str:
+    if label.startswith("<") and label.endswith(">"):
+        inner = label[1:-1]
+        if inner.startswith("vk_"):
+            try:
+                vk = int(inner.replace("vk_", ""))
+            except ValueError:
+                return label
+            if 0x30 <= vk <= 0x39:  # digits
+                return chr(vk)
+            if 0x41 <= vk <= 0x5A:  # letters A-Z
+                return chr(vk + 32)  # lower-case alpha for pynput parser
+        return f"<{inner.lower()}>"
+    if len(label) == 1:
+        return label.lower()
+    return label
+
+
+def normalize_combo(combo: Iterable[str]) -> List[str]:
+    return [normalize_label(x) for x in combo]
+
+
+def is_parseable_hotkey(combo_str: str) -> bool:
+    try:
+        keyboard.HotKey.parse(combo_str)
+        return True
+    except Exception:
+        return False
+
+
 def str_to_key(label: str) -> keyboard.Key | keyboard.KeyCode:
     if not label:
         return keyboard.KeyCode.from_char(" ")

From 401ddc2b268e3b8311e3ce32e11daf979a41fcca Mon Sep 17 00:00:00 2001
From: Redstoneur <alfa.aog36@gmail.com>
Date: Mon, 16 Feb 2026 23:33:20 +0100
Subject: [PATCH 07/20] Update package API to expose key components and improve
 module accessibility

---
 pymacrorecorder/__init__.py | 19 ++++++++++++++++++-
 1 file changed, 18 insertions(+), 1 deletion(-)

diff --git a/pymacrorecorder/__init__.py b/pymacrorecorder/__init__.py
index aa72291..d59520b 100644
--- a/pymacrorecorder/__init__.py
+++ b/pymacrorecorder/__init__.py
@@ -1,7 +1,24 @@
-"""PyMacroRecorder package initialization."""
+"""PyMacroRecorder package public API."""
 
 from .app import App
+from .config import DEFAULT_HOTKEYS, load_config, save_config
+from .hotkeys import HotkeyManager, capture_hotkey_blocking
+from .models import Macro, MacroEvent
+from .player import Player
+from .recorder import Recorder
+from .storage import load_macros_from_csv, save_macro_to_csv
 
 __all__ = [
     "App",
+    "Recorder",
+    "Player",
+    "Macro",
+    "MacroEvent",
+    "HotkeyManager",
+    "capture_hotkey_blocking",
+    "DEFAULT_HOTKEYS",
+    "load_config",
+    "save_config",
+    "load_macros_from_csv",
+    "save_macro_to_csv",
 ]

From c9c2480a33939761c61010f6ff2cb9f384f082aa Mon Sep 17 00:00:00 2001
From: Redstoneur <alfa.aog36@gmail.com>
Date: Tue, 17 Feb 2026 00:16:43 +0100
Subject: [PATCH 08/20] Add CI workflows for building binaries on multiple
 platforms and streamline build scripts

---
 .github/workflows/ci.yml      | 42 +++++++++++++++++++++++++++++++++++
 .github/workflows/release.yml | 17 +++++++++-----
 build.ps1                     |  7 +-----
 build.sh                      |  7 +-----
 4 files changed, 55 insertions(+), 18 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index b7b7e60..7ea9198 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -36,3 +36,45 @@ jobs:
         run: |
           pytest
 
+  build-binaries:
+    name: Build binaries (${{ matrix.os }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        include:
+          - os: ubuntu-latest
+            extension: ""
+            shell: bash
+            run_cmd: bash build.sh
+          - os: windows-latest
+            extension: .exe
+            shell: pwsh
+            run_cmd: .\\build.ps1
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          python -m pip install -r requirements.txt
+          python -m pip install pyinstaller
+
+      - name: Make build script executable
+        if: runner.os != 'Windows'
+        run: chmod +x build.sh
+
+      - name: Build binary
+        run: ${{ matrix.run_cmd }}
+        shell: ${{ matrix.shell }}
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: PyMacroRecorder-${{ runner.os }}${{ matrix.extension }}
+          path: dist/PyMacroRecorder${{ matrix.extension }}
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 9f3622a..0ade599 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -13,11 +13,13 @@ jobs:
       matrix:
         include:
           - os: ubuntu-latest
-            pyinstaller_os: linux
             extension: ""
+            shell: bash
+            run_cmd: bash build.sh
           - os: windows-latest
-            pyinstaller_os: windows
             extension: .exe
+            shell: pwsh
+            run_cmd: .\\build.ps1
     steps:
       - name: Checkout
         uses: actions/checkout@v4
@@ -33,14 +35,18 @@ jobs:
           python -m pip install -r requirements.txt
           python -m pip install pyinstaller
 
+      - name: Make build script executable
+        if: runner.os != 'Windows'
+        run: chmod +x build.sh
+
       - name: Build binary
-        run: |
-          pyinstaller --onefile --name PyMacroRecorder main.py
+        run: ${{ matrix.run_cmd }}
+        shell: ${{ matrix.shell }}
 
       - name: Upload artifact
         uses: actions/upload-artifact@v4
         with:
-          name: PyMacroRecorder-${{ matrix.pyinstaller_os }}${{ matrix.extension }}
+          name: PyMacroRecorder-${{ runner.os }}${{ matrix.extension }}
           path: dist/PyMacroRecorder${{ matrix.extension }}
 
   release:
@@ -61,4 +67,3 @@ jobs:
             artifacts/**/PyMacroRecorder.exe
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
diff --git a/build.ps1 b/build.ps1
index 3ff3c87..15cc26e 100644
--- a/build.ps1
+++ b/build.ps1
@@ -13,12 +13,7 @@ $AppName = "PyMacroRecorder"
 Remove-Item -Recurse -Force -ErrorAction SilentlyContinue $DistDir, $BuildDir, $SpecFile
 
 # Run pyinstaller
-pyinstaller \
-  --onefile \
-  --name "$AppName" \
-  --distpath "$DistDir" \
-  --workpath "$BuildDir" \
-  "$EntryPoint"
+pyinstaller --onefile --name "$AppName" --distpath "$DistDir" --workpath "$BuildDir" "$EntryPoint"
 
 Write-Host "Build complete. Binary located at: $DistDir\$AppName.exe"
 
diff --git a/build.sh b/build.sh
index 6798dd5..478db7d 100644
--- a/build.sh
+++ b/build.sh
@@ -14,12 +14,7 @@ APP_NAME="PyMacroRecorder"
 rm -rf "$DIST_DIR" "$BUILD_DIR" "$SPEC_FILE"
 
 # Run pyinstaller
-pyinstaller \
-  --onefile \
-  --name "$APP_NAME" \
-  --distpath "$DIST_DIR" \
-  --workpath "$BUILD_DIR" \
-  "$ENTRYPOINT"
+pyinstaller --onefile --name "$APP_NAME" --distpath "$DIST_DIR" --workpath "$BUILD_DIR" "$ENTRYPOINT"
 
 # Print result path
 echo "Build complete. Binary located at: $DIST_DIR/$APP_NAME"

From 0364b146fab25e9c11162840528c163eee1482d5 Mon Sep 17 00:00:00 2001
From: Redstoneur <alfa.aog36@gmail.com>
Date: Tue, 17 Feb 2026 11:30:25 +0100
Subject: [PATCH 09/20] Add detailed docstrings for classes and methods to
 improve code documentation

---
 CONTRIBUTING.md             |   7 ++-
 main.py                     |   8 ++-
 pymacrorecorder/app.py      | 103 ++++++++++++++++++++++++++++++++++++
 pymacrorecorder/config.py   |  17 ++++++
 pymacrorecorder/hotkeys.py  |  42 +++++++++++++++
 pymacrorecorder/models.py   |  25 ++++++++-
 pymacrorecorder/player.py   |  40 ++++++++++++++
 pymacrorecorder/recorder.py |  86 ++++++++++++++++++++++++++++++
 pymacrorecorder/storage.py  |  17 +++++-
 pymacrorecorder/utils.py    |  72 +++++++++++++++++++++++++
 10 files changed, 413 insertions(+), 4 deletions(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 5bb3c56..59178a2 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -21,8 +21,13 @@ Thanks for your interest in improving PyMacroRecorder!
 - Ensure new features work on both Windows and Linux.
 - When adding storage or settings, keep JSON format and update `pymacrorecorder/config.py` as needed.
 
+## Docstrings
+- All Python docstrings must use Sphinx reStructuredText (reST) style.
+- Include ``:param:``, ``:type:``, ``:return:``, ``:rtype:``, and ``:raises:`` as appropriate.
+- Google or NumPy docstring styles are not allowed.
+- Provide docstrings for every module, class, and public function/method.
+
 ## Submitting changes
 - Create a feature branch for your work.
 - Add or update documentation for new behavior.
 - Open a pull request summarizing the change, testing performed, and any platform-specific notes.
-
diff --git a/main.py b/main.py
index 28912c6..ec69e19 100644
--- a/main.py
+++ b/main.py
@@ -1,11 +1,17 @@
+"""CLI entry point for running the PyMacroRecorder application."""
+
 from pymacrorecorder.app import App
 
 
 def main() -> None:
+    """Launch the Tkinter application window and start the main event loop.
+
+    :return: Nothing.
+    :rtype: None
+    """
     app = App()
     app.mainloop()
 
 
 if __name__ == "__main__":
     main()
-
diff --git a/pymacrorecorder/app.py b/pymacrorecorder/app.py
index 5014d90..7711ddc 100644
--- a/pymacrorecorder/app.py
+++ b/pymacrorecorder/app.py
@@ -16,7 +16,14 @@
 
 
 class App(tk.Tk):
+    """Main Tkinter window that orchestrates recording, playback, and storage."""
+
     def __init__(self) -> None:
+        """Initialize the application window, services, and global hotkeys.
+
+        :return: Nothing.
+        :rtype: None
+        """
         super().__init__()
         self.title("PyMacroRecorder")
         self.geometry("900x600")
@@ -33,6 +40,11 @@ def __init__(self) -> None:
         self.hotkey_manager.start()
 
     def _build_ui(self) -> None:
+        """Build the control bar, preview tree, log area, and hotkey editor.
+
+        :return: Nothing.
+        :rtype: None
+        """
         controls = ttk.Frame(self)
         controls.pack(fill="x", padx=10, pady=5)
 
@@ -101,20 +113,46 @@ def _build_ui(self) -> None:
             row += 1
 
     def _log(self, msg: str) -> None:
+        """Append a log line to the log text widget.
+
+        :param msg: Message to display.
+        :type msg: str
+        :return: Nothing.
+        :rtype: None
+        """
         self.log_text.configure(state="normal")
         self.log_text.insert("end", msg + "\n")
         self.log_text.see("end")
         self.log_text.configure(state="disabled")
 
     def _refresh_hotkey_labels(self) -> None:
+        """Refresh hotkey label text to reflect current mappings.
+
+        :return: Nothing.
+        :rtype: None
+        """
         for action, label in self.hotkey_labels.items():
             combo = self.hotkeys.get(action, [])
             label.configure(text=format_combo(combo) if combo else "(none)")
 
     def _dispatch_hotkey(self, action: str) -> None:
+        """Dispatch a captured hotkey action onto the Tkinter event loop.
+
+        :param action: Action key to perform.
+        :type action: str
+        :return: Nothing.
+        :rtype: None
+        """
         self.after(0, self._handle_hotkey, action)
 
     def _handle_hotkey(self, action: str) -> None:
+        """Handle hotkey actions by invoking the matching command.
+
+        :param action: Action identifier from the hotkey map.
+        :type action: str
+        :return: Nothing.
+        :rtype: None
+        """
         if action == "start_record":
             self.start_recording()
         elif action == "stop_record":
@@ -129,12 +167,22 @@ def _handle_hotkey(self, action: str) -> None:
             self.load_macro()
 
     def start_recording(self) -> None:
+        """Begin recording input events and update control states.
+
+        :return: Nothing.
+        :rtype: None
+        """
         if self.recorder:
             self.start_rec_btn.configure(state="disabled")
             self.stop_rec_btn.configure(state="normal")
             self.recorder.start(list(self.hotkeys.values()))
 
     def stop_recording(self) -> None:
+        """Stop recording and populate preview with recorded events.
+
+        :return: Nothing.
+        :rtype: None
+        """
         self.start_rec_btn.configure(state="normal")
         self.stop_rec_btn.configure(state="disabled")
         events = self.recorder.stop()
@@ -145,6 +193,13 @@ def stop_recording(self) -> None:
             self._populate_preview(None)
 
     def _populate_preview(self, macro: Optional[Macro]) -> None:
+        """Fill the preview tree with macro events.
+
+        :param macro: Macro to preview or ``None`` to clear.
+        :type macro: Macro | None
+        :return: Nothing.
+        :rtype: None
+        """
         for item in self.preview.get_children():
             self.preview.delete(item)
         if not macro:
@@ -155,6 +210,13 @@ def _populate_preview(self, macro: Optional[Macro]) -> None:
                                                    evt.delay_ms))
 
     def _delete_selected_events(self, _event: Optional[tk.Event] = None) -> None:
+        """Delete selected events from the current macro and update preview.
+
+        :param _event: Optional Tk event when triggered from key binding.
+        :type _event: tk.Event | None
+        :return: Nothing.
+        :rtype: None
+        """
         if not self.current_macro or self.current_macro.is_empty():
             self._log("No macro to edit")
             return
@@ -174,6 +236,11 @@ def _delete_selected_events(self, _event: Optional[tk.Event] = None) -> None:
         self._populate_preview(self.current_macro if not self.current_macro.is_empty() else None)
 
     def start_playback(self) -> None:
+        """Start macro playback with the configured repeat count.
+
+        :return: Nothing.
+        :rtype: None
+        """
         if not self.current_macro or self.current_macro.is_empty():
             messagebox.showwarning("Macro", "No macro loaded")
             return
@@ -190,11 +257,21 @@ def start_playback(self) -> None:
         self.player.play(self.current_macro, repeats)
 
     def stop_playback(self) -> None:
+        """Stop macro playback and restore control states.
+
+        :return: Nothing.
+        :rtype: None
+        """
         self.player.stop()
         self.start_play_btn.configure(state="normal")
         self.stop_play_btn.configure(state="disabled")
 
     def save_macro(self) -> None:
+        """Prompt for a file name and persist the current macro to CSV.
+
+        :return: Nothing.
+        :rtype: None
+        """
         if not self.current_macro or self.current_macro.is_empty():
             messagebox.showwarning("Save", "No macro to save")
             return
@@ -211,6 +288,11 @@ def save_macro(self) -> None:
         self._log(f"Macro '{name}' saved to {path_str}")
 
     def load_macro(self) -> None:
+        """Load a macro from CSV and update preview and current state.
+
+        :return: Nothing.
+        :rtype: None
+        """
         path_str = filedialog.askopenfilename(filetypes=[("CSV", "*.csv")], title="Load macro")
         if not path_str:
             return
@@ -235,6 +317,13 @@ def load_macro(self) -> None:
         self._log(f"Macro '{macro.name}' loaded")
 
     def _start_hotkey_capture(self, action: str) -> None:
+        """Start capturing a new hotkey combination for a specific action.
+
+        :param action: Action identifier being rebound.
+        :type action: str
+        :return: Nothing.
+        :rtype: None
+        """
         self._log(f"Capturing hotkey for {action}...")
         self.hotkey_manager.stop()
 
@@ -245,6 +334,15 @@ def worker() -> None:
         threading.Thread(target=worker, daemon=True).start()
 
     def _finish_capture(self, action: str, combo: Optional[List[str]]) -> None:
+        """Finalize hotkey capture, persist configuration, and restart listener.
+
+        :param action: Action identifier being updated.
+        :type action: str
+        :param combo: Captured key combination or ``None`` if invalid.
+        :type combo: list[str] | None
+        :return: Nothing.
+        :rtype: None
+        """
         if not combo or len(combo) < 2:
             self._log("Hotkey ignored (minimum 2 keys)")
         else:
@@ -257,6 +355,11 @@ def _finish_capture(self, action: str, combo: Optional[List[str]]) -> None:
 
 
 def main() -> None:
+    """Run the application in standalone mode.
+
+    :return: Nothing.
+    :rtype: None
+    """
     app = App()
     app.mainloop()
 
diff --git a/pymacrorecorder/config.py b/pymacrorecorder/config.py
index d69c949..d381b94 100644
--- a/pymacrorecorder/config.py
+++ b/pymacrorecorder/config.py
@@ -25,12 +25,22 @@
 
 
 def _config_path() -> Path:
+    """Return the filesystem path to the user config file, creating the directory.
+
+    :return: Absolute path to the config file.
+    :rtype: pathlib.Path
+    """
     data_dir = Path(user_data_dir(APP_NAME, APP_AUTHOR))
     data_dir.mkdir(parents=True, exist_ok=True)
     return data_dir / CONFIG_NAME
 
 
 def load_config() -> Dict[str, Dict[str, List[str]]]:
+    """Load hotkey configuration, falling back to defaults on error or absence.
+
+    :return: Mapping containing sanitized hotkey combinations.
+    :rtype: dict[str, dict[str, list[str]]]
+    """
     path = _config_path()
     if not path.exists():
         return {"hotkeys": DEFAULT_HOTKEYS.copy()}
@@ -54,6 +64,13 @@ def load_config() -> Dict[str, Dict[str, List[str]]]:
 
 
 def save_config(config: Dict[str, Dict[str, List[str]]]) -> None:
+    """Persist the provided configuration to disk.
+
+    :param config: Configuration payload containing hotkey mappings.
+    :type config: dict[str, dict[str, list[str]]]
+    :return: Nothing.
+    :rtype: None
+    """
     path = _config_path()
     hotkeys = config.get("hotkeys", DEFAULT_HOTKEYS)
     normalized = {k: normalize_combo(v) for k, v in hotkeys.items()}
diff --git a/pymacrorecorder/hotkeys.py b/pymacrorecorder/hotkeys.py
index 4713a11..b88ded8 100644
--- a/pymacrorecorder/hotkeys.py
+++ b/pymacrorecorder/hotkeys.py
@@ -13,28 +13,61 @@
 
 
 class HotkeyManager:
+    """Manage global hotkey registration and dispatch via pynput."""
+
     def __init__(self, mapping: Dict[str, List[str]], dispatcher: HotkeyCallback):
+        """Create a hotkey manager with an action-to-combo mapping.
+
+        :param mapping: Hotkey mapping keyed by action name.
+        :type mapping: dict[str, list[str]]
+        :param dispatcher: Callback invoked with action identifier when triggered.
+        :type dispatcher: Callable[[str], None]
+        :return: Nothing.
+        :rtype: None
+        """
         self.mapping = mapping
         self.dispatcher = dispatcher
         self._listener: Optional[keyboard.GlobalHotKeys] = None
         self._lock = threading.Lock()
 
     def start(self) -> None:
+        """Start the hotkey listener with the current mapping.
+
+        :return: Nothing.
+        :rtype: None
+        """
         with self._lock:
             self._restart()
 
     def stop(self) -> None:
+        """Stop the hotkey listener if it is running.
+
+        :return: Nothing.
+        :rtype: None
+        """
         with self._lock:
             if self._listener:
                 self._listener.stop()
                 self._listener = None
 
     def update(self, mapping: Dict[str, List[str]]) -> None:
+        """Replace the mapping and restart the listener safely.
+
+        :param mapping: New hotkey mapping keyed by action name.
+        :type mapping: dict[str, list[str]]
+        :return: Nothing.
+        :rtype: None
+        """
         with self._lock:
             self.mapping = mapping
             self._restart()
 
     def _restart(self) -> None:
+        """Rebuild the pynput listener according to the current mapping.
+
+        :return: Nothing.
+        :rtype: None
+        """
         if self._listener:
             self._listener.stop()
         hotkey_map: Dict[str, Callable[[], None]] = {}
@@ -54,6 +87,15 @@ def _restart(self) -> None:
 
 
 def capture_hotkey_blocking(min_keys: int = 2, timeout: int = 10) -> Optional[List[str]]:
+    """Capture a hotkey combination synchronously using pynput listeners.
+
+    :param min_keys: Minimum number of keys required to accept the combo.
+    :type min_keys: int
+    :param timeout: Maximum seconds to wait before aborting capture.
+    :type timeout: int
+    :return: Normalized combo if enough keys were pressed, else ``None``.
+    :rtype: list[str] | None
+    """
     combo: List[str] = []
     done = threading.Event()
 
diff --git a/pymacrorecorder/models.py b/pymacrorecorder/models.py
index ecb61e1..dec9363 100644
--- a/pymacrorecorder/models.py
+++ b/pymacrorecorder/models.py
@@ -8,6 +8,16 @@
 
 @dataclass
 class MacroEvent:
+    """Represents a single keyboard or mouse event within a macro sequence.
+
+    :ivar event_type: Event identifier such as ``key_down`` or ``mouse_click``.
+    :vartype event_type: str
+    :ivar payload: Event-specific payload values.
+    :vartype payload: dict[str, object]
+    :ivar delay_ms: Delay before the event in milliseconds.
+    :vartype delay_ms: int
+    """
+
     event_type: str
     payload: Dict[str, object]
     delay_ms: int
@@ -15,10 +25,23 @@ class MacroEvent:
 
 @dataclass
 class Macro:
+    """A named collection of macro events.
+
+    :ivar name: Macro display name.
+    :vartype name: str
+    :ivar events: Ordered list of recorded events.
+    :vartype events: list[MacroEvent]
+    """
+
     name: str
     events: List[MacroEvent] = field(default_factory=list)
 
     def is_empty(self) -> bool:
-        return len(self.events) == 0
+        """Return whether the macro has no events.
+
+        :return: ``True`` if no events are stored.
+        :rtype: bool
+        """
 
+        return len(self.events) == 0
 
diff --git a/pymacrorecorder/player.py b/pymacrorecorder/player.py
index 6906bd2..12f7054 100644
--- a/pymacrorecorder/player.py
+++ b/pymacrorecorder/player.py
@@ -15,7 +15,16 @@
 
 
 class Player:
+    """Replay recorded macro events using pynput controllers."""
+
     def __init__(self, log_fn: Optional[LogFn] = None) -> None:
+        """Initialize the player with optional logging hook.
+
+        :param log_fn: Callback to log status messages.
+        :type log_fn: Callable[[str], None] | None
+        :return: Nothing.
+        :rtype: None
+        """
         self.log = log_fn or (lambda _: None)
         self._keyboard = keyboard.Controller()
         self._mouse = mouse.Controller()
@@ -23,6 +32,15 @@ def __init__(self, log_fn: Optional[LogFn] = None) -> None:
         self._stop_event = threading.Event()
 
     def play(self, macro: Macro, repeats: int) -> None:
+        """Start asynchronous playback of a macro.
+
+        :param macro: Macro to play.
+        :type macro: Macro
+        :param repeats: Number of times to repeat; 0 for infinite.
+        :type repeats: int
+        :return: Nothing.
+        :rtype: None
+        """
         if self.is_running():
             return
         self._stop_event.clear()
@@ -33,15 +51,30 @@ def play(self, macro: Macro, repeats: int) -> None:
         )
 
     def stop(self) -> None:
+        """Request playback stop and join the worker thread."""
         self._stop_event.set()
         if self._thread and self._thread.is_alive():
             self._thread.join(timeout=1.0)
         self.log("Playback stopped")
 
     def is_running(self) -> bool:
+        """Return whether a playback thread is currently active.
+
+        :return: ``True`` when playback thread is alive.
+        :rtype: bool
+        """
         return self._thread is not None and self._thread.is_alive()
 
     def _run(self, macro: Macro, repeats: int) -> None:
+        """Internal worker that iterates events until repeats are satisfied.
+
+        :param macro: Macro to replay.
+        :type macro: Macro
+        :param repeats: Remaining repeat count (0 means infinite).
+        :type repeats: int
+        :return: Nothing.
+        :rtype: None
+        """
         count = 0
         while repeats == 0 or count < repeats:
             if self._stop_event.is_set():
@@ -55,6 +88,13 @@ def _run(self, macro: Macro, repeats: int) -> None:
         self._stop_event.clear()
 
     def _apply_event(self, event) -> None:
+        """Apply a recorded event to keyboard or mouse controllers.
+
+        :param event: Macro event containing type, payload, and delay.
+        :type event: MacroEvent
+        :return: Nothing.
+        :rtype: None
+        """
         etype = event.event_type
         data = event.payload
         if etype == "key_down":
diff --git a/pymacrorecorder/recorder.py b/pymacrorecorder/recorder.py
index 646e26f..636c4f2 100644
--- a/pymacrorecorder/recorder.py
+++ b/pymacrorecorder/recorder.py
@@ -15,7 +15,16 @@
 
 
 class Recorder:
+    """Capture keyboard and mouse events while respecting ignored hotkeys."""
+
     def __init__(self, log_fn: Optional[LogFn] = None) -> None:
+        """Initialize recorder with optional logger.
+
+        :param log_fn: Callback for status messages.
+        :type log_fn: Callable[[str], None] | None
+        :return: Nothing.
+        :rtype: None
+        """
         self.log = log_fn or (lambda _: None)
         self._keyboard_listener: Optional[keyboard.Listener] = None
         self._mouse_listener: Optional[mouse.Listener] = None
@@ -26,6 +35,13 @@ def __init__(self, log_fn: Optional[LogFn] = None) -> None:
         self._hotkeys: List[Set[str]] = []
 
     def start(self, ignored_hotkeys: List[List[str]]) -> None:
+        """Start recording, ignoring events that match provided hotkeys.
+
+        :param ignored_hotkeys: List of hotkey combos that should not be recorded.
+        :type ignored_hotkeys: list[list[str]]
+        :return: Nothing.
+        :rtype: None
+        """
         if self._running.is_set():
             return
         self._hotkeys = combos_as_sets(ignored_hotkeys)
@@ -44,6 +60,11 @@ def start(self, ignored_hotkeys: List[List[str]]) -> None:
         self.log("Recording started")
 
     def stop(self) -> List[MacroEvent]:
+        """Stop recording and return collected macro events.
+
+        :return: Recorded macro events in order.
+        :rtype: list[MacroEvent]
+        """
         if not self._running.is_set():
             return []
         self._running.clear()
@@ -57,15 +78,38 @@ def stop(self) -> List[MacroEvent]:
         return list(self._events)
 
     def _add_event(self, event_type: str, payload: dict) -> None:
+        """Append a macro event with computed delay.
+
+        :param event_type: Identifier for the event type.
+        :type event_type: str
+        :param payload: Event-specific payload data.
+        :type payload: dict
+        :return: Nothing.
+        :rtype: None
+        """
         now = time.time()
         delay_ms = 0 if not self._events else int((now - self._last_time) * 1000)
         self._last_time = now
         self._events.append(MacroEvent(event_type=event_type, payload=payload, delay_ms=delay_ms))
 
     def _should_ignore(self, pressed_snapshot: Set[str]) -> bool:
+        """Return whether current pressed keys match any ignored hotkey.
+
+        :param pressed_snapshot: Current pressed key labels.
+        :type pressed_snapshot: set[str]
+        :return: ``True`` if event should be ignored.
+        :rtype: bool
+        """
         return pressed_matches_hotkey(pressed_snapshot, self._hotkeys)
 
     def _on_key_press(self, key: keyboard.Key | keyboard.KeyCode) -> None:
+        """Handle key press events and store them when recording.
+
+        :param key: Pressed key instance.
+        :type key: keyboard.Key | keyboard.KeyCode
+        :return: Nothing.
+        :rtype: None
+        """
         if not self._running.is_set():
             return
         label = key_to_str(key)
@@ -75,6 +119,13 @@ def _on_key_press(self, key: keyboard.Key | keyboard.KeyCode) -> None:
         self._add_event("key_down", {"key": label})
 
     def _on_key_release(self, key: keyboard.Key | keyboard.KeyCode) -> None:
+        """Handle key release events and store them when recording.
+
+        :param key: Released key instance.
+        :type key: keyboard.Key | keyboard.KeyCode
+        :return: Nothing.
+        :rtype: None
+        """
         if not self._running.is_set():
             return
         label = key_to_str(key)
@@ -85,6 +136,19 @@ def _on_key_release(self, key: keyboard.Key | keyboard.KeyCode) -> None:
         self._pressed.discard(label)
 
     def _on_click(self, x: int, y: int, button: mouse.Button, pressed: bool) -> None:
+        """Record mouse click events.
+
+        :param x: Cursor X coordinate.
+        :type x: int
+        :param y: Cursor Y coordinate.
+        :type y: int
+        :param button: Mouse button pressed or released.
+        :type button: mouse.Button
+        :param pressed: ``True`` if pressed, ``False`` if released.
+        :type pressed: bool
+        :return: Nothing.
+        :rtype: None
+        """
         if not self._running.is_set():
             return
         if self._should_ignore(self._pressed):
@@ -100,6 +164,19 @@ def _on_click(self, x: int, y: int, button: mouse.Button, pressed: bool) -> None
         )
 
     def _on_scroll(self, x: int, y: int, dx: int, dy: int) -> None:
+        """Record mouse scroll events.
+
+        :param x: Cursor X coordinate.
+        :type x: int
+        :param y: Cursor Y coordinate.
+        :type y: int
+        :param dx: Horizontal scroll delta.
+        :type dx: int
+        :param dy: Vertical scroll delta.
+        :type dy: int
+        :return: Nothing.
+        :rtype: None
+        """
         if not self._running.is_set():
             return
         if self._should_ignore(self._pressed):
@@ -107,6 +184,15 @@ def _on_scroll(self, x: int, y: int, dx: int, dy: int) -> None:
         self._add_event("mouse_scroll", {"x": x, "y": y, "dx": dx, "dy": dy})
 
     def _on_move(self, x: int, y: int) -> None:
+        """Record mouse move events.
+
+        :param x: Cursor X coordinate.
+        :type x: int
+        :param y: Cursor Y coordinate.
+        :type y: int
+        :return: Nothing.
+        :rtype: None
+        """
         if not self._running.is_set():
             return
         if self._should_ignore(self._pressed):
diff --git a/pymacrorecorder/storage.py b/pymacrorecorder/storage.py
index 721405a..42a6c6a 100644
--- a/pymacrorecorder/storage.py
+++ b/pymacrorecorder/storage.py
@@ -13,6 +13,15 @@
 
 
 def save_macro_to_csv(path: Path, macro: Macro) -> None:
+    """Write a macro to CSV with JSON-encoded events.
+
+    :param path: Destination CSV path.
+    :type path: pathlib.Path
+    :param macro: Macro to serialize.
+    :type macro: Macro
+    :return: Nothing.
+    :rtype: None
+    """
     path.parent.mkdir(parents=True, exist_ok=True)
     with path.open("w", newline="", encoding="utf-8") as fh:
         writer = csv.DictWriter(fh, fieldnames=CSV_FIELDS)
@@ -24,6 +33,13 @@ def save_macro_to_csv(path: Path, macro: Macro) -> None:
 
 
 def load_macros_from_csv(path: Path) -> List[Macro]:
+    """Load macros from a CSV file.
+
+    :param path: Source CSV path.
+    :type path: pathlib.Path
+    :return: Parsed macros in file order.
+    :rtype: list[Macro]
+    """
     macros: List[Macro] = []
     if not path.exists():
         return macros
@@ -35,4 +51,3 @@ def load_macros_from_csv(path: Path) -> List[Macro]:
             macros.append(Macro(name=row.get("name", "macro"), events=events))
     return macros
 
-
diff --git a/pymacrorecorder/utils.py b/pymacrorecorder/utils.py
index 6e171f2..e52d8c2 100644
--- a/pymacrorecorder/utils.py
+++ b/pymacrorecorder/utils.py
@@ -8,6 +8,13 @@
 
 
 def key_to_str(key: keyboard.Key | keyboard.KeyCode) -> str:
+    """Normalize a pynput key to string label.
+
+    :param key: Key instance from pynput.
+    :type key: keyboard.Key | keyboard.KeyCode
+    :return: Normalized key label.
+    :rtype: str
+    """
     if isinstance(key, keyboard.KeyCode):
         if key.char:
             return key.char
@@ -18,10 +25,24 @@ def key_to_str(key: keyboard.Key | keyboard.KeyCode) -> str:
 
 
 def button_to_str(btn: mouse.Button) -> str:
+    """Normalize a mouse button to string label.
+
+    :param btn: Mouse button instance.
+    :type btn: mouse.Button
+    :return: Button label.
+    :rtype: str
+    """
     return btn.name if hasattr(btn, "name") else str(btn)
 
 
 def normalize_label(label: str) -> str:
+    """Normalize an individual key label for parsing.
+
+    :param label: Raw label such as ``<ctrl>`` or ``A``.
+    :type label: str
+    :return: Normalized lowercase label.
+    :rtype: str
+    """
     if label.startswith("<") and label.endswith(">"):
         inner = label[1:-1]
         if inner.startswith("vk_"):
@@ -40,10 +61,24 @@ def normalize_label(label: str) -> str:
 
 
 def normalize_combo(combo: Iterable[str]) -> List[str]:
+    """Normalize each label in a hotkey combination.
+
+    :param combo: Iterable of key labels.
+    :type combo: Iterable[str]
+    :return: Normalized labels preserving order.
+    :rtype: list[str]
+    """
     return [normalize_label(x) for x in combo]
 
 
 def is_parseable_hotkey(combo_str: str) -> bool:
+    """Return whether a combo string can be parsed by pynput.
+
+    :param combo_str: Hotkey combination string (e.g., ``<ctrl>+c``).
+    :type combo_str: str
+    :return: ``True`` if parsable, otherwise ``False``.
+    :rtype: bool
+    """
     try:
         keyboard.HotKey.parse(combo_str)
         return True
@@ -52,6 +87,13 @@ def is_parseable_hotkey(combo_str: str) -> bool:
 
 
 def str_to_key(label: str) -> keyboard.Key | keyboard.KeyCode:
+    """Convert a normalized label to a pynput key instance.
+
+    :param label: Normalized label such as ``a`` or ``<ctrl>``.
+    :type label: str
+    :return: Corresponding pynput key or keycode.
+    :rtype: keyboard.Key | keyboard.KeyCode
+    """
     if not label:
         return keyboard.KeyCode.from_char(" ")
     if label.startswith("<") and label.endswith(">"):
@@ -72,6 +114,13 @@ def str_to_key(label: str) -> keyboard.Key | keyboard.KeyCode:
 
 
 def str_to_button(label: str) -> mouse.Button:
+    """Convert a normalized label to a pynput mouse button.
+
+    :param label: Normalized button label.
+    :type label: str
+    :return: Mouse button enum value.
+    :rtype: mouse.Button
+    """
     try:
         return mouse.Button[label]
     except KeyError:
@@ -82,12 +131,35 @@ def str_to_button(label: str) -> mouse.Button:
 
 
 def format_combo(combo: Iterable[str]) -> str:
+    """Join a combo into a ``+`` separated string.
+
+    :param combo: Normalized labels.
+    :type combo: Iterable[str]
+    :return: Joined combination string.
+    :rtype: str
+    """
     return "+".join(combo)
 
 
 def combos_as_sets(mapping: Iterable[List[str]]) -> List[Set[str]]:
+    """Convert a list of combos to list of sets for fast comparison.
+
+    :param mapping: Hotkey combos.
+    :type mapping: Iterable[list[str]]
+    :return: List of sets for each combo.
+    :rtype: list[set[str]]
+    """
     return [set(x) for x in mapping]
 
 
 def pressed_matches_hotkey(pressed: Set[str], hotkeys: List[Set[str]]) -> bool:
+    """Check if pressed keys satisfy any hotkey combination.
+
+    :param pressed: Currently pressed key labels.
+    :type pressed: set[str]
+    :param hotkeys: List of hotkey sets to match against.
+    :type hotkeys: list[set[str]]
+    :return: ``True`` if a hotkey is matched.
+    :rtype: bool
+    """
     return any(hk.issubset(pressed) for hk in hotkeys)

From 5f3f57ccb54a28efcde2ab90ef4d2d70013b71d6 Mon Sep 17 00:00:00 2001
From: Redstoneur <alfa.aog36@gmail.com>
Date: Tue, 17 Feb 2026 15:00:15 +0100
Subject: [PATCH 10/20] Add logo SVG file for branding and visual identity

---
 images/logo.svg | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 images/logo.svg

diff --git a/images/logo.svg b/images/logo.svg
new file mode 100644
index 0000000..b9393e4
--- /dev/null
+++ b/images/logo.svg
@@ -0,0 +1,22 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 400 400">
+    <defs>
+        <marker id="arrow" markerWidth="4" markerHeight="4" refX="2" refY="2"
+                orient="auto" markerUnits="strokeWidth">
+            <path d="M0,0 L4,2 L0,4 Z" fill="#00ccff"/>
+        </marker>
+    </defs>
+    <rect width="400" height="400" rx="32" fill="#1e1e2f"/>
+    <g transform="translate(200,200)">
+        <path d="M0-110A110 110 0 1 1-77-77" fill="none" stroke="#00ccff"
+              stroke-width="11" stroke-linecap="round"
+              marker-end="url(#arrow)"/>
+        <g transform="scale(.9)">
+            <path d="M-2-38L-22 20l14-5 8 21 10-4-8-21 14 5Z" fill="#00ccff"/>
+        </g>
+        <circle cx="55" cy="-35" r="12" fill="#ff3b3b"/>
+        <circle cx="55" cy="-35" r="12" fill="#ff3b3b" opacity=".3">
+            <animate attributeName="r" values="12;20;12" dur="2s" repeatCount="indefinite"/>
+            <animate attributeName="opacity" values=".3;0;.3" dur="2s" repeatCount="indefinite"/>
+        </circle>
+    </g>
+</svg>

From e71883b8d9a7e04d391520870bc4a87d05973d3e Mon Sep 17 00:00:00 2001
From: Redstoneur <alfa.aog36@gmail.com>
Date: Tue, 17 Feb 2026 15:05:07 +0100
Subject: [PATCH 11/20] Add logo assets and move SVG to assets

Move images/logo.svg to assets/logo.svg and add assets/logo.ico and assets/logo.png. Centralizes logo files and provides ICO/PNG formats for favicon and cross-platform use.
---
 assets/logo.ico             | Bin 0 -> 8797 bytes
 assets/logo.png             | Bin 0 -> 50251 bytes
 {images => assets}/logo.svg |   0
 3 files changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 assets/logo.ico
 create mode 100644 assets/logo.png
 rename {images => assets}/logo.svg (100%)

diff --git a/assets/logo.ico b/assets/logo.ico
new file mode 100644
index 0000000000000000000000000000000000000000..0b37fb1bd26085add19238129fcd9d4dffcfcaee
GIT binary patch
literal 8797
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
Cs%|6z

literal 0
HcmV?d00001

diff --git a/assets/logo.png b/assets/logo.png
new file mode 100644
index 0000000000000000000000000000000000000000..107dfdeb870d1d9c6bb66ee88fa90d7ec930718e
GIT binary patch
literal 50251
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

literal 0
HcmV?d00001

diff --git a/images/logo.svg b/assets/logo.svg
similarity index 100%
rename from images/logo.svg
rename to assets/logo.svg

From 47ded37cfc15ca706b4424d0329d8cc2a47a5c4c Mon Sep 17 00:00:00 2001
From: Redstoneur <alfa.aog36@gmail.com>
Date: Tue, 17 Feb 2026 15:24:08 +0100
Subject: [PATCH 12/20] Bundle app icon/assets and set window icon

Add icon and assets packaging to build scripts and initialize the GUI icon at runtime. Updated build.ps1 and build.sh to include --icon, --add-data and --noconsole so PyInstaller bundles the assets and uses the provided logo. In app.py imported sys, added _set_icon() (called during init) which loads logo.png or falls back to logo.ico and handles both script and PyInstaller (_MEIPASS) runtime paths; failures are logged but do not crash the app.
---
 build.ps1              |  5 +++--
 build.sh               |  5 +++--
 pymacrorecorder/app.py | 32 ++++++++++++++++++++++++++++++++
 3 files changed, 38 insertions(+), 4 deletions(-)

diff --git a/build.ps1 b/build.ps1
index 15cc26e..40de0a9 100644
--- a/build.ps1
+++ b/build.ps1
@@ -7,13 +7,14 @@ $DistDir = Join-Path $ProjectRoot "dist"
 $BuildDir = Join-Path $ProjectRoot "build"
 $SpecFile = Join-Path $ProjectRoot "PyMacroRecorder.spec"
 $EntryPoint = Join-Path $ProjectRoot "main.py"
+$IconFile = Join-Path $ProjectRoot "assets\logo.ico"
 $AppName = "PyMacroRecorder"
 
 # Clean previous outputs
 Remove-Item -Recurse -Force -ErrorAction SilentlyContinue $DistDir, $BuildDir, $SpecFile
 
-# Run pyinstaller
-pyinstaller --onefile --name "$AppName" --distpath "$DistDir" --workpath "$BuildDir" "$EntryPoint"
+# Run pyinstaller with icon and assets
+pyinstaller --onefile --noconsole --name "$AppName" --icon "$IconFile" --add-data "assets;assets" --distpath "$DistDir" --workpath "$BuildDir" "$EntryPoint"
 
 Write-Host "Build complete. Binary located at: $DistDir\$AppName.exe"
 
diff --git a/build.sh b/build.sh
index 478db7d..7b3b3a3 100644
--- a/build.sh
+++ b/build.sh
@@ -8,13 +8,14 @@ DIST_DIR="$PROJECT_ROOT/dist"
 BUILD_DIR="$PROJECT_ROOT/build"
 SPEC_FILE="$PROJECT_ROOT/PyMacroRecorder.spec"
 ENTRYPOINT="$PROJECT_ROOT/main.py"
+ICON_FILE="$PROJECT_ROOT/assets/logo.ico"
 APP_NAME="PyMacroRecorder"
 
 # Clean previous outputs
 rm -rf "$DIST_DIR" "$BUILD_DIR" "$SPEC_FILE"
 
-# Run pyinstaller
-pyinstaller --onefile --name "$APP_NAME" --distpath "$DIST_DIR" --workpath "$BUILD_DIR" "$ENTRYPOINT"
+# Run pyinstaller with icon and assets
+pyinstaller --onefile --noconsole --name "$APP_NAME" --icon "$ICON_FILE" --add-data "assets:assets" --distpath "$DIST_DIR" --workpath "$BUILD_DIR" "$ENTRYPOINT"
 
 # Print result path
 echo "Build complete. Binary located at: $DIST_DIR/$APP_NAME"
diff --git a/pymacrorecorder/app.py b/pymacrorecorder/app.py
index 7711ddc..928b7ed 100644
--- a/pymacrorecorder/app.py
+++ b/pymacrorecorder/app.py
@@ -1,5 +1,6 @@
 """Tkinter application entry point for PyMacroRecorder."""
 
+import sys
 import threading
 import tkinter as tk
 from pathlib import Path
@@ -27,6 +28,7 @@ def __init__(self) -> None:
         super().__init__()
         self.title("PyMacroRecorder")
         self.geometry("900x600")
+        self._set_icon()
 
         cfg = load_config()
         self.hotkeys: Dict[str, List[str]] = cfg.get("hotkeys", DEFAULT_HOTKEYS)
@@ -39,6 +41,36 @@ def __init__(self) -> None:
         self.hotkey_manager = HotkeyManager(self.hotkeys, self._dispatch_hotkey)
         self.hotkey_manager.start()
 
+    def _set_icon(self) -> None:
+        """Set the window icon from the `assets` folder.
+
+        :return: Nothing.
+        :rtype: None
+        """
+        try:
+            # Determine the base path (works for both script and PyInstaller)
+            if getattr(sys, 'frozen', False):
+                # Running as compiled executable
+                # noinspection PyProtectedMember
+                base_path = Path(sys._MEIPASS)
+            else:
+                # Running as script
+                base_path = Path(__file__).parent.parent
+                print(base_path)
+
+            icon_path = base_path / "assets" / "logo.png"
+            if icon_path.exists():
+                icon = tk.PhotoImage(file=str(icon_path))
+                self.iconphoto(True, icon)
+            else:
+                # Fallback to .ico if .png not found
+                icon_ico_path = base_path / "assets" / "logo.ico"
+                if icon_ico_path.exists():
+                    self.iconbitmap(str(icon_ico_path))
+        except Exception as e:
+            # Silently fail if icon cannot be loaded
+            print(f"Warning: Could not load icon: {e}")
+
     def _build_ui(self) -> None:
         """Build the control bar, preview tree, log area, and hotkey editor.
 

From 76a247fa48c5867313ed155de5f41c5a1a3c8fe1 Mon Sep 17 00:00:00 2001
From: Redstoneur <alfa.aog36@gmail.com>
Date: Tue, 17 Feb 2026 16:54:02 +0100
Subject: [PATCH 13/20] Use OS-specific build steps in workflows

Replace matrix-based shell/run_cmd entries with explicit conditional build steps in .github/workflows/ci.yml and .github/workflows/release.yml. Removed per-matrix "shell" and "run_cmd" variables and added a "Build binary (Linux)" step that runs bash build.sh when runner.os != 'Windows' (keeping the chmod +x step), plus a "Build binary (Windows)" step that runs .\build.ps1 when runner.os == 'Windows'. This clarifies platform-specific commands and avoids relying on matrix shell variables.
---
 .github/workflows/ci.yml      | 14 +++++++-------
 .github/workflows/release.yml | 14 +++++++-------
 2 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 7ea9198..3d9c088 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -44,12 +44,8 @@ jobs:
         include:
           - os: ubuntu-latest
             extension: ""
-            shell: bash
-            run_cmd: bash build.sh
           - os: windows-latest
             extension: .exe
-            shell: pwsh
-            run_cmd: .\\build.ps1
     steps:
       - name: Checkout
         uses: actions/checkout@v4
@@ -69,9 +65,13 @@ jobs:
         if: runner.os != 'Windows'
         run: chmod +x build.sh
 
-      - name: Build binary
-        run: ${{ matrix.run_cmd }}
-        shell: ${{ matrix.shell }}
+      - name: Build binary (Linux)
+        if: runner.os != 'Windows'
+        run: bash build.sh
+
+      - name: Build binary (Windows)
+        if: runner.os == 'Windows'
+        run: .\build.ps1
 
       - name: Upload artifact
         uses: actions/upload-artifact@v4
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 0ade599..c5599b6 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -14,12 +14,8 @@ jobs:
         include:
           - os: ubuntu-latest
             extension: ""
-            shell: bash
-            run_cmd: bash build.sh
           - os: windows-latest
             extension: .exe
-            shell: pwsh
-            run_cmd: .\\build.ps1
     steps:
       - name: Checkout
         uses: actions/checkout@v4
@@ -39,9 +35,13 @@ jobs:
         if: runner.os != 'Windows'
         run: chmod +x build.sh
 
-      - name: Build binary
-        run: ${{ matrix.run_cmd }}
-        shell: ${{ matrix.shell }}
+      - name: Build binary (Linux)
+        if: runner.os != 'Windows'
+        run: bash build.sh
+
+      - name: Build binary (Windows)
+        if: runner.os == 'Windows'
+        run: .\build.ps1
 
       - name: Upload artifact
         uses: actions/upload-artifact@v4

From 4c57b649f47387d15b53022ab842cc0f60ff8cce Mon Sep 17 00:00:00 2001
From: Redstoneur <alfa.aog36@gmail.com>
Date: Tue, 17 Feb 2026 16:54:24 +0100
Subject: [PATCH 14/20] Remove debug print of base_path

Remove an accidental debug print (print(base_path)) from pymacrorecorder/app.py. The print occurred when determining base_path while running as a script; removing it prevents stray console output during normal use.
---
 pymacrorecorder/app.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/pymacrorecorder/app.py b/pymacrorecorder/app.py
index 928b7ed..24a0a9a 100644
--- a/pymacrorecorder/app.py
+++ b/pymacrorecorder/app.py
@@ -56,7 +56,6 @@ def _set_icon(self) -> None:
             else:
                 # Running as script
                 base_path = Path(__file__).parent.parent
-                print(base_path)
 
             icon_path = base_path / "assets" / "logo.png"
             if icon_path.exists():

From d857686b3224a82946bc566b9a95a72558a1b823 Mon Sep 17 00:00:00 2001
From: Redstoneur <alfa.aog36@gmail.com>
Date: Tue, 17 Feb 2026 17:24:25 +0100
Subject: [PATCH 15/20] Docs: venv activation and Python version

Unify and clarify virtualenv instructions in README.md and CONTRIBUTING.md: use "source .venv/bin/activate" as the primary activation command and format the Windows activation hint in inline code. Also add a recommendation for Python 3.14 in CONTRIBUTING and apply minor whitespace/doc formatting tweaks for consistency.
---
 CONTRIBUTING.md | 8 ++++++--
 README.md       | 2 +-
 2 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 59178a2..e644287 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -3,11 +3,12 @@
 Thanks for your interest in improving PyMacroRecorder!
 
 ## Getting started
-1. Install Python 3.10+.
+
+1. Install Python 3.10+. (3.14 is recommended for latest features)
 2. Create a virtual environment and install dependencies:
    ```bash
    python -m venv .venv
-   . .venv/Scripts/activate  # Windows: .venv\Scripts\activate
+   source .venv/bin/activate  # Windows: `.venv\Scripts\activate`
    pip install -r requirements.txt
    ```
 3. Run the app locally:
@@ -16,18 +17,21 @@ Thanks for your interest in improving PyMacroRecorder!
    ```
 
 ## Development guidelines
+
 - Keep `main.py` limited to application bootstrap; place logic inside `pymacrorecorder/`.
 - Prefer small, focused classes and functions with clear responsibilities.
 - Ensure new features work on both Windows and Linux.
 - When adding storage or settings, keep JSON format and update `pymacrorecorder/config.py` as needed.
 
 ## Docstrings
+
 - All Python docstrings must use Sphinx reStructuredText (reST) style.
 - Include ``:param:``, ``:type:``, ``:return:``, ``:rtype:``, and ``:raises:`` as appropriate.
 - Google or NumPy docstring styles are not allowed.
 - Provide docstrings for every module, class, and public function/method.
 
 ## Submitting changes
+
 - Create a feature branch for your work.
 - Add or update documentation for new behavior.
 - Open a pull request summarizing the change, testing performed, and any platform-specific notes.
diff --git a/README.md b/README.md
index 0dcf62a..c4477e5 100644
--- a/README.md
+++ b/README.md
@@ -40,7 +40,7 @@ PyMacroRecorder/
 ## Quick start
 ```bash
 python -m venv .venv
-. .venv/Scripts/activate  # Windows: .venv\Scripts\activate
+source .venv/bin/activate  # Windows: `.venv\Scripts\activate`
 pip install -r requirements.txt
 python main.py
 ```

From e0f87a62638cf756a08be351e9f538c80f942d8f Mon Sep 17 00:00:00 2001
From: Redstoneur <alfa.aog36@gmail.com>
Date: Tue, 17 Feb 2026 17:25:03 +0100
Subject: [PATCH 16/20] Harden parsing and use specific exceptions

Make error handling more precise and robust when reading config and macro storage. Import JSONDecodeError and catch (OSError, JSONDecodeError) in load_config to avoid masking unrelated errors; narrow exception handling in is_parseable_hotkey to (ValueError, KeyError). Wrap CSV/JSON macro loading in try/except (OSError, json.JSONDecodeError, TypeError, ValueError) to return an empty list on malformed or unreadable files. Also remove stray blank lines in Macro.is_empty.
---
 pymacrorecorder/config.py  |  3 ++-
 pymacrorecorder/models.py  |  2 --
 pymacrorecorder/storage.py | 15 +++++++++------
 pymacrorecorder/utils.py   |  2 +-
 4 files changed, 12 insertions(+), 10 deletions(-)

diff --git a/pymacrorecorder/config.py b/pymacrorecorder/config.py
index d381b94..2b2fcf2 100644
--- a/pymacrorecorder/config.py
+++ b/pymacrorecorder/config.py
@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import json
+from json import JSONDecodeError
 from pathlib import Path
 from typing import Dict, List
 
@@ -47,7 +48,7 @@ def load_config() -> Dict[str, Dict[str, List[str]]]:
     try:
         with path.open("r", encoding="utf-8") as fh:
             data = json.load(fh)
-    except Exception:
+    except (OSError, JSONDecodeError):
         return {"hotkeys": DEFAULT_HOTKEYS.copy()}
     hotkeys = data.get("hotkeys", {})
     merged = DEFAULT_HOTKEYS.copy()
diff --git a/pymacrorecorder/models.py b/pymacrorecorder/models.py
index dec9363..ccd14d9 100644
--- a/pymacrorecorder/models.py
+++ b/pymacrorecorder/models.py
@@ -42,6 +42,4 @@ def is_empty(self) -> bool:
         :return: ``True`` if no events are stored.
         :rtype: bool
         """
-
         return len(self.events) == 0
-
diff --git a/pymacrorecorder/storage.py b/pymacrorecorder/storage.py
index 42a6c6a..b34348f 100644
--- a/pymacrorecorder/storage.py
+++ b/pymacrorecorder/storage.py
@@ -43,11 +43,14 @@ def load_macros_from_csv(path: Path) -> List[Macro]:
     macros: List[Macro] = []
     if not path.exists():
         return macros
-    with path.open("r", newline="", encoding="utf-8") as fh:
-        reader = csv.DictReader(fh)
-        for row in reader:
-            raw_events = json.loads(row.get("events", "[]"))
-            events = [MacroEvent(**evt) for evt in raw_events]
-            macros.append(Macro(name=row.get("name", "macro"), events=events))
+    try:
+        with path.open("r", newline="", encoding="utf-8") as fh:
+            reader = csv.DictReader(fh)
+            for row in reader:
+                raw_events = json.loads(row.get("events", "[]"))
+                events = [MacroEvent(**evt) for evt in raw_events]
+                macros.append(Macro(name=row.get("name", "macro"), events=events))
+    except (OSError, json.JSONDecodeError, TypeError, ValueError):
+        return []
     return macros
 
diff --git a/pymacrorecorder/utils.py b/pymacrorecorder/utils.py
index e52d8c2..cb0eb15 100644
--- a/pymacrorecorder/utils.py
+++ b/pymacrorecorder/utils.py
@@ -82,7 +82,7 @@ def is_parseable_hotkey(combo_str: str) -> bool:
     try:
         keyboard.HotKey.parse(combo_str)
         return True
-    except Exception:
+    except (ValueError, KeyError):
         return False
 
 

From b06b2fe7282d572029da50ea26643612c615c082 Mon Sep 17 00:00:00 2001
From: Redstoneur <alfa.aog36@gmail.com>
Date: Tue, 17 Feb 2026 17:25:25 +0100
Subject: [PATCH 17/20] Bump CI Python to 3.14 and disable pytest

Update GitHub Actions workflows to use Python 3.14 (ci.yml and release.yml) and temporarily comment out the pytest step in ci.yml. This applies a Python version bump across CI/release jobs and disables running tests in CI pending follow-up fixes or environment updates.
---
 .github/workflows/ci.yml      | 10 +++++-----
 .github/workflows/release.yml |  2 +-
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 3d9c088..6187059 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -16,7 +16,7 @@ jobs:
       - name: Set up Python
         uses: actions/setup-python@v5
         with:
-          python-version: '3.11'
+          python-version: '3.14'
 
       - name: Install dependencies
         run: |
@@ -32,9 +32,9 @@ jobs:
         run: |
           ruff check pymacrorecorder main.py
 
-      - name: Run pytest
-        run: |
-          pytest
+      # - name: Run pytest
+      #   run: |
+      #     pytest
 
   build-binaries:
     name: Build binaries (${{ matrix.os }})
@@ -53,7 +53,7 @@ jobs:
       - name: Set up Python
         uses: actions/setup-python@v5
         with:
-          python-version: '3.11'
+          python-version: '3.14'
 
       - name: Install dependencies
         run: |
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index c5599b6..30e5119 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -23,7 +23,7 @@ jobs:
       - name: Set up Python
         uses: actions/setup-python@v5
         with:
-          python-version: '3.11'
+          python-version: '3.14'
 
       - name: Install dependencies
         run: |

From 30af9c578663b7d5ee69fe90130875e61c9230bc Mon Sep 17 00:00:00 2001
From: Redstoneur <alfa.aog36@gmail.com>
Date: Tue, 17 Feb 2026 17:32:13 +0100
Subject: [PATCH 18/20] Bump version to 1.0.0

Update project version in pyproject.toml from 0.1.1 to 1.0.0 to mark a new major release. No other metadata or functional changes were made.
---
 pyproject.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pyproject.toml b/pyproject.toml
index 6850ba9..efae425 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pymacrorecorder"
-version = "0.1.1"
+version = "1.0.0"
 description = "Cross-platform Tkinter macro recorder for keyboard and mouse."
 readme = "README.md"
 requires-python = ">=3.10"

From e140fc809208c4106cfdd24f4b98e26955058451 Mon Sep 17 00:00:00 2001
From: Redstoneur <alfa.aog36@gmail.com>
Date: Tue, 17 Feb 2026 17:50:11 +0100
Subject: [PATCH 19/20] Add lint deps and suppress pylint warnings

Add development tooling and address lint warnings across the codebase. Changes include: add pylint/ruff/pytest to requirements, add pylint disables for classes with many attributes, mark protected access usage of sys._MEIPASS with a pylint disable, narrow the icon-loading exception to OSError and tk.TclError, annotate str_to_key with a pylint disable for many return statements, tighten exception handling in str_to_button to ValueError/TypeError, and remove an extra trailing blank line in storage.py. These changes are intended to improve static analysis compatibility and make exception handling more explicit.
---
 pymacrorecorder/app.py      | 6 +++---
 pymacrorecorder/recorder.py | 2 +-
 pymacrorecorder/storage.py  | 1 -
 pymacrorecorder/utils.py    | 4 ++--
 requirements.txt            | 3 +++
 5 files changed, 9 insertions(+), 7 deletions(-)

diff --git a/pymacrorecorder/app.py b/pymacrorecorder/app.py
index 24a0a9a..8888bd2 100644
--- a/pymacrorecorder/app.py
+++ b/pymacrorecorder/app.py
@@ -16,7 +16,7 @@
 from .utils import format_combo
 
 
-class App(tk.Tk):
+class App(tk.Tk):  # pylint: disable=too-many-instance-attributes
     """Main Tkinter window that orchestrates recording, playback, and storage."""
 
     def __init__(self) -> None:
@@ -52,7 +52,7 @@ def _set_icon(self) -> None:
             if getattr(sys, 'frozen', False):
                 # Running as compiled executable
                 # noinspection PyProtectedMember
-                base_path = Path(sys._MEIPASS)
+                base_path = Path(sys._MEIPASS)  # pylint: disable=protected-access
             else:
                 # Running as script
                 base_path = Path(__file__).parent.parent
@@ -66,7 +66,7 @@ def _set_icon(self) -> None:
                 icon_ico_path = base_path / "assets" / "logo.ico"
                 if icon_ico_path.exists():
                     self.iconbitmap(str(icon_ico_path))
-        except Exception as e:
+        except (OSError, tk.TclError) as e:
             # Silently fail if icon cannot be loaded
             print(f"Warning: Could not load icon: {e}")
 
diff --git a/pymacrorecorder/recorder.py b/pymacrorecorder/recorder.py
index 636c4f2..ae7b2f7 100644
--- a/pymacrorecorder/recorder.py
+++ b/pymacrorecorder/recorder.py
@@ -14,7 +14,7 @@
 LogFn = Callable[[str], None]
 
 
-class Recorder:
+class Recorder:  # pylint: disable=too-many-instance-attributes
     """Capture keyboard and mouse events while respecting ignored hotkeys."""
 
     def __init__(self, log_fn: Optional[LogFn] = None) -> None:
diff --git a/pymacrorecorder/storage.py b/pymacrorecorder/storage.py
index b34348f..76c42eb 100644
--- a/pymacrorecorder/storage.py
+++ b/pymacrorecorder/storage.py
@@ -53,4 +53,3 @@ def load_macros_from_csv(path: Path) -> List[Macro]:
     except (OSError, json.JSONDecodeError, TypeError, ValueError):
         return []
     return macros
-
diff --git a/pymacrorecorder/utils.py b/pymacrorecorder/utils.py
index cb0eb15..a10c6d3 100644
--- a/pymacrorecorder/utils.py
+++ b/pymacrorecorder/utils.py
@@ -86,7 +86,7 @@ def is_parseable_hotkey(combo_str: str) -> bool:
         return False
 
 
-def str_to_key(label: str) -> keyboard.Key | keyboard.KeyCode:
+def str_to_key(label: str) -> keyboard.Key | keyboard.KeyCode:  # pylint: disable=too-many-return-statements
     """Convert a normalized label to a pynput key instance.
 
     :param label: Normalized label such as ``a`` or ``<ctrl>``.
@@ -126,7 +126,7 @@ def str_to_button(label: str) -> mouse.Button:
     except KeyError:
         try:
             return mouse.Button(int(label))  # handle numeric value
-        except Exception:
+        except (ValueError, TypeError):
             return mouse.Button.left
 
 
diff --git a/requirements.txt b/requirements.txt
index 7d59ce0..f0465ab 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -2,3 +2,6 @@ pynput>=1.7.6
 appdirs>=1.4.4
 pyinstaller>=5.1.0
 pyinstaller-hooks-contrib>=2024.6.0
+pylint>=2.15.0
+ruff>=0.0.241
+pytest>=7.2.0

From a221fd01a76eb42ab7a35dba7d6097b09067b908 Mon Sep 17 00:00:00 2001
From: Redstoneur <84982695+Redstoneur@users.noreply.github.com>
Date: Tue, 17 Feb 2026 19:28:16 +0100
Subject: [PATCH 20/20] Update pymacrorecorder/app.py

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
---
 pymacrorecorder/app.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/pymacrorecorder/app.py b/pymacrorecorder/app.py
index 8888bd2..ba67a4c 100644
--- a/pymacrorecorder/app.py
+++ b/pymacrorecorder/app.py
@@ -68,7 +68,7 @@ def _set_icon(self) -> None:
                     self.iconbitmap(str(icon_ico_path))
         except (OSError, tk.TclError) as e:
             # Silently fail if icon cannot be loaded
-            print(f"Warning: Could not load icon: {e}")
+            self._log(f"Warning: Could not load icon: {e}")
 
     def _build_ui(self) -> None:
         """Build the control bar, preview tree, log area, and hotkey editor.