flurryx-code-memory 0.4.0__py3-none-any.whl

code_memory/sync/autostart/base.py

@@ -0,0 +1,106 @@
+"""Shared types + platform dispatch for autostart adapters."""
+
+from __future__ import annotations
+
+import logging
+import platform
+import shutil
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from . import Adapter
+
+from ...config import detect_project_slug
+
+log = logging.getLogger("codememory.autostart")
+
+
+@dataclass(frozen=True)
+class AutostartStatus:
+    installed: bool
+    running: bool
+    label: str
+    unit_path: str | None = None
+    note: str | None = None
+
+
+def get_adapter() -> Adapter:
+    """Return the adapter for the current OS."""
+    system = platform.system()
+    if system == "Darwin":
+        from .launchd import LaunchdAdapter
+
+        return LaunchdAdapter()
+    if system == "Linux":
+        from .systemd import SystemdUserAdapter
+
+        return SystemdUserAdapter()
+    if system == "Windows":
+        from .schtasks import SchtasksAdapter
+
+        return SchtasksAdapter()
+    raise RuntimeError(f"unsupported OS: {system}")
+
+
+def ensure_autostart(repo: Path, *, project: str | None = None) -> AutostartStatus:
+    """Install + start the autostart service for ``repo`` if not already.
+
+    Idempotent. Safe to call on every MCP server boot.
+    """
+    from ..safety import UnsafeWatchRootError, assert_safe_watch_root
+
+    try:
+        repo = assert_safe_watch_root(repo)
+    except UnsafeWatchRootError as e:
+        return AutostartStatus(
+            installed=False,
+            running=False,
+            label="<unsafe-root>",
+            note=str(e),
+        )
+    try:
+        adapter = get_adapter()
+    except RuntimeError as e:
+        return AutostartStatus(
+            installed=False,
+            running=False,
+            label="<unsupported>",
+            note=str(e),
+        )
+
+    status = adapter.status(repo)
+    if status.installed and status.running:
+        return status
+    if not status.installed:
+        status = adapter.install(repo)
+    if status.installed and not status.running:
+        status = adapter.start(repo)
+    return status
+
+
+def watcher_command(repo: Path) -> list[str]:
+    """Resolve the command line that launches the watcher.
+
+    Prefer the installed ``code-memory`` script; fall back to ``python -m``
+    invocation when the script isn't on PATH (development checkouts).
+    """
+    exe = shutil.which("code-memory")
+    if exe:
+        return [exe, "watch", str(repo)]
+    return [sys.executable, "-m", "code_memory.cli", "watch", str(repo)]
+
+
+def repo_label(repo: Path) -> str:
+    """Deterministic label / unit name suffix for a repo.
+
+    Uses the same slug logic as project detection so a repo's autostart
+    label matches its project slug — easy to spot in `launchctl list`,
+    `systemctl --user list-units`, or Task Scheduler.
+    """
+    try:
+        return detect_project_slug(repo)
+    except Exception:  # noqa: BLE001
+        return repo.name.lower().replace(" ", "-")

code_memory/sync/autostart/launchd.py

