context-forge-cli 0.4.11__tar.gz → 0.4.12__tar.gz

{context_forge_cli-0.4.11 → context_forge_cli-0.4.12}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: context-forge-cli
-Version: 0.4.11
+Version: 0.4.12
 Summary: Session manager and context bridge for agentic CLI tools
 Project-URL: Homepage, https://github.com/emmver/contextforge
 Project-URL: Repository, https://github.com/emmver/contextforge
@@ -171,6 +171,7 @@ The method is chosen automatically based on token count and whether a target ses
 | Gemini | `~/.gemini/tmp/<project_hash>/chats/` JSON | New session / `/resume` |
 | Antigravity | `~/.gemini/antigravity-cli/history.jsonl` | `-i` / `--conversation` |
 | altimate-code | `~/.local/share/altimate-code/opencode.db` | `run -s` / `import` |
+| Cursor | `~/.config/Cursor/User/globalStorage/state.vscdb` | `cursor-agent -p` / `--resume` |
 
 ## Session Summaries
 

{context_forge_cli-0.4.11 → context_forge_cli-0.4.12}/PLAN.md

@@ -88,6 +88,7 @@ Agents and contributors: update this file as you work.
 - [ ] GitHub Actions CI: `uv run pytest --cov=contextforge`
 - [ ] `open-claw` adapter (if/when CLI interface is documented)
 - [x] Antigravity adapter (`adapters/antigravity.py`)
+- [x] Cursor adapter (`adapters/cursor.py`)
 - [ ] Session search: `cf ls --search <query>`
 - [ ] Session archiving: `cf archive <id>`
 

{context_forge_cli-0.4.11 → context_forge_cli-0.4.12}/README.md

@@ -142,6 +142,7 @@ The method is chosen automatically based on token count and whether a target ses
 | Gemini | `~/.gemini/tmp/<project_hash>/chats/` JSON | New session / `/resume` |
 | Antigravity | `~/.gemini/antigravity-cli/history.jsonl` | `-i` / `--conversation` |
 | altimate-code | `~/.local/share/altimate-code/opencode.db` | `run -s` / `import` |
+| Cursor | `~/.config/Cursor/User/globalStorage/state.vscdb` | `cursor-agent -p` / `--resume` |
 
 ## Session Summaries
 

context_forge_cli-0.4.12/contextforge/adapters/cursor.py

