threadkeeper 0.4.0__py3-none-any.whl

threadkeeper/adapters/copilot.py

@@ -0,0 +1,195 @@
+"""GitHub Copilot CLI adapter.
+
+Config: ~/.copilot/mcp-config.json — JSON with a top-level `mcpServers`
+section (same key as Claude / Gemini, contrary to older bundles that
+shipped an unused `servers` key).
+
+Instructions: Copilot doesn't have a stable single "global" file. Its
+conventionPaths table (from the CLI bundle):
+
+    AGENTS.md                     in cwd and walked-up parents
+    CLAUDE.md                     in cwd, parents, and `.claude/` subdir
+    GEMINI.md                     in cwd and parents
+    copilot-instructions.md       in `.github/` subdir, walked up
+
+Walking up from any project under `~`, Copilot reaches `~/.claude/CLAUDE.md`
+(which our setup manages) and picks it up automatically. We also write
+the canonically-named `~/.copilot/copilot-instructions.md` as a stable
+location user-level symlinks/projects can point at.
+
+Transcripts: ~/.copilot/session-store.db — a sqlite database. Schema:
+  sessions(id, cwd, repository, host_type, branch, summary, created_at, updated_at)
+  turns(id, session_id, turn_index, user_message, assistant_response, timestamp)
+
+Each row in `turns` corresponds to ONE user/assistant exchange. We
+split it into two NormalizedMessage records during ingest so the rest
+of the pipeline (FTS, semantic, skill scan) doesn't have to know
+about the merged-turn shape.
+"""
+from __future__ import annotations
+
+import json
+import shutil
+import sqlite3
+from datetime import datetime
+from pathlib import Path
+from typing import Iterator
+
+from .base import CLIAdapter, NormalizedMessage
+
+
+def _ts(s: str) -> int:
+    try:
+        return int(datetime.fromisoformat(s.replace("Z", "+00:00")).timestamp())
+    except Exception:
+        try:
+            # Copilot stores timestamps via sqlite's datetime('now')
+            # which yields 'YYYY-MM-DD HH:MM:SS' (no T, no tz).
+            return int(datetime.strptime(s, "%Y-%m-%d %H:%M:%S").timestamp())
+        except Exception:
+            import time
+            return int(time.time())
+
+
+class CopilotAdapter(CLIAdapter):
+    name = "copilot"
+
+    def __init__(self) -> None:
+        self.config_path = Path("~/.copilot/mcp-config.json").expanduser()
+        self.session_db = Path("~/.copilot/session-store.db").expanduser()
+        self._instructions = Path("~/.copilot/copilot-instructions.md").expanduser()
+        # Copilot loads hooks from `~/.copilot/hooks.json` (or
+        # `~/.copilot/hooks/hooks.json`). The bundle's schema accepts
+        # the same Claude-Code-compatible shape (`_vsCodeCompat` mode),
+        # so we reuse the helper but write to a dedicated file rather
+        # than into mcp-config.json.
+        self._hooks_path = Path("~/.copilot/hooks.json").expanduser()
+
+    def instructions_path(self):
+        return self._instructions
+
+    def hooks_supported(self) -> bool:
+        return True
+
+    def register_hooks(self, specs, dry_run=False) -> str:
+        from ._hook_helpers import install_claude_style_hooks
+        return install_claude_style_hooks(
+            self._hooks_path, specs, dry_run=dry_run,
+        )
+
+    def is_installed(self) -> bool:
+        if self.config_path.exists() or self.session_db.exists():
+            return True
+        return (
+            shutil.which("copilot") is not None
+            or shutil.which("gh") is not None
+        )
+
+    # ----- MCP registration ---------------------------------------------
+    def register_mcp_server(
+        self, name, command, args, env, dry_run=False
+    ) -> str:
+        cfg: dict
+        if self.config_path.exists():
+            try:
+                cfg = json.loads(self.config_path.read_text())
+            except json.JSONDecodeError:
+                return "copilot: malformed mcp-config.json — refused"
+        else:
+            cfg = {}
+        # Copilot v1.0.43+ schema validates the top-level `mcpServers`
+        # key (same as Claude/Gemini). Older bundles shipped with
+        # `servers` documented; the validator now rejects that file.
+        # If we see a legacy `servers` block, migrate its contents into
+        # `mcpServers` AND drop the legacy key so the file is valid.
+        legacy = cfg.pop("servers", None)
+        if isinstance(legacy, dict):
+            cfg.setdefault("mcpServers", {})
+            for k, v in legacy.items():
+                cfg["mcpServers"].setdefault(k, v)
+        servers = cfg.setdefault("mcpServers", {})
+        entry = {
+            "command": command,
+            "args": list(args),
+        }
+        if env:
+            entry["env"] = dict(env)
+        existing = servers.get(name)
+        if existing == entry and legacy is None:
+            return "copilot: already current"
+        servers[name] = entry
+        if not dry_run:
+            self.config_path.parent.mkdir(parents=True, exist_ok=True)
+            self.config_path.write_text(json.dumps(cfg, indent=2))
+        if legacy is not None:
+            return f"copilot: migrated legacy 'servers' → 'mcpServers' + {'added' if not existing else 'updated'} {name}"
+        return f"copilot: {'would ' if dry_run else ''}{'update' if existing else 'add'}"
+
+    def unregister_mcp_server(self, name, dry_run=False) -> str:
+        if not self.config_path.exists():
+            return "copilot: nothing to remove"
+        cfg = json.loads(self.config_path.read_text())
+        servers = (cfg.get("mcpServers") or cfg.get("servers") or {})
+        if name not in servers:
+            return "copilot: not present"
+        if dry_run:
+            return f"copilot: would remove {name}"
+        servers.pop(name)
+        self.config_path.write_text(json.dumps(cfg, indent=2))
+        return f"copilot: removed {name}"
+
+    # ----- Transcript ingestion -----------------------------------------
+    # Copilot stores transcripts in a single sqlite DB rather than per-
+    # session jsonl files. We treat the DB itself as the single
+    # "transcript file" — ingest's mtime-based incremental scheme works
+    # because Copilot updates the file as new turns land.
+    def session_dir(self):
+        return self.session_db.parent
+
+    def transcript_files(self) -> list[Path]:
+        if self.session_db.exists():
+            return [self.session_db]
+        return []
+
+    def iter_messages(self, fp: Path) -> Iterator[NormalizedMessage]:
+        if not fp.exists():
+            return
+        try:
+            conn = sqlite3.connect(f"file:{fp}?mode=ro&immutable=0", uri=True)
+        except sqlite3.OperationalError:
+            return
+        try:
+            rows = conn.execute(
+                "SELECT session_id, turn_index, user_message, "
+                "assistant_response, timestamp FROM turns "
+                "ORDER BY session_id, turn_index"
+            ).fetchall()
+        except sqlite3.OperationalError:
+            conn.close()
+            return
+        conn.close()
+        for sess_id, turn_idx, user_msg, asst_msg, ts in rows:
+            created = _ts(ts or "")
+            if user_msg:
+                yield NormalizedMessage(
+                    uuid=f"copilot:{sess_id}:{turn_idx}:u",
+                    session_id=sess_id,
+                    role="user",
+                    content=user_msg,
+                    model="",
+                    created_at=created,
+                    raw={"turn_index": turn_idx},
+                )
+            if asst_msg:
+                yield NormalizedMessage(
+                    uuid=f"copilot:{sess_id}:{turn_idx}:a",
+                    session_id=sess_id,
+                    role="assistant",
+                    content=asst_msg,
+                    model="",
+                    created_at=created,
+                    raw={"turn_index": turn_idx},
+                )
+
+
+ADAPTER = CopilotAdapter()

