sessionwiki 2.0.0__py3-none-any.whl

sessionwiki/adapters/claude_code.py

@@ -0,0 +1,77 @@
+"""Claude Code session-store adapter.
+
+Claude Code writes one .jsonl per session under:
+    ~/.claude/projects/<project-dir-slug>/<session-uuid>.jsonl
+
+Sub-agent runs live in:
+    ~/.claude/projects/<project-dir-slug>/<session-uuid>/subagents/agent-*.jsonl
+
+Project directory names encode the full absolute path with slashes replaced by
+dashes, e.g. '-Users-USER-Desktop-2026-production-draft-ai-newsletter'.
+We strip the common prefix to produce a friendly slug.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from sessionwiki.adapters import register
+from sessionwiki.adapters.base import BaseAdapter
+
+
+@register("claude_code")
+class ClaudeCodeAdapter(BaseAdapter):
+    """Claude Code — reads ~/.claude/projects/*/*.jsonl"""
+
+    # Cross-platform: dot-dir works on macOS, Linux, and Windows
+    session_store_path = Path.home() / ".claude" / "projects"
+
+    def derive_project_slug(self, jsonl_path: Path) -> str:
+        """Strip the '-Users-...-production-draft-' prefix from the project dir name."""
+        store = Path(self.session_store_path).expanduser()
+        try:
+            rel = jsonl_path.relative_to(store)
+        except ValueError:
+            return jsonl_path.parent.name
+        if not rel.parts:
+            return jsonl_path.parent.name
+        project_dir = rel.parts[0]
+        parts = project_dir.lstrip("-").split("-")
+        # Find a recognizable split point — anything after 'draft', 'production', or 'Desktop'
+        for marker in ("draft", "production", "Desktop"):
+            if marker in parts:
+                idx = len(parts) - 1 - parts[::-1].index(marker)
+                tail = parts[idx + 1 :]
+                if tail:
+                    return "-".join(tail)
+        return "-".join(parts[-2:]) if len(parts) >= 2 else project_dir
+
+    def is_subagent(self, jsonl_path: Path) -> bool:
+        """Detect Claude Code sub-agent runs by canonical path layout (#406).
+
+        Claude Code stores sub-agent runs at:
+            ~/.claude/projects/<project>/<session-uuid>/subagents/agent-*.jsonl
+
+        Old heuristic was a substring check on ``"subagent" in path.parts``,
+        which mis-tagged any user project named e.g. ``subagent-runner`` —
+        every session in such a project was demoted to sub-agent on the
+        project page and excluded from session counts.
+
+        New rule: the file MUST live in a directory literally named
+        ``subagents`` (plural) AND have a filename starting with
+        ``agent-``. Both conditions match the canonical Claude layout
+        and exclude every false-positive case (project name "subagent",
+        "subagent-runner", "agent-subagent-helper", etc.).
+        """
+        parts = jsonl_path.parts
+        if "subagents" not in parts:
+            return False
+        # The 'subagents' segment must be the immediate parent directory.
+        try:
+            parent_idx = parts.index("subagents")
+        except ValueError:
+            return False
+        if parent_idx >= len(parts) - 1:
+            return False
+        # And the filename must start with 'agent-' (the canonical pattern).
+        return parts[-1].startswith("agent-")

sessionwiki/adapters/codex_cli.py

@@ -0,0 +1,226 @@
+"""Codex CLI adapter (production — v0.5 fix #109).
+
+Reads session transcripts from OpenAI's Codex CLI and normalizes the
+Codex-native JSONL schema into the shared Claude-style format. v0.3 brings this adapter
+from stub → production: it discovers session files, derives project slugs,
+and declares its schema version. Record parsing goes through the shared
+converter in sessionwiki.convert with graceful degradation for unknown record
+types.
+
+Codex CLI stores sessions under:
+- ~/.codex/sessions/
+- ~/.codex/projects/ (alternate layout)
+
+Both are checked. Users can override via config.json.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from sessionwiki.adapters import register
+from sessionwiki.adapters.base import BaseAdapter
+
+
+@register("codex_cli")
+class CodexCliAdapter(BaseAdapter):
+    """Codex CLI — reads ~/.codex/sessions/**/*.jsonl (v0.3 production)"""
+
+    SUPPORTED_SCHEMA_VERSIONS = ["v0.x", "v1.0"]
+
+    DEFAULT_ROOTS = [
+        # Cross-platform: dot-dir works on macOS, Linux, and Windows
+        Path.home() / ".codex" / "sessions",
+        Path.home() / ".codex" / "projects",
+    ]
+
+    def __init__(self, config: dict[str, Any] | None = None):
+        super().__init__(config)
+        ad_cfg = (config or {}).get("adapters", {}).get("codex_cli", {})
+        paths = ad_cfg.get("roots") or []
+        self.roots: list[Path] = (
+            [Path(p).expanduser() for p in paths] if paths else self.DEFAULT_ROOTS
+        )
+
+    @property
+    def session_store_path(self):  # type: ignore[override]
+        return self.roots
+
+    # #496: is_available() inherited from BaseAdapter — it now creates
+    # a temp instance and reads self.session_store_path through the
+    # @property below. Was a duplicate scan over DEFAULT_ROOTS; same
+    # result, less code.
+
+    def discover_sessions(self) -> list[Path]:
+        out: list[Path] = []
+        for root in self.roots:
+            root = Path(root).expanduser()
+            if root.exists():
+                out.extend(sorted(root.rglob("*.jsonl")))
+        # Dedupe
+        seen: set[Path] = set()
+        unique: list[Path] = []
+        for p in out:
+            if p not in seen:
+                seen.add(p)
+                unique.append(p)
+        return unique
+
+    def derive_project_slug(self, path: Path) -> str:
+        """Derive the project slug from the Codex session's recorded cwd.
+
+        Codex CLI 0.118.0 stores sessions under date-bucketed directories
+        (~/.codex/sessions/YYYY/MM/DD/rollout-*.jsonl), so the directory
+        path itself is NOT the project identifier. Instead we read the
+        session_meta record's `cwd` field and use its basename.
+
+        Fallback: if the session has no cwd, use the directory name
+        (which will be the DD date bucket — not great, but better than
+        crashing).
+        """
+        import json
+
+        # Try to read cwd from the session_meta record
+        try:
+            with open(path, encoding="utf-8", errors="replace") as f:
+                for line in f:
+                    try:
+                        r = json.loads(line.strip())
+                    except ValueError:
+                        continue
+                    if r.get("type") == "session_meta":
+                        cwd = r.get("payload", {}).get("cwd", "")
+                        if cwd:
+                            # Use the basename of the working directory
+                            return Path(cwd).name.lower().replace(" ", "-")
+                    break  # session_meta is always the first record
+        except OSError:
+            pass
+
+        # Fallback: use the parent directory name
+        return path.parent.name
+
+
+    def normalize_records(self, records: list[dict[str, Any]]) -> list[dict[str, Any]]:
+        """Normalize Codex CLI records into the shared Claude-style format.
+
+        Maps:
+        - session_meta → sessionId, cwd, model metadata extraction
+        - response_item(role=user, type=message) → user record
+        - response_item(role=assistant, type=message) → assistant record
+        - response_item(type=web_search_call) → tool_use record
+        - event_msg(type=task_started) → turn boundary (triggers slug)
+        - Everything else → skipped gracefully
+        """
+        out: list[dict[str, Any]] = []
+
+        # Extract session metadata first
+        session_id = ""
+        cwd = ""
+        model = ""
+        for r in records:
+            if r.get("type") == "session_meta":
+                p = r.get("payload", {})
+                session_id = p.get("id", "")
+                cwd = p.get("cwd", "")
+
+        for r in records:
+            rtype = r.get("type", "")
+            payload = r.get("payload", {})
+            ts = r.get("timestamp", "")
+
+            if rtype == "session_meta":
+                # Emit a synthetic init record with metadata
+                out.append({
+                    "type": "init",
+                    "sessionId": session_id,
+                    "cwd": cwd,
+                    "timestamp": ts,
+                })
+                continue
+
+            if rtype == "turn_context":
+                model = payload.get("model", model)
+                continue
+
+            if rtype == "response_item":
+                role = payload.get("role", "")
+                item_type = payload.get("type", "")
+                content_blocks = payload.get("content", [])
+
+                if role == "user" and item_type == "message":
+                    # Extract text from content blocks
+                    text_parts = []
+                    for block in (content_blocks if isinstance(content_blocks, list) else []):
+                        if isinstance(block, dict) and block.get("type") == "input_text":
+                            text_parts.append(block.get("text", ""))
+                        elif isinstance(block, str):
+                            text_parts.append(block)
+                    text = "\n".join(text_parts).strip()
+                    if text:
+                        out.append({
+                            "type": "user",
+                            "message": {"role": "user", "content": text},
+                            "timestamp": ts,
+                        })
+                    continue
+
+                if role == "assistant" and item_type == "message":
+                    text_parts = []
+                    for block in (content_blocks if isinstance(content_blocks, list) else []):
+                        if isinstance(block, dict) and block.get("type") == "output_text":
+                            text_parts.append({"type": "text", "text": block.get("text", "")})
+                        elif isinstance(block, str):
+                            text_parts.append({"type": "text", "text": block})
+                    if text_parts:
+                        out.append({
+                            "type": "assistant",
+                            "message": {
+                                "role": "assistant",
+                                "content": text_parts,
+                                "model": model,
+                            },
+                            "timestamp": ts,
+                        })
+                    continue
+
+                if role == "developer":
+                    # System/developer prompt — skip (context, not conversation)
+                    continue
+
+                if item_type == "web_search_call":
+                    out.append({
+                        "type": "assistant",
+                        "message": {
+                            "role": "assistant",
+                            "content": [{
+                                "type": "tool_use",
+                                "name": "WebSearch",
+                                "input": {"query": payload.get("query", "")},
+                            }],
+                        },
+                        "timestamp": ts,
+                    })
+                    continue
+
+                if item_type == "reasoning":
+                    # Thinking block — skip by default (matches Claude config)
+                    continue
+
+            if rtype == "event_msg":
+                # Turn lifecycle events — mostly metadata, not conversation
+                continue
+
+            # Unknown record type — skip gracefully (never crash)
+
+        return out
+
+    def is_subagent(self, path: Path) -> bool:
+        """Codex CLI has no sub-agent concept (#406). Returns False
+        unconditionally. The previous substring heuristic produced
+        false positives on any project named e.g. ``subagent-runner``
+        or any path containing ``agent-`` (which is also a common
+        prefix in user code).
+        """
+        return False

sessionwiki/adapters/contrib/__init__.py

@@ -0,0 +1 @@
+"""Contrib adapters — loaded on demand via ``discover_contrib()``."""

sessionwiki/adapters/contrib/chatgpt.py

@@ -0,0 +1,252 @@
+"""ChatGPT conversation-export adapter (v1.1 · #44).
+
+ChatGPT doesn't write session files to disk like Claude Code or Codex.
+Users must **export** their chat history from
+https://chat.openai.com/settings → Data Controls → Export, then extract
+the zip into a directory. This adapter reads `conversations.json` from
+that export.
+
+The export format is a JSON array of conversation objects::
+
+    [
+      {
+        "title": "Debugging my FastAPI route",
+        "create_time": 1730246400.0,
+        "update_time": 1730250000.0,
+        "mapping": {
+          "<uuid>": {
+            "id": "<uuid>",
+            "message": {
+              "author": {"role": "user"|"assistant"|"system"|"tool"},
+              "content": {"parts": ["..."]} | {"content_type": "code", ...},
+              "create_time": 1730246402.0
+            },
+            "parent": "<uuid>",
+            "children": ["<uuid>"]
+          }
+        },
+        "current_node": "<uuid>"
+      },
+      ...
+    ]
+
+Configuration (in ``sessions_config.json``)::
+
+    "chatgpt": {
+      "enabled": false,
+      "export_dirs": ["~/Downloads/chatgpt-export"],
+      "min_messages": 2
+    }
+
+Opt-in: disabled by default. Add ``"enabled": true`` and point
+``export_dirs`` at the folder where you extracted the export zip.
+"""
+
+from __future__ import annotations
+
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Iterator
+
+from sessionwiki.adapters import register
+from sessionwiki.adapters.base import BaseAdapter
+
+
+@register("chatgpt")
+class ChatGPTAdapter(BaseAdapter):
+    """ChatGPT — parses conversations.json from a user's export."""
+
+    SUPPORTED_SCHEMA_VERSIONS = ["v1"]
+
+    DEFAULT_EXPORT_DIRS = [
+        Path.home() / "Downloads" / "chatgpt-export",
+    ]
+
+    def __init__(self, config: dict[str, Any] | None = None):
+        super().__init__(config)
+        ad_cfg = (config or {}).get("chatgpt", {})
+        self._enabled = ad_cfg.get("enabled", False)
+        self._min_messages = int(ad_cfg.get("min_messages", 2))
+        dirs = ad_cfg.get("export_dirs", [])
+        if dirs:
+            self._export_dirs = [Path(d).expanduser() for d in dirs]
+        else:
+            self._export_dirs = self.DEFAULT_EXPORT_DIRS
+
+    @property
+    def session_store_path(self):  # type: ignore[override]
+        return self._export_dirs
+
+    @classmethod
+    def is_available(cls) -> bool:
+        # Disabled by default — user must opt in via config
+        return False
+
+    def is_available_with_config(self) -> bool:
+        if not self._enabled:
+            return False
+        return any(
+            (d / "conversations.json").is_file() for d in self._export_dirs
+        )
+
+    def discover_sessions(self) -> list[Path]:
+        """Each conversations.json file is one 'session-store'."""
+        out: list[Path] = []
+        for d in self._export_dirs:
+            path = d / "conversations.json"
+            if path.is_file():
+                out.append(path)
+        return out
+
+
+# ─── Parsing ───────────────────────────────────────────────────────────
+
+
+def _role(msg: dict[str, Any]) -> str:
+    """Extract role from the message dict."""
+    try:
+        return msg["author"]["role"]
+    except (KeyError, TypeError):
+        return "unknown"
+
+
+def _content_parts(msg: dict[str, Any]) -> list[str]:
+    """Extract text parts from a message. ChatGPT exports can be nested."""
+    content = msg.get("content", {})
+    if not isinstance(content, dict):
+        return []
+    parts = content.get("parts", [])
+    if not isinstance(parts, list):
+        return []
+    # Each part can be a string OR a dict with "text" or "image_url"
+    out: list[str] = []
+    for part in parts:
+        if isinstance(part, str):
+            out.append(part)
+        elif isinstance(part, dict) and "text" in part:
+            out.append(str(part["text"]))
+    return out
+
+
+def _linearize(conversation: dict[str, Any]) -> Iterator[dict[str, Any]]:
+    """Follow the parent→children chain from `current_node` back to root,
+    then yield messages in forward order."""
+    mapping = conversation.get("mapping", {})
+    current = conversation.get("current_node")
+    if not current or not mapping:
+        return
+
+    # Walk up from current_node to collect the linear path
+    chain: list[str] = []
+    while current:
+        chain.append(current)
+        node = mapping.get(current, {})
+        current = node.get("parent")
+    chain.reverse()  # root → leaf
+
+    for node_id in chain:
+        node = mapping.get(node_id, {})
+        msg = node.get("message")
+        if not msg:
+            continue
+        yield msg
+
+
+def parse_conversations_json(path: Path) -> list[dict[str, Any]]:
+    """Read a conversations.json export and return a list of session dicts.
+
+    Each session dict has: ``title``, ``created``, ``updated``, ``messages``
+    (list of ``{role, text, created}``).
+    """
+    try:
+        raw = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return []
+
+    if not isinstance(raw, list):
+        return []
+
+    sessions: list[dict[str, Any]] = []
+    for conv in raw:
+        if not isinstance(conv, dict):
+            continue
+
+        title = str(conv.get("title", "Untitled ChatGPT conversation"))
+        created = conv.get("create_time")
+        updated = conv.get("update_time")
+
+        messages: list[dict[str, Any]] = []
+        for msg in _linearize(conv):
+            role = _role(msg)
+            parts = _content_parts(msg)
+            if not parts:
+                continue
+            msg_created = msg.get("create_time")
+            messages.append({
+                "role": role,
+                "text": "\n".join(parts),
+                "created": msg_created,
+            })
+
+        sessions.append({
+            "title": title,
+            "created": created,
+            "updated": updated,
+            "messages": messages,
+        })
+
+    return sessions
+
+
+# ─── Markdown rendering ───────────────────────────────────────────────
+
+
+def _fmt_ts(ts: Any) -> str:
+    """Format a Unix timestamp as ISO date string; "" if unavailable."""
+    if ts is None:
+        return ""
+    try:
+        return datetime.fromtimestamp(float(ts), tz=timezone.utc).strftime("%Y-%m-%d")
+    except (ValueError, TypeError, OSError):
+        return ""
+
+
+def render_conversation_markdown(session: dict[str, Any]) -> str:
+    """Render a single ChatGPT conversation as frontmatter-tagged markdown."""
+    title = session["title"]
+    date_str = _fmt_ts(session.get("created")) or _fmt_ts(session.get("updated"))
+    msg_count = len(session["messages"])
+
+    # Collect unique roles
+    roles = sorted({m["role"] for m in session["messages"] if m["role"] != "unknown"})
+
+    fm = [
+        "---",
+        f'title: "{title}"',
+        "type: source",
+        "tags: [chatgpt, session-transcript]",
+        f"date: {date_str}",
+        "project: chatgpt",
+        f"source: chatgpt-export",
+        f"message_count: {msg_count}",
+        f"roles: [{', '.join(roles)}]",
+        "---",
+        "",
+        f"# {title}",
+        "",
+        f"**Messages:** {msg_count} · **Date:** {date_str or 'unknown'}",
+        "",
+        "## Conversation",
+        "",
+    ]
+
+    for m in session["messages"]:
+        role = m["role"].capitalize()
+        fm.append(f"### {role}")
+        fm.append("")
+        # Indent text blocks for readability
+        fm.append(m["text"])
+        fm.append("")
+
+    return "\n".join(fm)

sessionwiki/adapters/contrib/copilot_chat.py

@@ -0,0 +1,121 @@
+"""VS Code Copilot Chat adapter.
+
+Reads conversation history from the GitHub Copilot Chat extension's local
+storage in VS Code, VS Code Insiders, and VSCodium.
+
+Copilot Chat stores per-workspace conversation files under:
+    <editor-data>/User/workspaceStorage/<hash>/chatSessions/*.jsonl
+    <editor-data>/User/workspaceStorage/<hash>/chatSessions/*.json
+
+where <editor-data> is platform- and editor-variant-specific:
+    macOS:   ~/Library/Application Support/<editor>/
+    Linux:   ~/.config/<editor>/
+    Windows: %APPDATA%/<editor>/
+
+Supported editor variants: Code, Code - Insiders, VSCodium.
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Any
+
+from sessionwiki.adapters import register
+from sessionwiki.adapters.base import BaseAdapter
+
+# Editor directory names for each VS Code variant.
+_EDITOR_DIRS = ["Code", "Code - Insiders", "VSCodium"]
+
+
+def _build_default_roots() -> list[Path]:
+    """Build the full cross-platform DEFAULT_ROOTS list at import time."""
+    home = Path.home()
+    roots: list[Path] = []
+    for editor in _EDITOR_DIRS:
+        # macOS
+        roots.append(home / "Library" / "Application Support" / editor / "User" / "workspaceStorage")
+        # Linux
+        roots.append(home / ".config" / editor / "User" / "workspaceStorage")
+        # Windows
+        roots.append(home / "AppData" / "Roaming" / editor / "User" / "workspaceStorage")
+    return roots
+
+
+@register("copilot_chat", aliases=["copilot-chat"])
+class CopilotChatAdapter(BaseAdapter):
+    """GitHub Copilot Chat — reads VS Code workspaceStorage chatSessions.
+
+    #arch-l5 (#626): canonical name is ``copilot_chat`` (snake_case,
+    matching every other adapter). The kebab-case ``copilot-chat`` is
+    kept as a REGISTRY alias and still recognised in
+    ``sessions_config.json`` so existing user configs don't break.
+    """
+
+    # #arch-m9 (#621): SUPPORTED_SCHEMA_VERSIONS = ["v1"] is the
+    # BaseAdapter default — declaration removed here.
+
+    DEFAULT_ROOTS: list[Path] = _build_default_roots()
+
+    # File patterns inside chatSessions/ subdirectories.
+    SESSION_FILE_PATTERNS = ["*.jsonl", "*.json"]
+
+    def __init__(self, config: dict[str, Any] | None = None):
+        super().__init__(config)
+        adapters_cfg = (config or {}).get("adapters", {}) or {}
+        # #626: read snake_case config first; fall back to legacy
+        # kebab-case so existing sessions_config.json keeps working.
+        ad_cfg = adapters_cfg.get("copilot_chat") or adapters_cfg.get("copilot-chat") or {}
+        paths = ad_cfg.get("roots") or []
+        self.roots: list[Path] = (
+            [Path(p).expanduser() for p in paths] if paths else self.DEFAULT_ROOTS
+        )
+
+    @property
+    def session_store_path(self):  # type: ignore[override]
+        return self.roots
+
+    # #496: is_available() inherited from BaseAdapter — temp
+    # instance reads self.session_store_path through the @property.
+
+    def discover_sessions(self) -> list[Path]:
+        """Find chatSessions/*.jsonl and *.json under each workspace hash dir."""
+        out: list[Path] = []
+        for root in self.roots:
+            root = Path(root).expanduser()
+            if not root.exists():
+                continue
+            # Walk <root>/<hash>/chatSessions/<file>
+            for pattern in self.SESSION_FILE_PATTERNS:
+                glob_pattern = os.path.join("*", "chatSessions", pattern)
+                out.extend(sorted(root.glob(glob_pattern)))
+        # De-dupe while preserving order
+        seen: set[Path] = set()
+        unique: list[Path] = []
+        for p in out:
+            if p not in seen:
+                seen.add(p)
+                unique.append(p)
+        return unique
+
+    def derive_project_slug(self, path: Path) -> str:
+        """Derive a slug from the workspace hash directory.
+
+        The chatSessions/ files live at:
+            <root>/<workspace-hash>/chatSessions/<file>
+        We use the workspace hash (parent of chatSessions/) as the slug,
+        truncated to 12 chars and prefixed with 'copilot-'.
+        """
+        # Try to find the workspace hash dir — should be the parent of chatSessions/
+        for root in self.roots:
+            root = Path(root).expanduser()
+            try:
+                rel = path.relative_to(root)
+                if rel.parts:
+                    return f"copilot-{rel.parts[0][:12]}"
+            except ValueError:
+                continue
+        # Fallback: walk up from the file to find the chatSessions parent
+        if path.parent.name == "chatSessions":
+            return f"copilot-{path.parent.parent.name[:12]}"
+        return f"copilot-{path.parent.name[:12]}"