@@ -0,0 +1,341 @@
+"""Adapter for Cursor IDE chat/composer sessions.
+
+Cursor stores conversation data in SQLite ("state.vscdb") files under its
+user data directory:
+
+  - ``globalStorage/state.vscdb`` — authoritative store for full conversation
+    content, shared across all workspaces. Conversations ("composers") live
+    in the ``cursorDiskKV`` table as ``composerData:<composerId>`` rows, and
+    individual chat turns ("bubbles") as ``bubbleId:<composerId>:<bubbleId>``
+    rows.
+  - ``workspaceStorage/<hash>/state.vscdb`` + ``workspace.json`` — per-workspace
+    metadata used here only to recover the project cwd for a composer (older
+    Cursor versions also kept a workspace-local composer index here).
+
+Cursor's storage schema has drifted across versions (schema version is
+tracked via a ``_v`` field on composer objects), so this adapter reads
+fields defensively with ``.get()`` and falls back to scanning bubbles
+directly when the ``fullConversationHeadersOnly`` index is absent.
+"""
+from __future__ import annotations
+
+import json
+import os
+import shlex
+import sqlite3
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+from urllib.parse import unquote, urlparse
+
+import tiktoken
+
+from contextforge.adapters.base import ToolAdapter
+from contextforge.models.session import Message, Session
+
+
+def _cursor_user_dir() -> Path:
+    """Return Cursor's per-OS "User" data directory."""
+    if sys.platform == "darwin":
+        return Path.home() / "Library" / "Application Support" / "Cursor" / "User"
+    if sys.platform.startswith("win"):
+        appdata = os.environ.get("APPDATA")
+        base = Path(appdata) if appdata else Path.home() / "AppData" / "Roaming"
+        return base / "Cursor" / "User"
+    return Path.home() / ".config" / "Cursor" / "User"
+
+
+_CURSOR_USER_DIR = _cursor_user_dir()
+_GLOBAL_DB = _CURSOR_USER_DIR / "globalStorage" / "state.vscdb"
+_WORKSPACE_STORAGE_DIR = _CURSOR_USER_DIR / "workspaceStorage"
+
+
+def _count_tokens(text: str) -> int:
+    """Count tokens in text using tiktoken for Claude models."""
+    try:
+        enc = tiktoken.encoding_for_model("claude-3-5-sonnet-20241022")
+        return len(enc.encode(text))
+    except Exception:
+        # Fallback: rough estimate (~4 chars per token)
+        return len(text) // 4
+
+
+def _ms_to_dt(ts) -> datetime | None:
+    """Convert a millisecond timestamp to UTC datetime, or None if unusable."""
+    if not ts:
+        return None
+    try:
+        return datetime.fromtimestamp(int(ts) / 1000, tz=timezone.utc)
+    except (TypeError, ValueError, OSError, OverflowError):
+        return None
+
+
+def _uri_to_path(uri: str) -> str | None:
+    """Convert a workspace.json ``file://`` URI to a plain filesystem path."""
+    if not uri:
+        return None
+    try:
+        parsed = urlparse(uri)
+    except ValueError:
+        return None
+    if parsed.scheme == "file":
+        return unquote(parsed.path)
+    return uri
+
+
+def _load_json_blob(value) -> dict | list | None:
+    """Decode a BLOB/TEXT value from an ItemTable/cursorDiskKV row into JSON."""
+    if value is None:
+        return None
+    if isinstance(value, bytes):
+        try:
+            value = value.decode("utf-8")
+        except UnicodeDecodeError:
+            return None
+    try:
+        return json.loads(value)
+    except (json.JSONDecodeError, TypeError):
+        return None
+
+
+class CursorAdapter(ToolAdapter):
+    tool_name = "cursor"
+    default_paths = [_GLOBAL_DB]
+
+    def _workspace_paths(self) -> dict[str, str]:
+        """Map workspaceStorage hash-dir names to their project path."""
+        mapping: dict[str, str] = {}
+        if not _WORKSPACE_STORAGE_DIR.exists():
+            return mapping
+        for ws_dir in _WORKSPACE_STORAGE_DIR.iterdir():
+            if not ws_dir.is_dir():
+                continue
+            meta_file = ws_dir / "workspace.json"
+            if not meta_file.exists():
+                continue
+            try:
+                with meta_file.open() as f:
+                    meta = json.load(f)
+            except (json.JSONDecodeError, OSError):
+                continue
+            uri = meta.get("folder") or meta.get("workspace")
+            path = _uri_to_path(uri) if isinstance(uri, str) else None
+            if path:
+                mapping[ws_dir.name] = path
+        return mapping
+
+    def _composer_workspace_map(self) -> dict[str, str]:
+        """Map composerId -> project cwd via each workspace's local state.vscdb.
+
+        Only populated on Cursor <=2.6, which kept a per-workspace composer
+        index (``composer.composerData`` in ``ItemTable``) before the 3.0+
+        global-index refactor. Newer versions simply won't match here, and
+        callers should treat a missing entry as "cwd unknown".
+        """
+        composer_to_ws: dict[str, str] = {}
+        if not _WORKSPACE_STORAGE_DIR.exists():
+            return composer_to_ws
+        ws_paths = self._workspace_paths()
+        for ws_dir in _WORKSPACE_STORAGE_DIR.iterdir():
+            cwd = ws_paths.get(ws_dir.name)
+            db_path = ws_dir / "state.vscdb"
+            if not cwd or not db_path.exists():
+                continue
+            try:
+                conn = sqlite3.connect(str(db_path))
+                cur = conn.cursor()
+                cur.execute(
+                    "SELECT value FROM ItemTable WHERE key = 'composer.composerData'"
+                )
+                row = cur.fetchone()
+                conn.close()
+            except sqlite3.Error:
+                continue
+            data = _load_json_blob(row[0]) if row else None
+            if not isinstance(data, dict):
+                continue
+            for entry in data.get("allComposers") or []:
+                cid = entry.get("composerId") if isinstance(entry, dict) else None
+                if cid:
+                    composer_to_ws[cid] = cwd
+        return composer_to_ws
+
+    def discover_sessions(self) -> list[Session]:
+        if not _GLOBAL_DB.exists():
+            return []
+
+        try:
+            conn = sqlite3.connect(str(_GLOBAL_DB))
+            conn.row_factory = sqlite3.Row
+            cur = conn.cursor()
+            cur.execute(
+                "SELECT key, value FROM cursorDiskKV WHERE key LIKE 'composerData:%'"
+            )
+            rows = cur.fetchall()
+        except sqlite3.Error:
+            return []
+
+        composer_to_ws = self._composer_workspace_map()
+
+        sessions: list[Session] = []
+        for row in rows:
+            key = row["key"]
+            composer_id = key.split(":", 1)[1] if ":" in key else key
+            data = _load_json_blob(row["value"])
+            if not isinstance(data, dict):
+                continue
+
+            headers = data.get("fullConversationHeadersOnly") or []
+            created_at = _ms_to_dt(data.get("createdAt"))
+            updated_at = _ms_to_dt(data.get("lastUpdatedAt")) or created_at
+
+            title = data.get("name") or None
+            if not title:
+                title = self._first_bubble_text(cur, composer_id, headers)
+
+            if created_at is None and updated_at is None and not headers and not title:
+                # Nothing usable — likely an empty/never-started composer.
+                continue
+
+            now = datetime.now(timezone.utc)
+            sessions.append(
+                Session(
+                    id=composer_id,
+                    tool=self.tool_name,
+                    title=title[:200] if title else None,
+                    cwd=composer_to_ws.get(composer_id),
+                    created_at=created_at or now,
+                    updated_at=updated_at or created_at or now,
+                    raw_path=str(_GLOBAL_DB),
+                    status="unknown",
+                )
+            )
+
+        conn.close()
+        return sessions
+
+    def _first_bubble_text(
+        self, cur: sqlite3.Cursor, composer_id: str, headers: list
+    ) -> str | None:
+        """Best-effort title fallback: text of the first bubble in the conversation."""
+        first_id = None
+        for h in headers:
+            if isinstance(h, dict) and h.get("bubbleId"):
+                first_id = h["bubbleId"]
+                break
+        if first_id is None:
+            return None
+        try:
+            cur.execute(
+                "SELECT value FROM cursorDiskKV WHERE key = ?",
+                (f"bubbleId:{composer_id}:{first_id}",),
+            )
+            row = cur.fetchone()
+        except sqlite3.Error:
+            return None
+        bubble = _load_json_blob(row[0]) if row else None
+        if isinstance(bubble, dict):
+            text = bubble.get("text")
+            if isinstance(text, str) and text.strip():
+                return text.strip()
+        return None
+
+    def load_messages(self, session_id: str) -> list[Message]:
+        if not _GLOBAL_DB.exists():
+            return []
+
+        try:
+            conn = sqlite3.connect(str(_GLOBAL_DB))
+            cur = conn.cursor()
+            cur.execute(
+                "SELECT value FROM cursorDiskKV WHERE key = ?",
+                (f"composerData:{session_id}",),
+            )
+            row = cur.fetchone()
+            composer = _load_json_blob(row[0]) if row else None
+            headers = (
+                composer.get("fullConversationHeadersOnly")
+                if isinstance(composer, dict)
+                else None
+            )
+
+            if headers:
+                ordered_ids = [
+                    h.get("bubbleId")
+                    for h in headers
+                    if isinstance(h, dict) and h.get("bubbleId")
+                ]
+                keys = [f"bubbleId:{session_id}:{bid}" for bid in ordered_ids]
+                value_by_key: dict[str, object] = {}
+                if keys:
+                    placeholders = ",".join("?" for _ in keys)
+                    cur.execute(
+                        f"SELECT key, value FROM cursorDiskKV WHERE key IN ({placeholders})",
+                        keys,
+                    )
+                    value_by_key = dict(cur.fetchall())
+                ordered_bubbles = []
+                for key in keys:
+                    parsed = _load_json_blob(value_by_key.get(key))
+                    if isinstance(parsed, dict):
+                        ordered_bubbles.append(parsed)
+            else:
+                # No header index (older/partial data) — scan bubbles directly
+                # and fall back to sorting by creation time.
+                cur.execute(
+                    "SELECT value FROM cursorDiskKV WHERE key LIKE ?",
+                    (f"bubbleId:{session_id}:%",),
+                )
+                ordered_bubbles = sorted(
+                    (
+                        parsed
+                        for (v,) in cur.fetchall()
+                        if isinstance(parsed := _load_json_blob(v), dict)
+                    ),
+                    key=lambda b: b.get("createdAt") or 0,
+                )
+
+            conn.close()
+        except sqlite3.Error:
+            return []
+
+        messages: list[Message] = []
+        for bubble in ordered_bubbles:
+            text = bubble.get("text")
+            if not isinstance(text, str) or not text.strip():
+                continue
+            # type: 1 = user, 2 = assistant.
+            role = "user" if bubble.get("type") == 1 else "assistant"
+            messages.append(
+                Message(
+                    role=role,
+                    content=text,
+                    timestamp=_ms_to_dt(bubble.get("createdAt")),
+                    token_count=_count_tokens(text),
+                )
+            )
+
+        return messages
+
+    def build_inject_command(
+        self,
+        context: str,
+        target_session_id: str | None = None,
+        cwd: str | None = None,
+        method: str = "system_prompt",
+    ) -> str:
+        """Build a shell command to start/resume a Cursor CLI (``cursor-agent``) session.
+
+        ``cursor-agent -p <prompt>`` runs a one-shot non-interactive turn;
+        ``cursor-agent --resume <id> -p <prompt>`` continues an existing chat.
+        """
+        safe_ctx = shlex.quote(context)
+
+        if method == "resume" and target_session_id:
+            cmd = f"cursor-agent --resume {shlex.quote(target_session_id)} -p {safe_ctx}"
+        else:
+            cmd = f"cursor-agent -p {safe_ctx}"
+
+        if cwd:
+            cmd = f"cd {shlex.quote(cwd)} && {cmd}"
+        return cmd