threadkeeper/adapters/gemini.py

@@ -0,0 +1,169 @@
+"""Google Gemini CLI adapter.
+
+Config: ~/.gemini/settings.json with an `mcpServers` section (same
+shape as Claude Code's, JSON).
+
+Transcripts: ~/.gemini/tmp/<user>/chats/session-<ts>-<id>.jsonl
+Each line is a JSON object. First line is session-meta
+({"sessionId", "projectHash", "startTime", ...}). Subsequent lines:
+  {"id": <msg-uuid>, "timestamp": ..., "type": "info"|"user"|"model"|...,
+   "content": <string or structured>}
+We pick `type in {"user", "model"}` as turns; map "model" → "assistant".
+"""
+from __future__ import annotations
+
+import getpass
+import json
+import shutil
+from datetime import datetime
+from pathlib import Path
+from typing import Iterator
+
+from .base import CLIAdapter, NormalizedMessage
+
+
+def _ts(s: str) -> int:
+    try:
+        return int(datetime.fromisoformat(s.replace("Z", "+00:00")).timestamp())
+    except Exception:
+        import time
+        return int(time.time())
+
+
+def _coerce_text(content) -> str:
+    """Gemini content may be: a plain string, a list of segments, or a
+    dict with text/parts. Coerce to a single string."""
+    if isinstance(content, str):
+        return content
+    if isinstance(content, dict):
+        if isinstance(content.get("text"), str):
+            return content["text"]
+        if isinstance(content.get("parts"), list):
+            return "\n".join(_coerce_text(p) for p in content["parts"])
+    if isinstance(content, list):
+        return "\n".join(_coerce_text(x) for x in content if x is not None)
+    return ""
+
+
+class GeminiAdapter(CLIAdapter):
+    name = "gemini"
+
+    def __init__(self) -> None:
+        self.config_path = Path("~/.gemini/settings.json").expanduser()
+        self._instructions = Path("~/.gemini/GEMINI.md").expanduser()
+        # The "chats" tmp tree is per-OS-user; resolve at instance time.
+        self.chats_root = Path(
+            f"~/.gemini/tmp/{getpass.getuser()}/chats"
+        ).expanduser()
+
+    def instructions_path(self):
+        return self._instructions
+
+    def hooks_supported(self) -> bool:
+        return True
+
+    def register_hooks(self, specs, dry_run=False) -> str:
+        # Gemini reads `settings.hooks` in the same shape as Claude
+        # Code (the bundle even ships `gemini hooks migrate --from-claude`),
+        # so the Claude-style helper Just Works for the same file.
+        from ._hook_helpers import install_claude_style_hooks
+        return install_claude_style_hooks(
+            self.config_path, specs, dry_run=dry_run,
+        )
+
+    def is_installed(self) -> bool:
+        if self.config_path.exists() or self.chats_root.parent.exists():
+            return True
+        return shutil.which("gemini") is not None
+
+    # ----- MCP registration ---------------------------------------------
+    def register_mcp_server(
+        self, name, command, args, env, dry_run=False
+    ) -> str:
+        cfg: dict
+        if self.config_path.exists():
+            try:
+                cfg = json.loads(self.config_path.read_text())
+            except json.JSONDecodeError:
+                return "gemini: malformed settings.json — refused"
+        else:
+            cfg = {}
+        servers = cfg.setdefault("mcpServers", {})
+        entry = {
+            "command": command,
+            "args": list(args),
+        }
+        if env:
+            entry["env"] = dict(env)
+        existing = servers.get(name)
+        if existing == entry:
+            return "gemini: already current"
+        servers[name] = entry
+        if not dry_run:
+            self.config_path.parent.mkdir(parents=True, exist_ok=True)
+            self.config_path.write_text(json.dumps(cfg, indent=2))
+        return f"gemini: {'would ' if dry_run else ''}{'update' if existing else 'add'}"
+
+    def unregister_mcp_server(self, name, dry_run=False) -> str:
+        if not self.config_path.exists():
+            return "gemini: nothing to remove"
+        cfg = json.loads(self.config_path.read_text())
+        servers = (cfg.get("mcpServers") or {})
+        if name not in servers:
+            return "gemini: not present"
+        if dry_run:
+            return f"gemini: would remove {name}"
+        servers.pop(name)
+        self.config_path.write_text(json.dumps(cfg, indent=2))
+        return f"gemini: removed {name}"
+
+    # ----- Transcript ingestion -----------------------------------------
+    def session_dir(self):
+        return self.chats_root
+
+    def transcript_files(self) -> list[Path]:
+        if not self.chats_root.exists():
+            return []
+        return list(self.chats_root.glob("session-*.jsonl"))
+
+    def iter_messages(self, fp: Path) -> Iterator[NormalizedMessage]:
+        sess_id = ""
+        try:
+            with fp.open("r", encoding="utf-8", errors="replace") as f:
+                for line in f:
+                    line = line.strip()
+                    if not line:
+                        continue
+                    try:
+                        obj = json.loads(line)
+                    except json.JSONDecodeError:
+                        continue
+                    # session-meta line: first record carries sessionId.
+                    if "sessionId" in obj and "projectHash" in obj:
+                        sess_id = obj.get("sessionId") or ""
+                        continue
+                    typ = obj.get("type")
+                    if typ == "model":
+                        role = "assistant"
+                    elif typ == "user":
+                        role = "user"
+                    else:
+                        continue
+                    uuid = obj.get("id")
+                    if not uuid:
+                        continue
+                    text = _coerce_text(obj.get("content", ""))
+                    yield NormalizedMessage(
+                        uuid=uuid,
+                        session_id=sess_id,
+                        role=role,
+                        content=text,
+                        model=obj.get("model") or "",
+                        created_at=_ts(obj.get("timestamp", "")),
+                        raw=obj,
+                    )
+        except OSError:
+            return
+
+
+ADAPTER = GeminiAdapter()

