Merge pull request #61 from levelsoulove/pr60-plugins

feat(plugins): 引入插件系统与命令面板、全局快捷键基础设施

Author: EchoFish

commands.py

@@ -0,0 +1,65 @@
+"""Central command registry powering the command palette and shortcuts.
+
+Core actions and plugin-provided actions register here under a unique id with a
+human title and a callable. The palette does fuzzy filtering over titles.
+"""
+from dataclasses import dataclass
+from typing import Callable, Dict, List
+
+
+@dataclass
+class Command:
+    id: str
+    title: str
+    handler: Callable
+    shortcut: str = ""
+
+
+class CommandRegistry:
+    def __init__(self):
+        self._commands: Dict[str, Command] = {}
+
+    def register(self, command_id: str, title: str, handler: Callable, shortcut: str = ""):
+        if command_id in self._commands:
+            raise ValueError(f"命令已注册: {command_id}")
+        self._commands[command_id] = Command(command_id, title, handler, shortcut)
+
+    def unregister(self, command_id: str):
+        self._commands.pop(command_id, None)
+
+    def get(self, command_id: str) -> Command:
+        return self._commands[command_id]
+
+    def all(self) -> List[Command]:
+        return list(self._commands.values())
+
+    def execute(self, command_id: str, *args, **kwargs):
+        return self._commands[command_id].handler(*args, **kwargs)
+
+    def search(self, query: str) -> List[Command]:
+        """Subsequence (fuzzy) match over titles and ids, ranked by position."""
+        q = query.lower().strip()
+        if not q:
+            return self.all()
+        scored = []
+        for cmd in self._commands.values():
+            hay = (cmd.title + " " + cmd.id).lower()
+            score = _subseq_score(q, hay)
+            if score is not None:
+                scored.append((score, cmd))
+        scored.sort(key=lambda s: s[0])
+        return [cmd for _s, cmd in scored]
+
+
+def _subseq_score(query: str, text: str):
+    """Return a score (lower=better) if query is a subsequence of text, else None."""
+    pos = 0
+    first = None
+    for ch in query:
+        idx = text.find(ch, pos)
+        if idx == -1:
+            return None
+        if first is None:
+            first = idx
+        pos = idx + 1
+    return (first, pos - first)  # prefer earlier + tighter matches

config.py

@@ -81,6 +81,9 @@ def __init__(self):
         self.reminder_interval = 300   # seconds between scans
         self.reminder_lead_days = 1    # remind when due within N days
 
+        # Plugins directory (each *.py exposes register(context)).
+        self.plugins_dir = self.data_dir / "plugins"
+
         self.window_width = 1200
         self.window_height = 800
         self.theme_color = "#2c3e50"

examples/hello_plugin.py

@@ -0,0 +1,18 @@
+"""Example SmartNotes plugin.
+
+Drop a copy into your plugins directory. On load it registers a command that
+becomes available in the command palette (Ctrl+Shift+P).
+"""
+
+
+def register(context):
+    registry = context["registry"]
+
+    def say_hello():
+        app = context.get("app")
+        msg = "你好，来自示例插件 👋"
+        if app is not None and hasattr(app, "_set_status"):
+            app._set_status(msg)
+        return msg
+
+    registry.register("plugin.hello", "示例插件: 打招呼", say_hello)

gui.py

@@ -44,11 +44,16 @@ def __init__(self, root):
         self.auto_save_job = None
         self.is_modified = False
 
+        from commands import CommandRegistry  # noqa: PLC0415
+        self.commands = CommandRegistry()
+
         self.setup_styles()
         self.create_menu()
         self.create_widgets()
         self.load_notes_list()
         self.rebuild_search_index()
+        self._register_core_commands()
+        self._load_plugins()
 
         if config.auto_save:
             self.start_auto_save()
@@ -188,6 +193,65 @@ def _build_view_menu(self, menubar):
         view_menu.add_command(label="历史版本", command=self.show_history)
         view_menu.add_command(label="全屏", accelerator="F11")
 
+    def _register_core_commands(self):
+        actions = [
+            ("core.new_note", "新建笔记", self.create_note, "Ctrl+N"),
+            ("core.save_note", "保存笔记", self.save_current_note, "Ctrl+S"),
+            ("core.search", "搜索", self.show_search, "Ctrl+F"),
+            ("core.preview", "切换预览", self.toggle_preview, ""),
+            ("core.todo", "待办列表", self.show_todo_view, ""),
+            ("core.dashboard", "任务仪表盘", self.show_dashboard, ""),
+            ("core.settings", "设置", self.show_settings, ""),
+            ("core.rebuild_index", "重建索引", self.rebuild_search_index, ""),
+        ]
+        for cid, title, handler, shortcut in actions:
+            try:
+                self.commands.register(cid, title, handler, shortcut)
+            except ValueError:  # noqa: PERF203 - idempotent registration guard
+                pass  # already registered
+
+    def _load_plugins(self):
+        from plugins import loader  # noqa: PLC0415
+        context = {"registry": self.commands, "app": self}
+        loaded = loader.load_all(config.plugins_dir, context)
+        if loaded:
+            self._set_status(f"已加载插件: {', '.join(loaded)}")
+
+    def show_command_palette(self, event=None):
+        win = tk.Toplevel(self.root)
+        win.title("命令面板")
+        win.geometry("440x320")
+        entry = tk.Entry(win, font=('Microsoft YaHei UI', 12))
+        entry.pack(fill='x', padx=8, pady=8)
+        listbox = tk.Listbox(win)
+        listbox.pack(fill='both', expand=True, padx=8, pady=(0, 8))
+
+        state = {"cmds": []}
+
+        def refresh(*_):
+            listbox.delete(0, tk.END)
+            state["cmds"] = self.commands.search(entry.get())
+            for cmd in state["cmds"]:
+                sc = f"  ({cmd.shortcut})" if cmd.shortcut else ""
+                listbox.insert(tk.END, cmd.title + sc)
+            if state["cmds"]:
+                listbox.selection_set(0)
+
+        def run(_e=None):
+            sel = listbox.curselection()
+            idx = sel[0] if sel else 0
+            if state["cmds"]:
+                cmd = state["cmds"][idx]
+                win.destroy()
+                self.commands.execute(cmd.id)
+
+        entry.bind('<KeyRelease>', refresh)
+        entry.bind('<Return>', run)
+        listbox.bind('<Double-Button-1>', run)
+        refresh()
+        entry.focus()
+        return "break"
+
     def _bind_shortcuts(self):
         self.root.bind('<Control-n>', lambda e: self.create_note())
         self.root.bind('<Control-s>', lambda e: self.save_current_note())