{context_forge_cli-0.4.11 → context_forge_cli-0.4.12}/contextforge/adapters/registry.py

@@ -7,6 +7,7 @@ from contextforge.adapters.claude_code import ClaudeCodeAdapter
 from contextforge.adapters.claude_desktop import ClaudeDesktopAdapter
 from contextforge.adapters.codex import CodexAdapter
 from contextforge.adapters.antigravity import AntigravityAdapter
+from contextforge.adapters.cursor import CursorAdapter
 from contextforge.adapters.gemini import GeminiAdapter
 
 ADAPTERS: dict[str, type[ToolAdapter]] = {
@@ -16,6 +17,7 @@ ADAPTERS: dict[str, type[ToolAdapter]] = {
     "altimate_code": AltimateCodeAdapter,
     "gemini": GeminiAdapter,
     "antigravity": AntigravityAdapter,
+    "cursor": CursorAdapter,
 }
 
 

{context_forge_cli-0.4.11 → context_forge_cli-0.4.12}/contextforge/tui/widgets/session_detail.py

@@ -17,6 +17,7 @@ TOOL_COLORS = {
     "claude_desktop": "yellow",
     "gemini":         "blue",
     "antigravity":    "white",
+    "cursor":         "bright_white",
 }
 TOOL_LABELS = {
     "claude_code":    "◆ Claude Code",
@@ -25,6 +26,7 @@ TOOL_LABELS = {
     "claude_desktop": "◇ Claude Desktop",
     "gemini":         "✦ Gemini",
     "antigravity":    "◉ Antigravity",
+    "cursor":         "▲ Cursor",
 }
 
 

{context_forge_cli-0.4.11 → context_forge_cli-0.4.12}/contextforge/tui/widgets/session_table.py

@@ -20,6 +20,7 @@ TOOL_ICON = {
     "claude_desktop": "◇",   # Claude Desktop — open diamond
     "gemini":         "✦",   # Google Gemini — four-pointed star
     "antigravity":    "◉",   # Antigravity — circle
+    "cursor":         "▲",   # Cursor — triangle
 }
 
 TOOL_MARKUP = {
@@ -29,6 +30,7 @@ TOOL_MARKUP = {
     "claude_desktop": "[yellow]◇ Desktop[/yellow]",
     "gemini":         "[blue]✦ Gemini[/blue]",
     "antigravity":    "[white]◉ Agy[/white]",
+    "cursor":         "[bright_white]▲ Cursor[/bright_white]",
 }
 
 TOOL_DISPLAY = {
@@ -38,6 +40,7 @@ TOOL_DISPLAY = {
     "claude_desktop": "◇ Desktop",
     "gemini":         "✦ Gemini",
     "antigravity":    "◉ Agy",
+    "cursor":         "▲ Cursor",
 }
 
 _FTOOL_MAP = {
@@ -47,6 +50,7 @@ _FTOOL_MAP = {
     "ftool-gem":   "gemini",
     "ftool-alt":   "altimate_code",
     "ftool-agy":   "antigravity",
+    "ftool-cur":   "cursor",
 }
 
 
@@ -164,6 +168,7 @@ class SessionTable(Widget):
                 yield Button("✦ Gem",   id="ftool-gem",    classes="filter-tool-btn")
                 yield Button("⚡ Alt",   id="ftool-alt",    classes="filter-tool-btn")
                 yield Button("◉ Agy",   id="ftool-agy",    classes="filter-tool-btn")
+                yield Button("▲ Cursor", id="ftool-cur",    classes="filter-tool-btn")
             yield DataTable(cursor_type="row", zebra_stripes=True, id="sessions-datatable")
 
     def on_mount(self) -> None:

{context_forge_cli-0.4.11 → context_forge_cli-0.4.12}/contextforge/tui/widgets/stats_panel.py

@@ -22,6 +22,7 @@ TOOL_COLORS = {
     "claude_desktop": "yellow",
     "gemini":         "blue",
     "antigravity":    "white",
+    "cursor":         "bright_white",
 }
 TOOL_LABELS = {
     "claude_code":    "◆ Claude Code",
@@ -30,9 +31,10 @@ TOOL_LABELS = {
     "claude_desktop": "◇ Desktop",
     "gemini":         "✦ Gemini",
     "antigravity":    "◉ Antigravity",
+    "cursor":         "▲ Cursor",
 }
 
-_TOOL_ORDER = ["claude_code", "codex", "gemini", "altimate_code", "claude_desktop", "antigravity"]
+_TOOL_ORDER = ["claude_code", "codex", "gemini", "altimate_code", "claude_desktop", "antigravity", "cursor"]
 
 WINDOW_LABELS = {
     "7d":  "7 days",

{context_forge_cli-0.4.11 → context_forge_cli-0.4.12}/contextforge/tui/widgets/status_bar.py

@@ -70,6 +70,7 @@ class StatusBar(Widget):
             "claude_desktop": "◇ Desktop",
             "gemini":         "✦ Gemini",
             "antigravity":    "◉ Agy",
+            "cursor":         "▲ Cursor",
         }
         for tool, label in labels.items():
             n = counts.get(tool, 0)
@@ -96,7 +97,7 @@ class StatusBar(Widget):
         if text:
             parts.append(f'"{text}"')
         if tool:
-            short = {"claude_code": "◆ CC", "codex": "⬡ Codex", "altimate_code": "⚡ Alt", "claude_desktop": "◇ Desktop", "gemini": "✦ Gemini", "antigravity": "◉ Agy"}.get(tool, tool)
+            short = {"claude_code": "◆ CC", "codex": "⬡ Codex", "altimate_code": "⚡ Alt", "claude_desktop": "◇ Desktop", "gemini": "✦ Gemini", "antigravity": "◉ Agy", "cursor": "▲ Cursor"}.get(tool, tool)
             parts.append(short)
 
         self.query_one("#status-filter", Static).update(

{context_forge_cli-0.4.11 → context_forge_cli-0.4.12}/contextforge/tui/widgets/tokens_panel.py

@@ -25,6 +25,7 @@ _TOOL_LABELS = {
     "claude_desktop": "◇ Claude Desktop",
     "gemini":         "✦ Gemini",
     "antigravity":    "◉ Antigravity",
+    "cursor":         "▲ Cursor",
 }
 
 

{context_forge_cli-0.4.11 → context_forge_cli-0.4.12}/contextforge/tui/widgets/transfer_panel.py

@@ -13,6 +13,7 @@ TOOLS = [
     ("codex", "Codex"),
     ("altimate_code", "altimate-code"),
     ("antigravity", "Antigravity"),
+    ("cursor", "Cursor"),
 ]
 
 STRATEGIES = [

{context_forge_cli-0.4.11 → context_forge_cli-0.4.12}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "context-forge-cli"
-version = "0.4.11"
+version = "0.4.12"
 description = "Session manager and context bridge for agentic CLI tools"
 readme = "README.md"
 license = { text = "MIT" }

context_forge_cli-0.4.12/tests/adapters/test_cursor.py

@@ -0,0 +1,308 @@
+"""Tests for the Cursor adapter using synthetic SQLite fixtures."""
+from __future__ import annotations
+
+import json
+import sqlite3
+import tempfile
+from pathlib import Path
+
+import pytest
+
+from contextforge.adapters.cursor import CursorAdapter, _ms_to_dt, _uri_to_path, _count_tokens
+
+
+def _make_global_db(path: Path, rows: dict[str, dict]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    conn = sqlite3.connect(str(path))
+    conn.execute("CREATE TABLE cursorDiskKV (key TEXT UNIQUE, value BLOB)")
+    for key, value in rows.items():
+        conn.execute(
+            "INSERT INTO cursorDiskKV (key, value) VALUES (?, ?)",
+            (key, json.dumps(value)),
+        )
+    conn.commit()
+    conn.close()
+
+
+def test_ms_to_dt():
+    dt = _ms_to_dt(1700000000000)
+    assert dt is not None
+    assert dt.tzinfo is not None
+
+
+def test_ms_to_dt_none():
+    assert _ms_to_dt(None) is None
+    assert _ms_to_dt(0) is None
+
+
+def test_uri_to_path_file_uri():
+    assert _uri_to_path("file:///Users/alice/myproject") == "/Users/alice/myproject"
+
+
+def test_uri_to_path_passthrough():
+    assert _uri_to_path("/plain/path") == "/plain/path"
+
+
+def test_count_tokens():
+    n = _count_tokens("hello world")
+    assert isinstance(n, int) and n > 0
+
+
+def test_discover_sessions_with_headers():
+    adapter = CursorAdapter()
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        global_db = Path(tmpdir) / "User" / "globalStorage" / "state.vscdb"
+        composer_id = "comp-1"
+        _make_global_db(
+            global_db,
+            {
+                f"composerData:{composer_id}": {
+                    "composerId": composer_id,
+                    "name": "Fix the bug",
+                    "createdAt": 1700000000000,
+                    "lastUpdatedAt": 1700000100000,
+                    "fullConversationHeadersOnly": [
+                        {"bubbleId": "b1", "type": 1},
+                        {"bubbleId": "b2", "type": 2},
+                    ],
+                },
+                f"bubbleId:{composer_id}:b1": {"text": "hi", "type": 1, "createdAt": 1700000000000},
+                f"bubbleId:{composer_id}:b2": {"text": "hello", "type": 2, "createdAt": 1700000050000},
+            },
+        )
+
+        import contextforge.adapters.cursor as mod
+
+        original_global = mod._GLOBAL_DB
+        original_ws = mod._WORKSPACE_STORAGE_DIR
+        mod._GLOBAL_DB = global_db
+        mod._WORKSPACE_STORAGE_DIR = Path(tmpdir) / "User" / "workspaceStorage"
+        try:
+            sessions = adapter.discover_sessions()
+        finally:
+            mod._GLOBAL_DB = original_global
+            mod._WORKSPACE_STORAGE_DIR = original_ws
+
+    assert len(sessions) == 1
+    session = sessions[0]
+    assert session.id == composer_id
+    assert session.title == "Fix the bug"
+    assert session.tool == "cursor"
+    assert session.created_at == _ms_to_dt(1700000000000)
+    assert session.updated_at == _ms_to_dt(1700000100000)
+
+
+def test_discover_sessions_title_fallback_to_first_bubble():
+    adapter = CursorAdapter()
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        global_db = Path(tmpdir) / "User" / "globalStorage" / "state.vscdb"
+        composer_id = "comp-2"
+        _make_global_db(
+            global_db,
+            {
+                f"composerData:{composer_id}": {
+                    "composerId": composer_id,
+                    "createdAt": 1700000000000,
+                    "fullConversationHeadersOnly": [
+                        {"bubbleId": "b1", "type": 1},
+                    ],
+                },
+                f"bubbleId:{composer_id}:b1": {
+                    "text": "Please refactor this function",
+                    "type": 1,
+                    "createdAt": 1700000000000,
+                },
+            },
+        )
+
+        import contextforge.adapters.cursor as mod
+
+        original_global = mod._GLOBAL_DB
+        original_ws = mod._WORKSPACE_STORAGE_DIR
+        mod._GLOBAL_DB = global_db
+        mod._WORKSPACE_STORAGE_DIR = Path(tmpdir) / "User" / "workspaceStorage"
+        try:
+            sessions = adapter.discover_sessions()
+        finally:
+            mod._GLOBAL_DB = original_global
+            mod._WORKSPACE_STORAGE_DIR = original_ws
+
+    assert len(sessions) == 1
+    assert sessions[0].title == "Please refactor this function"
+
+
+def test_discover_sessions_resolves_cwd_from_workspace():
+    adapter = CursorAdapter()
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        user_dir = Path(tmpdir) / "User"
+        global_db = user_dir / "globalStorage" / "state.vscdb"
+        composer_id = "comp-3"
+        _make_global_db(
+            global_db,
+            {
+                f"composerData:{composer_id}": {
+                    "composerId": composer_id,
+                    "name": "Session with cwd",
+                    "createdAt": 1700000000000,
+                    "fullConversationHeadersOnly": [],
+                },
+            },
+        )
+
+        ws_dir = user_dir / "workspaceStorage" / "abc123"
+        ws_dir.mkdir(parents=True)
+        (ws_dir / "workspace.json").write_text(
+            json.dumps({"folder": "file:///home/alice/project"})
+        )
+        ws_state_db = ws_dir / "state.vscdb"
+        conn = sqlite3.connect(str(ws_state_db))
+        conn.execute("CREATE TABLE ItemTable (key TEXT UNIQUE, value BLOB)")
+        conn.execute(
+            "INSERT INTO ItemTable (key, value) VALUES (?, ?)",
+            (
+                "composer.composerData",
+                json.dumps({"allComposers": [{"composerId": composer_id}]}),
+            ),
+        )
+        conn.commit()
+        conn.close()
+
+        import contextforge.adapters.cursor as mod
+
+        original_global = mod._GLOBAL_DB
+        original_ws = mod._WORKSPACE_STORAGE_DIR
+        mod._GLOBAL_DB = global_db
+        mod._WORKSPACE_STORAGE_DIR = user_dir / "workspaceStorage"
+        try:
+            sessions = adapter.discover_sessions()
+        finally:
+            mod._GLOBAL_DB = original_global
+            mod._WORKSPACE_STORAGE_DIR = original_ws
+
+    assert len(sessions) == 1
+    assert sessions[0].cwd == "/home/alice/project"
+
+
+def test_load_messages_with_headers():
+    adapter = CursorAdapter()
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        global_db = Path(tmpdir) / "User" / "globalStorage" / "state.vscdb"
+        composer_id = "comp-4"
+        _make_global_db(
+            global_db,
+            {
+                f"composerData:{composer_id}": {
+                    "composerId": composer_id,
+                    "fullConversationHeadersOnly": [
+                        {"bubbleId": "b1", "type": 1},
+                        {"bubbleId": "b2", "type": 2},
+                    ],
+                },
+                f"bubbleId:{composer_id}:b1": {
+                    "text": "What does this do?",
+                    "type": 1,
+                    "createdAt": 1700000000000,
+                },
+                f"bubbleId:{composer_id}:b2": {
+                    "text": "It does X.",
+                    "type": 2,
+                    "createdAt": 1700000010000,
+                },
+            },
+        )
+
+        import contextforge.adapters.cursor as mod
+
+        original_global = mod._GLOBAL_DB
+        mod._GLOBAL_DB = global_db
+        try:
+            messages = adapter.load_messages(composer_id)
+        finally:
+            mod._GLOBAL_DB = original_global
+
+    assert len(messages) == 2
+    assert messages[0].role == "user"
+    assert messages[0].content == "What does this do?"
+    assert messages[1].role == "assistant"
+    assert messages[1].content == "It does X."
+
+
+def test_load_messages_without_headers_sorts_by_created_at():
+    adapter = CursorAdapter()
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        global_db = Path(tmpdir) / "User" / "globalStorage" / "state.vscdb"
+        composer_id = "comp-5"
+        _make_global_db(
+            global_db,
+            {
+                f"composerData:{composer_id}": {"composerId": composer_id},
+                f"bubbleId:{composer_id}:b2": {
+                    "text": "second",
+                    "type": 2,
+                    "createdAt": 1700000020000,
+                },
+                f"bubbleId:{composer_id}:b1": {
+                    "text": "first",
+                    "type": 1,
+                    "createdAt": 1700000010000,
+                },
+            },
+        )
+
+        import contextforge.adapters.cursor as mod
+
+        original_global = mod._GLOBAL_DB
+        mod._GLOBAL_DB = global_db
+        try:
+            messages = adapter.load_messages(composer_id)
+        finally:
+            mod._GLOBAL_DB = original_global
+
+    assert [m.content for m in messages] == ["first", "second"]
+
+
+def test_load_messages_missing_session_returns_empty():
+    adapter = CursorAdapter()
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        global_db = Path(tmpdir) / "User" / "globalStorage" / "state.vscdb"
+        _make_global_db(global_db, {})
+
+        import contextforge.adapters.cursor as mod
+
+        original_global = mod._GLOBAL_DB
+        mod._GLOBAL_DB = global_db
+        try:
+            messages = adapter.load_messages("does-not-exist")
+        finally:
+            mod._GLOBAL_DB = original_global
+
+    assert messages == []
+
+
+def test_build_inject_command_new_session():
+    adapter = CursorAdapter()
+    cmd = adapter.build_inject_command("some context", method="system_prompt")
+    assert "cursor-agent" in cmd
+    assert "-p" in cmd
+    assert "some context" in cmd
+
+
+def test_build_inject_command_resume():
+    adapter = CursorAdapter()
+    cmd = adapter.build_inject_command("ctx", target_session_id="abc-123", method="resume")
+    assert "cursor-agent" in cmd
+    assert "--resume" in cmd
+    assert "abc-123" in cmd
+
+
+def test_build_inject_command_with_cwd():
+    adapter = CursorAdapter()
+    cmd = adapter.build_inject_command("ctx", cwd="/tmp/proj")
+    assert cmd.startswith("cd /tmp/proj")
+    assert "cursor-agent" in cmd

{context_forge_cli-0.4.11 → context_forge_cli-0.4.12}/uv.lock

@@ -206,7 +206,7 @@ wheels = [
 
 [[package]]
 name = "context-forge-cli"
-version = "0.4.10"
+version = "0.4.12"
 source = { editable = "." }
 dependencies = [
     { name = "anthropic" },