@@ -0,0 +1,115 @@
+"""macOS launchd LaunchAgent adapter."""
+
+from __future__ import annotations
+
+import os
+import plistlib
+import subprocess
+from pathlib import Path
+
+from .base import AutostartStatus, repo_label, watcher_command
+
+LABEL_PREFIX = "com.codememory.watch"
+
+
+class LaunchdAdapter:
+    def _label(self, repo: Path) -> str:
+        return f"{LABEL_PREFIX}.{repo_label(repo)}"
+
+    def _plist_path(self, repo: Path) -> Path:
+        agents = Path.home() / "Library" / "LaunchAgents"
+        return agents / f"{self._label(repo)}.plist"
+
+    def _logs_dir(self) -> Path:
+        return Path.home() / "Library" / "Logs" / "codememory"
+
+    # ------------------------------------------------------------------
+
+    def install(self, repo: Path) -> AutostartStatus:
+        repo = Path(repo).resolve()
+        path = self._plist_path(repo)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        logs = self._logs_dir()
+        logs.mkdir(parents=True, exist_ok=True)
+        label = self._label(repo)
+
+        plist = {
+            "Label": label,
+            "ProgramArguments": watcher_command(repo),
+            "WorkingDirectory": str(repo),
+            "RunAtLoad": True,
+            "KeepAlive": True,
+            "StandardOutPath": str(logs / f"{label}.log"),
+            "StandardErrorPath": str(logs / f"{label}.err"),
+            "ProcessType": "Background",
+            "EnvironmentVariables": {
+                "PATH": os.environ.get(
+                    "PATH",
+                    "/usr/local/bin:/opt/homebrew/bin:/usr/bin:/bin",
+                ),
+            },
+        }
+        with path.open("wb") as fh:
+            plistlib.dump(plist, fh)
+        return AutostartStatus(
+            installed=True,
+            running=False,
+            label=label,
+            unit_path=str(path),
+        )
+
+    def uninstall(self, repo: Path) -> AutostartStatus:
+        label = self._label(repo)
+        path = self._plist_path(repo)
+        domain = f"gui/{os.getuid()}"
+        subprocess.run(
+            ["launchctl", "bootout", domain, str(path)],
+            capture_output=True,
+            check=False,
+        )
+        path.unlink(missing_ok=True)
+        return AutostartStatus(
+            installed=False, running=False, label=label, unit_path=str(path)
+        )
+
+    def status(self, repo: Path) -> AutostartStatus:
+        label = self._label(repo)
+        path = self._plist_path(repo)
+        installed = path.is_file()
+        running = False
+        if installed:
+            out = subprocess.run(
+                ["launchctl", "list", label],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+            running = out.returncode == 0
+        return AutostartStatus(
+            installed=installed,
+            running=running,
+            label=label,
+            unit_path=str(path),
+        )
+
+    def start(self, repo: Path) -> AutostartStatus:
+        label = self._label(repo)
+        path = self._plist_path(repo)
+        domain = f"gui/{os.getuid()}"
+        # bootstrap (may fail if already loaded — that's fine)
+        subprocess.run(
+            ["launchctl", "bootstrap", domain, str(path)],
+            capture_output=True,
+            check=False,
+        )
+        subprocess.run(
+            ["launchctl", "enable", f"{domain}/{label}"],
+            capture_output=True,
+            check=False,
+        )
+        subprocess.run(
+            ["launchctl", "kickstart", "-k", f"{domain}/{label}"],
+            capture_output=True,
+            check=False,
+        )
+        return self.status(repo)

code_memory/sync/autostart/schtasks.py

@@ -0,0 +1,155 @@
+"""Windows Task Scheduler adapter.
+
+Registers a per-user logon trigger via ``schtasks`` (no admin required).
+Uses an XML definition so we can configure restart-on-failure semantics
+that the simple ``/Create`` flags don't expose.
+"""
+
+from __future__ import annotations
+
+import getpass
+import subprocess
+import tempfile
+from pathlib import Path
+from xml.sax.saxutils import escape
+
+from .base import AutostartStatus, repo_label, watcher_command
+
+TASK_FOLDER = "CodeMemory\\Watch"
+
+
+class SchtasksAdapter:
+    def _task_name(self, repo: Path) -> str:
+        return f"{TASK_FOLDER}\\{repo_label(repo)}"
+
+    def install(self, repo: Path) -> AutostartStatus:
+        repo = Path(repo).resolve()
+        argv = watcher_command(repo)
+        exe = argv[0]
+        args = " ".join(_quote_win(a) for a in argv[1:])
+        user = getpass.getuser()
+        xml = _TASK_XML_TEMPLATE.format(
+            description=escape(f"code-memory watcher for {repo}"),
+            user=escape(user),
+            exe=escape(exe),
+            args=escape(args),
+            working_dir=escape(str(repo)),
+        )
+        with tempfile.NamedTemporaryFile(
+            "w", suffix=".xml", delete=False, encoding="utf-16"
+        ) as fh:
+            fh.write(xml)
+            xml_path = fh.name
+        try:
+            res = subprocess.run(
+                [
+                    "schtasks",
+                    "/Create",
+                    "/TN",
+                    self._task_name(repo),
+                    "/XML",
+                    xml_path,
+                    "/F",
+                ],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+            ok = res.returncode == 0
+        finally:
+            Path(xml_path).unlink(missing_ok=True)
+        return AutostartStatus(
+            installed=ok,
+            running=False,
+            label=self._task_name(repo),
+            note=None if ok else res.stderr.strip(),
+        )
+
+    def uninstall(self, repo: Path) -> AutostartStatus:
+        name = self._task_name(repo)
+        subprocess.run(
+            ["schtasks", "/Delete", "/TN", name, "/F"],
+            capture_output=True,
+            check=False,
+        )
+        return AutostartStatus(installed=False, running=False, label=name)
+
+    def status(self, repo: Path) -> AutostartStatus:
+        name = self._task_name(repo)
+        out = subprocess.run(
+            ["schtasks", "/Query", "/TN", name, "/FO", "LIST"],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        if out.returncode != 0:
+            return AutostartStatus(installed=False, running=False, label=name)
+        running = "Status:" in out.stdout and "Running" in out.stdout
+        return AutostartStatus(installed=True, running=running, label=name)
+
+    def start(self, repo: Path) -> AutostartStatus:
+        name = self._task_name(repo)
+        subprocess.run(
+            ["schtasks", "/Run", "/TN", name],
+            capture_output=True,
+            check=False,
+        )
+        return self.status(repo)
+
+
+def _quote_win(arg: str) -> str:
+    if not arg or any(c in arg for c in ' \t"'):
+        return '"' + arg.replace('"', '\\"') + '"'
+    return arg
+
+
+_TASK_XML_TEMPLATE = """<?xml version="1.0" encoding="UTF-16"?>
+<Task version="1.4" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
+  <RegistrationInfo>
+    <Description>{description}</Description>
+  </RegistrationInfo>
+  <Triggers>
+    <LogonTrigger>
+      <Enabled>true</Enabled>
+      <UserId>{user}</UserId>
+    </LogonTrigger>
+  </Triggers>
+  <Principals>
+    <Principal id="Author">
+      <UserId>{user}</UserId>
+      <LogonType>InteractiveToken</LogonType>
+      <RunLevel>LeastPrivilege</RunLevel>
+    </Principal>
+  </Principals>
+  <Settings>
+    <MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>
+    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>
+    <StopIfGoingOnBatteries>false</StopIfGoingOnBatteries>
+    <AllowHardTerminate>true</AllowHardTerminate>
+    <StartWhenAvailable>true</StartWhenAvailable>
+    <RunOnlyIfNetworkAvailable>false</RunOnlyIfNetworkAvailable>
+    <IdleSettings>
+      <StopOnIdleEnd>false</StopOnIdleEnd>
+      <RestartOnIdle>false</RestartOnIdle>
+    </IdleSettings>
+    <AllowStartOnDemand>true</AllowStartOnDemand>
+    <Enabled>true</Enabled>
+    <Hidden>false</Hidden>
+    <RunOnlyIfIdle>false</RunOnlyIfIdle>
+    <WakeToRun>false</WakeToRun>
+    <ExecutionTimeLimit>PT0S</ExecutionTimeLimit>
+    <Priority>7</Priority>
+    <RestartOnFailure>
+      <Interval>PT1M</Interval>
+      <Count>999</Count>
+    </RestartOnFailure>
+  </Settings>
+  <Actions Context="Author">
+    <Exec>
+      <Command>{exe}</Command>
+      <Arguments>{args}</Arguments>
+      <WorkingDirectory>{working_dir}</WorkingDirectory>
+    </Exec>
+  </Actions>
+</Task>
+"""

code_memory/sync/autostart/systemd.py

@@ -0,0 +1,113 @@
+"""Linux systemd --user adapter."""
+
+from __future__ import annotations
+
+import os
+import shlex
+import subprocess
+from pathlib import Path
+
+from .base import AutostartStatus, repo_label, watcher_command
+
+UNIT_PREFIX = "codememory-watch"
+
+
+class SystemdUserAdapter:
+    def _unit(self, repo: Path) -> str:
+        return f"{UNIT_PREFIX}-{repo_label(repo)}.service"
+
+    def _unit_path(self, repo: Path) -> Path:
+        base = (
+            Path(os.environ.get("XDG_CONFIG_HOME", str(Path.home() / ".config")))
+            / "systemd"
+            / "user"
+        )
+        return base / self._unit(repo)
+
+    # ------------------------------------------------------------------
+
+    def install(self, repo: Path) -> AutostartStatus:
+        repo = Path(repo).resolve()
+        unit_path = self._unit_path(repo)
+        unit_path.parent.mkdir(parents=True, exist_ok=True)
+        exec_start = " ".join(shlex.quote(arg) for arg in watcher_command(repo))
+        unit = f"""[Unit]
+Description=code-memory watcher ({repo.name})
+After=default.target
+
+[Service]
+Type=simple
+ExecStart={exec_start}
+WorkingDirectory={repo}
+Restart=on-failure
+RestartSec=5
+Environment=PATH={os.environ.get('PATH', '/usr/local/bin:/usr/bin:/bin')}
+
+[Install]
+WantedBy=default.target
+"""
+        unit_path.write_text(unit)
+        subprocess.run(
+            ["systemctl", "--user", "daemon-reload"],
+            capture_output=True,
+            check=False,
+        )
+        return AutostartStatus(
+            installed=True,
+            running=False,
+            label=self._unit(repo),
+            unit_path=str(unit_path),
+        )
+
+    def uninstall(self, repo: Path) -> AutostartStatus:
+        unit = self._unit(repo)
+        path = self._unit_path(repo)
+        subprocess.run(
+            ["systemctl", "--user", "disable", "--now", unit],
+            capture_output=True,
+            check=False,
+        )
+        path.unlink(missing_ok=True)
+        subprocess.run(
+            ["systemctl", "--user", "daemon-reload"],
+            capture_output=True,
+            check=False,
+        )
+        return AutostartStatus(
+            installed=False, running=False, label=unit, unit_path=str(path)
+        )
+
+    def status(self, repo: Path) -> AutostartStatus:
+        unit = self._unit(repo)
+        path = self._unit_path(repo)
+        installed = path.is_file()
+        running = False
+        if installed:
+            out = subprocess.run(
+                ["systemctl", "--user", "is-active", unit],
+                capture_output=True,
+                text=True,
+                check=False,
+            )
+            running = out.stdout.strip() == "active"
+        return AutostartStatus(
+            installed=installed,
+            running=running,
+            label=unit,
+            unit_path=str(path),
+        )
+
+    def start(self, repo: Path) -> AutostartStatus:
+        unit = self._unit(repo)
+        subprocess.run(
+            ["systemctl", "--user", "enable", "--now", unit],
+            capture_output=True,
+            check=False,
+        )
+        # best-effort linger so the service can run without active session
+        subprocess.run(
+            ["loginctl", "enable-linger", os.getenv("USER", "")],
+            capture_output=True,
+            check=False,
+        )
+        return self.status(repo)

code_memory/sync/hooks.py

@@ -0,0 +1,164 @@
+"""Git hooks installer: post-checkout / post-merge / post-rewrite / post-commit.
+
+Each hook fires ``code-memory sync`` in the background. Hooks are
+idempotent — the installer detects an existing code-memory block and
+overwrites it without disturbing the rest of the file. Plain ``rm`` of
+the marker block removes our integration cleanly.
+"""
+
+from __future__ import annotations
+
+import os
+import stat
+from dataclasses import dataclass
+from pathlib import Path
+
+HOOKS = ("post-checkout", "post-merge", "post-rewrite", "post-commit", "post-applypatch")
+
+MARKER_START = "# >>> code-memory sync >>>"
+MARKER_END = "# <<< code-memory sync <<<"
+
+
+@dataclass(frozen=True)
+class HookInstallResult:
+    installed: list[str]
+    skipped: list[str]
+    hooks_dir: str
+
+
+def install_hooks(repo: Path, *, trigger_cmd: str | None = None) -> HookInstallResult:
+    """Install code-memory hooks into ``repo``.
+
+    Returns lists of hook names that were (re)written vs skipped.
+    """
+    repo = Path(repo).resolve()
+    hooks_dir = _hooks_dir(repo)
+    hooks_dir.mkdir(parents=True, exist_ok=True)
+
+    trigger = trigger_cmd or _default_trigger()
+    installed: list[str] = []
+    skipped: list[str] = []
+    for hook in HOOKS:
+        path = hooks_dir / hook
+        block = _block_for(hook, trigger)
+        if path.exists():
+            current = path.read_text()
+            if MARKER_START in current and MARKER_END in current:
+                new = _replace_block(current, block)
+                if new == current:
+                    skipped.append(hook)
+                    continue
+            else:
+                new = current.rstrip() + "\n\n" + block + "\n"
+        else:
+            new = "#!/usr/bin/env bash\nset -euo pipefail\n\n" + block + "\n"
+        path.write_text(new)
+        _chmod_exec(path)
+        installed.append(hook)
+    return HookInstallResult(
+        installed=installed,
+        skipped=skipped,
+        hooks_dir=str(hooks_dir),
+    )
+
+
+def uninstall_hooks(repo: Path) -> HookInstallResult:
+    repo = Path(repo).resolve()
+    hooks_dir = _hooks_dir(repo)
+    removed: list[str] = []
+    skipped: list[str] = []
+    for hook in HOOKS:
+        path = hooks_dir / hook
+        if not path.exists():
+            skipped.append(hook)
+            continue
+        content = path.read_text()
+        if MARKER_START not in content:
+            skipped.append(hook)
+            continue
+        stripped = _strip_block(content)
+        if stripped.strip() in ("", "#!/usr/bin/env bash", "#!/usr/bin/env bash\nset -euo pipefail"):
+            path.unlink()
+        else:
+            path.write_text(stripped)
+            _chmod_exec(path)
+        removed.append(hook)
+    return HookInstallResult(
+        installed=removed,
+        skipped=skipped,
+        hooks_dir=str(hooks_dir),
+    )
+
+
+def hook_status(repo: Path) -> dict[str, bool]:
+    hooks_dir = _hooks_dir(Path(repo).resolve())
+    out: dict[str, bool] = {}
+    for hook in HOOKS:
+        path = hooks_dir / hook
+        out[hook] = path.is_file() and MARKER_START in path.read_text(errors="ignore")
+    return out
+
+
+# ---------------------------------------------------------------------------
+
+
+def _hooks_dir(repo: Path) -> Path:
+    """Return the hooks directory honouring ``core.hooksPath`` when set."""
+    import subprocess
+
+    out = subprocess.run(
+        ["git", "-C", str(repo), "config", "--get", "core.hooksPath"],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    custom = out.stdout.strip()
+    if custom:
+        p = Path(custom)
+        if not p.is_absolute():
+            p = repo / p
+        return p
+    return repo / ".git" / "hooks"
+
+
+def _default_trigger() -> str:
+    """The command embedded in each hook.
+
+    Background + disown so git never blocks on the sync. Stderr -> log
+    file so failures are observable.
+    """
+    log_path = "$HOME/.cache/codememory/hook.log"
+    return (
+        f"mkdir -p \"$(dirname {log_path})\" && "
+        f"( code-memory sync . --trigger \"$HOOK\" "
+        f">> {log_path} 2>&1 & ) "
+        "; disown 2>/dev/null || true"
+    )
+
+
+def _block_for(hook: str, trigger: str) -> str:
+    return (
+        f"{MARKER_START}\n"
+        f"HOOK={hook}\n"
+        f"command -v code-memory >/dev/null 2>&1 && {{ {trigger}; }}\n"
+        f"{MARKER_END}"
+    )
+
+
+def _replace_block(content: str, block: str) -> str:
+    start = content.index(MARKER_START)
+    end = content.index(MARKER_END, start) + len(MARKER_END)
+    return content[:start] + block + content[end:]
+
+
+def _strip_block(content: str) -> str:
+    start = content.index(MARKER_START)
+    end = content.index(MARKER_END, start) + len(MARKER_END)
+    return (content[:start].rstrip() + "\n" + content[end:].lstrip()).strip() + "\n"
+
+
+def _chmod_exec(path: Path) -> None:
+    if os.name == "nt":
+        return  # Git for Windows uses bash; chmod n/a
+    mode = path.stat().st_mode
+    path.chmod(mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)