@@ -198,6 +262,8 @@ def _bind_shortcuts(self):
         self.root.bind('<Control-b>', lambda e: self._md_wrap("bold"))
         self.root.bind('<Control-i>', lambda e: self._md_wrap("italic"))
         self.root.bind('<F9>', lambda e: self.toggle_focus_mode())
+        self.root.bind('<Control-Shift-P>', self.show_command_palette)
+        self.root.bind('<Control-Shift-p>', self.show_command_palette)
 
     def create_widgets(self):
         main_container = ttk.PanedWindow(self.root, orient=tk.HORIZONTAL)

plugins/__init__.py

@@ -0,0 +1 @@
+"""Plugin system for SmartNotes."""

plugins/loader.py

@@ -0,0 +1,42 @@
+"""Discover and load plugins.
+
+A plugin is a Python module exposing ``register(context)``, where context gives
+access to the command registry (and, in the running app, the main window). We
+discover ``*.py`` files in a plugins directory and import them.
+"""
+import importlib.util
+import logging
+from pathlib import Path
+from typing import List
+
+logger = logging.getLogger(__name__)
+
+
+def discover(plugins_dir: Path) -> List[Path]:
+    plugins_dir = Path(plugins_dir)
+    if not plugins_dir.exists():
+        return []
+    return sorted(p for p in plugins_dir.glob("*.py") if not p.name.startswith("_"))
+
+
+def load_module(path: Path):
+    spec = importlib.util.spec_from_file_location(f"smartnotes_plugin_{path.stem}", path)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+def load_all(plugins_dir: Path, context) -> List[str]:
+    """Import each plugin and call its register(context). Returns loaded names."""
+    loaded = []
+    for path in discover(plugins_dir):
+        try:
+            module = load_module(path)
+            if hasattr(module, "register"):
+                module.register(context)
+                loaded.append(path.stem)
+            else:
+                logger.warning("插件 %s 缺少 register(context)", path.name)
+        except Exception:  # noqa: PERF203 - isolate per-plugin failures
+            logger.exception("加载插件失败: %s", path.name)
+    return loaded

tests/test_commands.py

@@ -0,0 +1,63 @@
+"""Command registry: register/execute, fuzzy search, and plugin loading."""
+import pathlib
+
+from commands import CommandRegistry
+from plugins import loader
+
+
+def test_register_and_execute():
+    reg = CommandRegistry()
+    calls = []
+    reg.register("a.b", "Do Thing", lambda: calls.append(1))
+    reg.execute("a.b")
+    assert calls == [1]
+
+
+def test_duplicate_registration_rejected():
+    reg = CommandRegistry()
+    reg.register("x", "X", lambda: None)
+    try:
+        reg.register("x", "X again", lambda: None)
+        assert False, "expected ValueError"
+    except ValueError:
+        pass
+
+
+def test_fuzzy_search_subsequence():
+    reg = CommandRegistry()
+    reg.register("core.new_note", "新建笔记", lambda: None)
+    reg.register("core.save_note", "保存笔记", lambda: None)
+    reg.register("core.settings", "设置", lambda: None)
+    titles = [c.title for c in reg.search("note")]
+    assert "新建笔记" in titles and "保存笔记" in titles
+    # empty query returns everything
+    assert len(reg.search("")) == 3
+
+
+def test_unregister():
+    reg = CommandRegistry()
+    reg.register("x", "X", lambda: None)
+    reg.unregister("x")
+    assert reg.all() == []
+
+
+def test_plugin_discovery_and_load(tmp_path):
+    plugin = tmp_path / "myplugin.py"
+    plugin.write_text(
+        "def register(context):\n"
+        "    context['registry'].register('p.hi', 'Plugin Hi', lambda: 'hi')\n",
+        encoding="utf-8",
+    )
+    reg = CommandRegistry()
+    loaded = loader.load_all(tmp_path, {"registry": reg})
+    assert "myplugin" in loaded
+    assert reg.execute("p.hi") == "hi"
+
+
+def test_example_plugin_registers(tmp_path):
+    # the shipped example plugin should load and register its command
+    example = pathlib.Path(loader.__file__).resolve().parent.parent / "examples" / "hello_plugin.py"
+    reg = CommandRegistry()
+    mod = loader.load_module(example)
+    mod.register({"registry": reg, "app": None})
+    assert any(c.id == "plugin.hello" for c in reg.all())