opencode-chat-exporter 1.0.0__py3-none-any.whl

chat_exporter/__init__.py

@@ -0,0 +1,2 @@
+"""chat_exporter - export full OpenCode / AntiGravity conversations from local data."""
+__version__ = "1.1.0"

chat_exporter/__main__.py

@@ -0,0 +1,16 @@
+"""Entry point: `python -m chat_exporter` launches the GUI, `--cli` runs the console tool."""
+import sys
+
+from .cli import main as cli_main
+
+
+def main():
+    if len(sys.argv) > 1 and sys.argv[1] in ("--cli", "export", "list", "export-all", "watch"):
+        sys.argv = sys.argv[:1] + [a for a in sys.argv[1:] if a != "--cli"]
+        sys.exit(cli_main())
+    from .gui import main as gui_main
+    gui_main()
+
+
+if __name__ == "__main__":
+    main()

chat_exporter/antigravity.py

@@ -0,0 +1,599 @@
+"""AntiGravity conversation reader.
+
+Conversation data for Google's AntiGravity (the Gemini coding agent) lives under
+`%USERPROFILE%\\.gemini\\antigravity`:
+
+- `conversations\\<cascade-uuid>.db`            SQLite database with protobuf-encoded steps
+- `brain\\<cascade-uuid>\\.system_generated\\logs\\transcript.jsonl`  readable JSON-Lines transcript
+
+The transcript file is the primary source (plain JSON, one event per line). When it is
+missing, this module falls back to decoding the protobuf blobs inside the SQLite database
+(steps / task_details / render_info / metadata / step_payload columns).
+"""
+import json
+import os
+import re
+import sqlite3
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+DEFAULT_AG_DIR = Path(os.path.expandvars(r"%USERPROFILE%\.gemini\antigravity"))
+
+# transcript.jsonl entry kinds that represent tool execution results
+TOOL_KIND_NAMES = {
+    "LIST_DIRECTORY": "list_dir",
+    "VIEW_FILE": "view_file",
+    "RUN_COMMAND": "run_command",
+    "CODE_ACTION": "code",
+    "SEARCH_WEB": "search_web",
+    "GENERIC": "tool",
+}
+SKIP_KINDS = {"CONVERSATION_HISTORY"}
+
+
+# ---------------------------------------------------------------- small helpers
+def _parse_iso(value: str) -> int | None:
+    """ISO timestamp string -> epoch milliseconds."""
+    try:
+        s = value.replace("Z", "+00:00")
+        t = datetime.fromisoformat(s)
+        if t.tzinfo is None:
+            t = t.replace(tzinfo=timezone.utc)
+        return int(t.timestamp() * 1000)
+    except Exception:
+        return None
+
+
+def _strip_meta_lines(text: str) -> str:
+    """Drop the leading 'Created At: ... / Completed At: ...' header."""
+    lines = text.splitlines()
+    while lines and (lines[0].startswith("Created At:") or lines[0].startswith("Completed At:")):
+        lines.pop(0)
+    return "\n".join(lines).strip()
+
+
+def _clean_tool_content(kind: str, content: str | None, exit_code: Any) -> tuple[str | None, dict]:
+    """Normalize a tool result into (output_text, metadata)."""
+    if not content:
+        return None, {}
+    text = _strip_meta_lines(content)
+    metadata: dict = {}
+    if kind == "RUN_COMMAND":
+        if exit_code is not None:
+            metadata["exit"] = exit_code
+        m = re.search(r"The command exited with code (\d+)\.\s*\n*\s*Output:\s*\n*", text,
+                      re.IGNORECASE)
+        if m:
+            text = text[m.end():].strip()
+    return (text or None), metadata
+
+
+def _unquote(value: Any) -> Any:
+    """AntiGravity sometimes stores JSON argument values as extra-quoted strings."""
+    if isinstance(value, str) and value.startswith('"') and value.endswith('"'):
+        try:
+            return json.loads(value)
+        except Exception:
+            return value
+    if isinstance(value, list):
+        return [_unquote(v) for v in value]
+    if isinstance(value, dict):
+        return {k: _unquote(v) for k, v in value.items()}
+    return value
+
+
+# ---------------------------------------------------------------- transcript.jsonl
+def load_transcript(path: Path) -> list[dict]:
+    """Read a transcript.jsonl file into a list of event dicts."""
+    out: list[dict] = []
+    with open(path, encoding="utf-8", errors="replace") as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                out.append(json.loads(line))
+            except Exception:
+                continue
+    return out
+
+
+# ------------------------------------------------------------ SQLite fallback dir
+def _iter_fields(buf: bytes):
+    """Minimal protobuf wire-format reader: yields (field, wire_type, value).
+
+    value is an int for varints and bytes for length-delimited fields.
+    """
+    i, n = 0, len(buf)
+    while i < n:
+        tag = 0
+        shift = 0
+        while i < n:
+            b = buf[i]
+            i += 1
+            tag |= (b & 0x7F) << shift
+            if not (b & 0x80):
+                break
+            shift += 7
+        field = tag >> 3
+        wt = tag & 7
+        if wt == 0:
+            val = 0
+            shift = 0
+            while i < n:
+                b = buf[i]
+                i += 1
+                val |= (b & 0x7F) << shift
+                if not (b & 0x80):
+                    break
+                shift += 7
+            yield field, wt, val
+        elif wt == 1:
+            i += 8
+        elif wt == 2:
+            ln = 0
+            shift = 0
+            while i < n:
+                b = buf[i]
+                i += 1
+                ln |= (b & 0x7F) << shift
+                if not (b & 0x80):
+                    break
+                shift += 7
+            end = i + ln
+            if end > n:
+                return
+            yield field, wt, buf[i:end]
+            i = end
+        elif wt == 5:
+            i += 4
+        else:
+            return
+
+
+def _field(buf: bytes, wanted: int) -> list[Any]:
+    """Collect field values matching a field number."""
+    found: list[Any] = []
+    try:
+        for f, wt, v in _iter_fields(bytes(buf)):
+            if f == wanted:
+                found.append(v)
+    except Exception:
+        pass
+    return found
+
+
+def _str_field(buf: bytes, wanted: int) -> str | None:
+    for v in _field(buf, wanted):
+        if isinstance(v, bytes):
+            try:
+                s = v.decode("utf-8")
+                if s:
+                    return s
+            except Exception:
+                continue
+    return None
+
+
+def _varint_field(buf: bytes, wanted: int) -> int | None:
+    for v in _field(buf, wanted):
+        if isinstance(v, int):
+            return v
+    return None
+
+
+def _decode_timestamp_ms(buf: bytes) -> int | None:
+    """Protobuf google.protobuf.Timestamp {seconds, nanos} -> epoch milliseconds."""
+    secs = _varint_field(buf, 1)
+    if secs is None:
+        return None
+    nanos = _varint_field(buf, 2) or 0
+    return int(secs * 1000 + nanos / 1_000_000)
+
+
+def _db_entry_to_json(r: sqlite3.Row, title_out: list) -> dict | None:
+    """Convert one `steps` row into the same shape as a transcript.jsonl entry.
+
+    Returns None for internal bookkeeping steps that should be skipped.
+    """
+    payload = r["step_payload"] or b""
+    meta = r["metadata"] or b""
+    step_type = r["step_type"]
+    status = r["status"]
+    e: dict = {
+        "step_index": r["idx"],
+        "source": "MODEL",
+        "type": "GENERIC",
+        "status": "DONE",
+        "created_at": "",
+    }
+
+    # --- tool call info from metadata.f4 { id, name, argsJson } ---
+    tool_name: str | None = None
+    for f in _field(meta, 4):
+        name = _str_field(f, 2)
+        if name:
+            tool_name = name
+    summary = _str_field(meta, 30)
+    action = _str_field(meta, 31)
+
+    if step_type == 14:  # user message
+        text = None
+        for f19 in _field(payload, 19):
+            text = _str_field(f19, 2)
+            if text:
+                break
+        if not text:
+            return None
+        e.update(type="USER_INPUT", source="USER_EXPLICIT", status="DONE", content=text)
+        return e
+
+    if step_type == 15:  # assistant turn
+        content = None
+        tool_calls: list[dict] = []
+        for f20 in _field(payload, 20):
+            if content is None:
+                content = _str_field(f20, 3)
+            for f7 in _field(f20, 7):
+                tc = {"name": _str_field(f7, 2) or "tool"}
+                aj = _str_field(f7, 3)
+                if aj:
+                    try:
+                        tc["args"] = json.loads(aj)
+                    except Exception:
+                        tc["args"] = {"raw": aj}
+                tool_calls.append(tc)
+        e.update(type="PLANNER_RESPONSE", status="DONE")
+        if content:
+            e["content"] = content
+        if tool_calls:
+            e["tool_calls"] = tool_calls
+        return e
+
+    if step_type in (5, 9, 8):  # tool calls / results
+        kind = {5: "CODE_ACTION", 8: "VIEW_FILE", 9: "LIST_DIRECTORY"}[step_type]
+        e.update(type=kind, status="DONE")
+        parts: list[str] = []
+        if tool_name:
+            parts.append(f"Tool: {tool_name}")
+        if action:
+            parts.append(action)
+        if summary:
+            parts.append(summary)
+        # file content result
+        if step_type == 8:
+            for f14 in _field(payload, 14):
+                content = _str_field(f14, 4)
+                if content:
+                    parts.append(content)
+        elif step_type == 5:
+            for f10 in _field(payload, 10):
+                inner = _field(f10, 1)
+                if inner:
+                    content = _str_field(inner[0], 2)
+                    if content:
+                        parts.append(content)
+        e["content"] = "\n".join(parts).strip()
+        return e
+
+    if step_type == 21:  # run_command
+        e.update(type="RUN_COMMAND")
+        stdout: str | None = None
+        exit_code: int | None = None
+        for f28 in _field(payload, 28):
+            for f21 in _field(f28, 21):
+                stdout = _str_field(f21, 1)
+            exit_code = _varint_field(f28, 6)
+        if status in (6, 7):  # failed / denied
+            e["status"] = "ERROR" if status == 6 else "DENIED"
+            err = None
+            for f31 in _field(payload, 31):
+                err = _str_field(f31, 1) or _str_field(f31, 2) or _str_field(f31, 3)
+                if err:
+                    break
+            e["content"] = err or stdout
+            if exit_code is not None:
+                e["exit_code"] = exit_code
+            return e
+        e["status"] = "DONE"
+        e["exit_code"] = exit_code if exit_code is not None else 0
+        e["content"] = stdout or f"{tool_name or 'run_command'} returned {summary or 'ok'}"
+        return e
+
+    if step_type == 17:  # invalid tool call
+        e.update(type="ERROR_MESSAGE", source="SYSTEM", status="DONE")
+        err = None
+        for f24 in _field(payload, 24):
+            err = _str_field(f24, 9) or _str_field(f24, 3)
+            if err:
+                break
+        e["error"] = err or "invalid tool call"
+        e["content"] = "Error invalid tool call: " + (err or "")
+        return e
+
+    if step_type == 33:  # search_web
+        e.update(type="SEARCH_WEB", status="DONE")
+        text = None
+        for f42 in _field(payload, 42):
+            text = _str_field(f42, 5) or _str_field(f42, 1)
+            if text:
+                break
+        e["content"] = text or summary or "search completed"
+        return e
+
+    if step_type == 132:  # manage_task -> generic result
+        e.update(type="GENERIC", status="DONE")
+        text = None
+        for f140 in _field(payload, 140):
+            for f2 in _field(f140, 2):
+                text = _str_field(f2, 1)
+                if text:
+                    break
+        e["content"] = text or summary or "task updated"
+        return e
+
+    if step_type == 101:  # task notification
+        e.update(type="SYSTEM_MESSAGE", source="SYSTEM", status="DONE")
+        text: str | None = None
+        for f114 in _field(payload, 114):
+            for f2 in _field(f114, 2):
+                text = _str_field(f2, 1)
+                if text:
+                    break
+            if text:
+                break
+        e["content"] = text or "task notification"
+        return e
+
+    if step_type == 23:  # conversation header: carries the title
+        for f30 in _field(payload, 30):
+            title = _str_field(f30, 4)
+            if title:
+                title_out.append(title)
+        return None
+
+    return None
+
+
+def load_steps_from_db(db: Path) -> list[dict]:
+    """Decode every meaningful step from the conversations SQLite database."""
+    entries: list[dict] = []
+    title_holder: list = []
+    with sqlite3.connect(f"file:{db}?mode=ro", uri=True, timeout=30) as con:
+        con.row_factory = sqlite3.Row
+        rows = con.execute(
+            "SELECT idx, step_type, status, metadata, step_payload FROM steps ORDER BY idx"
+        ).fetchall()
+        for r in rows:
+            try:
+                e = _db_entry_to_json(r, title_holder)
+            except Exception:
+                e = None
+            if e:
+                entries.append(e)
+    return entries
+
+
+# ---------------------------------------------------------------- messages model
+def _msg(role: str, time_ms: int | None, parts: list[dict], mid: str) -> dict:
+    return {
+        "id": mid,
+        "time_created": time_ms,
+        "time_updated": time_ms,
+        "data": {"role": role},
+        "parts": parts,
+    }
+
+
+def _text_part(text: str) -> dict:
+    return {"data": {"type": "text", "text": text}}
+
+
+def _reasoning_part(text: str) -> dict:
+    return {"data": {"type": "reasoning", "text": text}}
+
+
+def _tool_part(tool: str, status: str, inp: Any, output: Any = None,
+               metadata: dict | None = None) -> dict:
+    state: dict = {"status": status, "input": inp or {}}
+    if output is not None:
+        state["output"] = output
+    if metadata:
+        state["metadata"] = metadata
+    return {"data": {"type": "tool", "tool": tool, "state": state}}
+
+
+def entries_to_messages(entries: list[dict]) -> list[dict]:
+    """Convert transcript-style entries into the OpenCode message model used by the GUI."""
+    messages: list[dict] = []
+    for n, e in enumerate(entries):
+        kind = e.get("type", "")
+        time_ms = _parse_iso(e.get("created_at") or "")
+        mid = f"ag-{n}"
+        if kind == "USER_INPUT":
+            text = (e.get("content") or "").strip()
+            if text.startswith("<USER_REQUEST>"):
+                text = text[len("<USER_REQUEST>"):]
+            end = text.find("</USER_REQUEST>")
+            if end != -1:
+                text = text[:end]
+            text = text.strip()
+            messages.append(_msg("user", time_ms, [_text_part(text)], mid))
+        elif kind == "PLANNER_RESPONSE":
+            parts: list[dict] = []
+            content = (e.get("content") or "").strip()
+            if content:
+                parts.append(_text_part(content))
+            thinking = (e.get("thinking") or "").strip()
+            if thinking:
+                parts.append(_reasoning_part(thinking))
+            for tc in e.get("tool_calls") or []:
+                parts.append(_tool_part(tc.get("name", "tool"), "completed",
+                                       _unquote(tc.get("args", {}))))
+            if not parts:
+                parts.append(_text_part("*(no visible response)*"))
+            messages.append(_msg("assistant", time_ms, parts, mid))
+        elif kind in TOOL_KIND_NAMES:
+            tool = TOOL_KIND_NAMES[kind]
+            output, metadata = _clean_tool_content(kind, e.get("content"), e.get("exit_code"))
+            status = "error" if e.get("status") == "ERROR" else (
+                "cancelled" if e.get("status") == "DENIED" else "completed")
+            messages.append(_msg("assistant", time_ms,
+                                 [_tool_part(tool, status, {}, output, metadata or None)], mid))
+        elif kind == "ERROR_MESSAGE":
+            messages.append(_msg("assistant", time_ms,
+                                 [_tool_part("error", "error", {},
+                                             e.get("content") or e.get("error") or "tool error")], mid))
+        elif kind == "SYSTEM_MESSAGE":
+            text = (e.get("content") or "").strip()
+            if text:
+                messages.append(_msg("system", time_ms, [_text_part(text)], mid))
+        elif kind == "CHECKPOINT":
+            text = (e.get("content") or "").strip()
+            if text:
+                text = text[:2000] + "\n…[checkpoint truncated]" if len(text) > 2000 else text
+                messages.append(_msg("system", time_ms, [_text_part("🧹 " + text)], mid))
+        # CONVERSATION_HISTORY and unknown kinds are skipped
+    return messages
+
+
+# ---------------------------------------------------------------- public class
+class AntiGravityDB:
+    """Read-only access to AntiGravity conversations, mirroring OpenCodeDB's interface."""
+
+    def __init__(self, root: Path | None = None) -> None:
+        p = Path(root) if root else DEFAULT_AG_DIR
+        self.brain_dir: Path | None = None
+        self.single_db: Path | None = None
+        if p.is_file() and p.suffix.lower() == ".db":
+            # a single conversations *.db file was given directly
+            self.single_db = Path(p)
+            self.conv_dir = self.single_db.parent
+            self.brain_dir = self.single_db.parent.parent / "brain"
+        elif p.is_dir():
+            if (p / "conversations").is_dir():
+                self.conv_dir = p / "conversations"
+                self.brain_dir = p / "brain"
+            elif any(p.glob("*.db")):
+                # the conversations folder itself was given
+                self.conv_dir = p
+                self.brain_dir = p.parent / "brain"
+            else:
+                self.conv_dir = p / "conversations"
+                self.brain_dir = p / "brain"
+        else:
+            raise FileNotFoundError(f"AntiGravity folder not found: {p}")
+        if self.single_db is None and not self.conv_dir.is_dir():
+            raise FileNotFoundError(f"No AntiGravity conversations folder at: {self.conv_dir}")
+        self._cache: dict[str, dict] = {}
+        self._info_cache: dict[str, dict] = {}
+
+    # ----------------------------------------------------------------- sessions
+    def list_cascades(self) -> list[str]:
+        if self.single_db is not None:
+            return [self.single_db.stem]
+        if not self.conv_dir.is_dir():
+            return []
+        return sorted(p.stem for p in self.conv_dir.glob("*.db"))
+
+    def _could_load(self, cascade_id: str) -> bool:
+        return self._transcript(cascade_id).exists() or self._db(cascade_id).exists()
+
+    def _transcript(self, cascade_id: str) -> Path:
+        if self.brain_dir is not None:
+            return self.brain_dir / cascade_id / ".system_generated" / "logs" / "transcript.jsonl"
+        return _transcript_path(Path.cwd(), cascade_id)
+
+    def _db(self, cascade_id: str) -> Path:
+        if self.single_db is not None:
+            return self.single_db
+        return self.conv_dir / f"{cascade_id}.db"
+
+    def _session_info(self, cascade_id: str, entries: list[dict],
+                      messages: list[dict]) -> dict:
+        title = ""
+        created = updated = None
+        for e in entries:
+            t = _parse_iso(e.get("created_at") or "")
+            if t:
+                created = t if created is None else min(created, t)
+                updated = t if updated is None else max(updated, t)
+        if not title:
+            for e in entries:
+                if e.get("type") == "USER_INPUT":
+                    text = (e.get("content") or "").strip()
+                    text = re.sub(r"^<USER_REQUEST>\s*", "", text)
+                    title = text.replace("\r", " ").replace("\n", " ")[:64].strip()
+                    break
+        if not title:
+            title = f"Conversation {cascade_id[:8]}"
+        brain = self.brain_dir / cascade_id if self.brain_dir is not None else None
+        directory = str(brain) if brain is not None and brain.is_dir() else str(
+            self.conv_dir if self.single_db is None else self.single_db.parent.parent)
+        return {
+            "id": cascade_id,
+            "title": title,
+            "directory": directory,
+            "agent": "antigravity",
+            "model": None,
+            "time_created": created,
+            "time_updated": updated,
+            "time_archived": None,
+            "message_count": len(messages),
+            "part_count": sum(len(m.get("parts", [])) for m in messages),
+            "steps": len(entries),
+        }
+
+    def _load_cascade(self, cascade_id: str) -> tuple[list[dict], list[dict]]:
+        """Return (entries, messages) for one cascade."""
+        tr = load_transcript(self._transcript(cascade_id))
+        if tr:
+            entries = [e for e in tr if e.get("type") not in SKIP_KINDS]
+            return entries, entries_to_messages(entries)
+        db = self._db(cascade_id)
+        if db.exists():
+            entries = load_steps_from_db(db)
+            return entries, entries_to_messages(entries)
+        return [], []
+
+    def list_sessions(self, include_archived: bool = False) -> list[dict]:
+        sessions = []
+        for cid in self.list_cascades():
+            try:
+                entries, messages = self._load_cascade(cid)
+            except Exception:
+                continue
+            if not messages and not entries:
+                continue
+            info = self._session_info(cid, entries, messages)
+            sessions.append(info)
+            self._cache[cid] = entries
+            self._info_cache[cid] = info
+        sessions.sort(key=lambda s: (s["time_updated"] or 0), reverse=True)
+        return sessions
+
+    # ------------------------------------------------------------- conversation
+    def get_session(self, cascade_id: str) -> dict | None:
+        if cascade_id in self._info_cache:
+            return self._info_cache[cascade_id]
+        entries, messages = self._load_cascade(cascade_id)
+        if not entries and not messages:
+            return None
+        info = self._session_info(cascade_id, entries, messages)
+        self._info_cache[cascade_id] = info
+        return info
+
+    def get_session_messages(self, cascade_id: str) -> list[dict]:
+        if cascade_id in self._cache:
+            entries = self._cache[cascade_id]
+        else:
+            entries, _ = self._load_cascade(cascade_id)
+        return entries_to_messages(entries)
+
+    # ----------------------------------------------------------------- helpers
+    @staticmethod
+    def ts(ms: int | None) -> datetime | None:
+        if not isinstance(ms, int) or ms <= 0:
+            return None
+        return datetime.fromtimestamp(ms / 1000, tz=timezone.utc).astimezone()