threadkeeper/adapters/vscode.py

@@ -0,0 +1,144 @@
+"""VS Code adapter — registers thread-keeper in VS Code's user-level
+MCP host (Code 1.93+).
+
+Modern VS Code ships built-in MCP host support, consumed by every
+MCP-aware extension running in the same window: GitHub Copilot Chat,
+the Claude IDE extension, the OpenAI Codex extension, Continue, Cline,
+and others. All of them read the same user-level file:
+
+    macOS:   ~/Library/Application Support/Code/User/mcp.json
+    Linux:   ~/.config/Code/User/mcp.json
+    Windows: %APPDATA%/Code/User/mcp.json
+
+Schema (note `servers`, NOT `mcpServers` — VS Code chose its own key):
+
+    {
+      "inputs":  [ … prompt-string inputs for secrets … ],
+      "servers": {
+        "<name>": {
+          "type":    "stdio" | "http" | "sse",
+          "command": "...",
+          "args":    [...],
+          "env":     {...}
+        }
+      }
+    }
+
+Hooks: VS Code has no SessionStart-style shell hook the way Claude Code
+or Gemini does. Instructions file: per-workspace `.github/instructions/*`
+or `copilot-instructions.md`, not a single global file we can write. So
+this adapter is MCP-registration-only — no hooks, no instructions, no
+transcript ingest.
+"""
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import sys
+from pathlib import Path
+from typing import Iterator
+
+from .base import CLIAdapter, NormalizedMessage
+
+
+def _default_config_path() -> Path:
+    """Per-OS default location for VS Code's user-level mcp.json.
+
+    Overridable via VSCODE_MCP_JSON env var (used by tests)."""
+    env = os.environ.get("VSCODE_MCP_JSON")
+    if env:
+        return Path(env).expanduser()
+    if sys.platform == "darwin":
+        return Path(
+            "~/Library/Application Support/Code/User/mcp.json"
+        ).expanduser()
+    if sys.platform == "win32":
+        appdata = os.environ.get("APPDATA") or "~/AppData/Roaming"
+        return Path(appdata).expanduser() / "Code" / "User" / "mcp.json"
+    # linux / freebsd / etc.
+    return Path("~/.config/Code/User/mcp.json").expanduser()
+
+
+def _vscode_user_dir() -> Path:
+    """The User/ directory itself — used to probe install presence even
+    when mcp.json hasn't been created yet."""
+    return _default_config_path().parent
+
+
+class VSCodeAdapter(CLIAdapter):
+    name = "vscode"
+
+    def __init__(self) -> None:
+        self.config_path = _default_config_path()
+
+    # ----------------------------- detection -----------------------------
+    def is_installed(self) -> bool:
+        # mcp.json already exists OR VS Code is on disk in some form
+        # (User/ profile dir, .app bundle, `code` on PATH).
+        if self.config_path.exists() or _vscode_user_dir().exists():
+            return True
+        if sys.platform == "darwin":
+            if Path("/Applications/Visual Studio Code.app").exists():
+                return True
+        return shutil.which("code") is not None
+
+    # ----------------------------- mcp -----------------------------------
+    def register_mcp_server(
+        self, name, command, args, env, dry_run=False
+    ) -> str:
+        cfg: dict
+        if self.config_path.exists():
+            try:
+                cfg = json.loads(self.config_path.read_text())
+            except json.JSONDecodeError:
+                return "vscode: malformed mcp.json — refused"
+        else:
+            cfg = {}
+        servers = cfg.setdefault("servers", {})
+        entry: dict = {
+            "type": "stdio",
+            "command": command,
+            "args": list(args),
+        }
+        if env:
+            entry["env"] = dict(env)
+        existing = servers.get(name)
+        if existing == entry:
+            return "vscode: already current"
+        servers[name] = entry
+        if not dry_run:
+            self.config_path.parent.mkdir(parents=True, exist_ok=True)
+            self.config_path.write_text(json.dumps(cfg, indent=2))
+        return f"vscode: {'would ' if dry_run else ''}{'update' if existing else 'add'}"
+
+    def unregister_mcp_server(self, name, dry_run=False) -> str:
+        if not self.config_path.exists():
+            return "vscode: nothing to remove"
+        try:
+            cfg = json.loads(self.config_path.read_text())
+        except json.JSONDecodeError:
+            return "vscode: malformed mcp.json — refused"
+        servers = (cfg.get("servers") or {})
+        if name not in servers:
+            return "vscode: not present"
+        if dry_run:
+            return f"vscode: would remove {name}"
+        servers.pop(name)
+        self.config_path.write_text(json.dumps(cfg, indent=2))
+        return f"vscode: removed {name}"
+
+    # ----------------------------- transcripts ---------------------------
+    # VS Code itself doesn't keep a unified MCP transcript on disk —
+    # individual extensions handle chat history their own way (Copilot
+    # via GitHub services; Claude IDE via ~/.claude/projects; etc.).
+    # The Claude-IDE side is already covered by the claude_code adapter,
+    # so there's nothing for the vscode adapter to ingest on top.
+    def transcript_files(self) -> list[Path]:
+        return []
+
+    def iter_messages(self, fp: Path) -> Iterator[NormalizedMessage]:
+        return iter(())
+
+
+ADAPTER = VSCodeAdapter()