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

chat_exporter/cli.py

@@ -0,0 +1,194 @@
+import argparse
+import re
+import sys
+import time
+from pathlib import Path
+from typing import Sequence
+
+from . import __version__
+from .db import SOURCES, make_db
+from .render import Exporter
+
+
+def _safe_title(title: str) -> str:
+    safe = re.sub(r'[\\/:*?"<>|]', "_", title)
+    safe = safe.strip().strip(".")
+    return safe[:120] or "untitled"
+
+
+def _make_exporter(args) -> Exporter:
+    return Exporter(
+        make_db(args.source, args.db),
+        include_reasoning=args.reasoning,
+        include_metadata=args.metadata,
+        output_dir=Path(getattr(args, "output_dir", None) or "."),
+        max_output=args.max_output,
+    )
+
+
+def _pick(db, args) -> list[dict]:
+    sessions = db.list_sessions(include_archived=args.archived)
+    if args.all:
+        return sessions
+    if not sessions:
+        print("No sessions found.")
+        sys.exit(1)
+    if args.session:
+        by_id = [s for s in sessions if s["id"] == args.session]
+        if by_id:
+            return by_id
+        try:
+            idx = int(args.session) - 1
+        except ValueError:
+            idx = -1
+        if 0 <= idx < len(sessions):
+            return [sessions[idx]]
+        by_title = [s for s in sessions if args.session.lower() in (s["title"] or "").lower()]
+        if by_title:
+            return by_title
+        print(f"Session not found: {args.session}")
+        print("Use `list` to see available sessions, or pass a numeric index.")
+        sys.exit(1)
+    if args.latest:
+        return [sessions[0]]
+    print("Specify `--session <id|index|title>`, `--latest`, or `--all`.")
+    sys.exit(1)
+
+
+def cmd_list(args) -> int:
+    db = make_db(args.source, args.db)
+    sessions = db.list_sessions(include_archived=args.archived)
+    if not sessions:
+        print("No sessions found.")
+        return 0
+    print(f"{'#':<4} {'created':<17} {'msgs':<6} {'parts':<7} title")
+    for i, s in enumerate(sessions, 1):
+        created = db.ts(s["time_created"])
+        created_s = created.strftime("%Y-%m-%d %H:%M") if created else "-"
+        print(f"{i:<4} {created_s:<17} {s['message_count']:<6} {s['part_count']:<7} {s['title'] or '(untitled)'}")
+    print()
+    print("IDs:")
+    for s in sessions:
+        print(f"  {s['id']}")
+    return 0
+
+
+def cmd_export(args) -> int:
+    db = make_db(args.source, args.db)
+    exporter = _make_exporter(args)
+    if args.all and args.one:
+        md = exporter.render_all(include_archived=args.archived)
+        out = Path(args.output or "all-conversations.md")
+        out.write_text(md, encoding="utf-8")
+        print(f"exported -> {out}  ({len(md):,} chars)")
+        return 0
+    for s in _pick(db, args):
+        md = exporter.render_session(s["id"])
+        out = Path(args.output or f"{_safe_title(s['title'] or s['id'])}.md")
+        out.write_text(md, encoding="utf-8")
+        print(f"exported -> {out}  ({len(md):,} chars, {s['message_count']} messages)")
+    return 0
+
+
+def cmd_export_all(args) -> int:
+    db = make_db(args.source, args.db)
+    exporter = _make_exporter(args)
+    sessions = db.list_sessions(include_archived=args.archived)
+    if not sessions:
+        print("No sessions found.")
+        return 0
+    out_dir = Path(args.output_dir or "chats")
+    out_dir.mkdir(parents=True, exist_ok=True)
+    for s in sessions:
+        md = exporter.render_session(s["id"])
+        out = out_dir / f"{_safe_title(s['title'] or s['id'])}.md"
+        out.write_text(md, encoding="utf-8")
+        print(f"exported -> {out}")
+    return 0
+
+
+def _watch_refresh(db, exporter: Exporter, out_dir: Path, show: bool) -> None:
+    out_dir.mkdir(parents=True, exist_ok=True)
+    for s in db.list_sessions():
+        md = exporter.render_session(s["id"])
+        out = out_dir / f"{_safe_title(s['title'] or s['id'])}.md"
+        out.write_text(md, encoding="utf-8")
+        if show:
+            print(f"updated -> {out}")
+
+
+def cmd_watch(args) -> int:
+    db = make_db(args.source, args.db)
+    exporter = _make_exporter(args)
+    out_dir = Path(args.output_dir or "chats")
+    print(f"Watching {db.db_path} every {args.poll}s -> {out_dir}")
+    last = None
+    while True:
+        try:
+            mtime = db.db_path.stat().st_mtime
+        except OSError:
+            mtime = None
+        if mtime != last:
+            last = mtime
+            _watch_refresh(db, exporter, out_dir, show=True)
+        time.sleep(args.poll)
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="chat_exporter",
+        description="Export full OpenCode conversations from the local database into one continuous Markdown transcript.",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    p.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    p.add_argument("--source", choices=SOURCES, default="opencode",
+                   help="conversation source (default: opencode)")
+    p.add_argument("--db", default=None,
+                   help="path to opencode.db, or (with --source antigravity) the AntiGravity "
+                        "folder, its conversations\\ subfolder, or a single .db file")
+    sub = p.add_subparsers(dest="command", required=True)
+
+    lp = sub.add_parser("list", help="list available sessions")
+    lp.add_argument("--archived", action="store_true")
+    lp.set_defaults(func=cmd_list)
+
+    ep = sub.add_parser("export", help="export one session to a single Markdown file")
+    ep.add_argument("--session", help="session ID, numeric index, or title fragment")
+    ep.add_argument("--latest", action="store_true")
+    ep.add_argument("--all", action="store_true")
+    ep.add_argument("--one", action="store_true", help="with --all: write every session into one combined file")
+    ep.add_argument("--archived", action="store_true")
+    ep.add_argument("--reasoning", action="store_true", help="include reasoning parts")
+    ep.add_argument("--metadata", action="store_true", help="include raw metadata parts")
+    ep.add_argument("--max-output", type=int, default=None, help="truncate tool outputs to N chars")
+    ep.add_argument("--output", "-o", default=None, help="output .md file path")
+    ep.set_defaults(func=cmd_export)
+
+    ap = sub.add_parser("export-all", help="export every session to its own Markdown file")
+    ap.add_argument("--output-dir", default="chats", help="output directory (default: chats)")
+    ap.add_argument("--archived", action="store_true")
+    ap.add_argument("--reasoning", action="store_true")
+    ap.add_argument("--metadata", action="store_true")
+    ap.add_argument("--max-output", type=int, default=None)
+    ap.set_defaults(func=cmd_export_all)
+
+    wp = sub.add_parser("watch", help="continuously re-export all sessions on database changes")
+    wp.add_argument("--output-dir", default="chats")
+    wp.add_argument("--poll", type=int, default=5, help="poll interval in seconds (default: 5)")
+    wp.add_argument("--archived", action="store_true")
+    wp.add_argument("--reasoning", action="store_true")
+    wp.add_argument("--metadata", action="store_true")
+    wp.add_argument("--max-output", type=int, default=None)
+    wp.set_defaults(func=cmd_watch)
+
+    return p
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    return args.func(args)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

chat_exporter/db.py

@@ -0,0 +1,149 @@
+import json
+import os
+import sqlite3
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+DEFAULT_DB = Path(os.path.expandvars(r"%USERPROFILE%\.local\share\opencode\opencode.db"))
+
+SOURCES = ("opencode", "antigravity")
+
+
+def make_db(source: str, path: str | Path | None = None):
+    """Build the right reader for a conversation source.
+
+    ``opencode`` uses the OpenCode SQLite database; ``antigravity`` scans the
+    AntiGravity folder (conversations + readable JSON transcripts).
+    """
+    if source == "antigravity":
+        from .antigravity import DEFAULT_AG_DIR, AntiGravityDB
+        return AntiGravityDB(Path(path) if path else DEFAULT_AG_DIR)
+    return OpenCodeDB(Path(path) if path else DEFAULT_DB)
+
+
+class OpenCodeDB:
+    """Read-only access to the OpenCode local SQLite database."""
+
+    def __init__(self, db_path: Path | None = None) -> None:
+        self.db_path = Path(db_path) if db_path else DEFAULT_DB
+        if not self.db_path.exists():
+            raise FileNotFoundError(f"OpenCode database not found: {self.db_path}")
+
+    def connect(self) -> sqlite3.Connection:
+        con = sqlite3.connect(f"file:{self.db_path}?mode=ro", uri=True, timeout=30)
+        con.row_factory = sqlite3.Row
+        return con
+
+    # ------------------------------------------------------------------ sessions
+    def list_sessions(self, include_archived: bool = False) -> list[dict]:
+        sql = """
+            SELECT s.id, s.title, s.directory, s.agent, s.model, s.time_created,
+                   s.time_updated, s.time_archived, s.cost, s.tokens_input,
+                   s.tokens_output, s.tokens_reasoning,
+                   (SELECT COUNT(*) FROM message m WHERE m.session_id = s.id) AS message_count,
+                   (SELECT COUNT(*) FROM part p WHERE p.session_id = s.id) AS part_count
+            FROM session s
+        """
+        if not include_archived:
+            sql += " WHERE s.time_archived IS NULL"
+        sql += " ORDER BY s.time_updated DESC"
+
+        rows = []
+        with self.connect() as con:
+            for r in con.execute(sql):
+                rows.append(self._row_to_dict(r))
+        return rows
+
+    def get_session(self, session_id: str) -> dict | None:
+        sql = """
+            SELECT s.*, p.name AS project_name, p.worktree AS project_worktree
+            FROM session s
+            LEFT JOIN project p ON p.id = s.project_id
+            WHERE s.id = ?
+        """
+        with self.connect() as con:
+            r = con.execute(sql, (session_id,)).fetchone()
+        return self._row_to_dict(r) if r else None
+
+    # ------------------------------------------------------------------ messages
+    def get_messages(self, session_id: str) -> list[dict]:
+        sql = """
+            SELECT id, time_created, time_updated, data
+            FROM message
+            WHERE session_id = ?
+            ORDER BY time_created ASC, rowid ASC
+        """
+        out = []
+        with self.connect() as con:
+            for r in con.execute(sql, (session_id,)):
+                try:
+                    data = json.loads(r["data"])
+                except Exception:
+                    data = {}
+                out.append(
+                    {
+                        "id": r["id"],
+                        "time_created": r["time_created"],
+                        "time_updated": r["time_updated"],
+                        "data": data,
+                        "parts": [],
+                    }
+                )
+        return out
+
+    # --------------------------------------------------------------------- parts
+    def get_parts_for_messages(self, message_ids: list[str]) -> dict[str, list[dict]]:
+        """Return all parts grouped by message_id, ordered by time_created."""
+        if not message_ids:
+            return {}
+        holder = ",".join("?" for _ in message_ids)
+        sql = f"""
+            SELECT id, message_id, time_created, time_updated, data
+            FROM part
+            WHERE message_id IN ({holder})
+            ORDER BY time_created ASC, rowid ASC
+        """
+        grouped: dict[str, list[dict]] = {mid: [] for mid in message_ids}
+        with self.connect() as con:
+            for r in con.execute(sql, message_ids):
+                try:
+                    data = json.loads(r["data"])
+                except Exception:
+                    data = {}
+                grouped.setdefault(r["message_id"], []).append(
+                    {
+                        "id": r["id"],
+                        "message_id": r["message_id"],
+                        "time_created": r["time_created"],
+                        "time_updated": r["time_updated"],
+                        "data": data,
+                    }
+                )
+        return grouped
+
+    def get_session_messages(self, session_id: str) -> list[dict]:
+        messages = self.get_messages(session_id)
+        parts = self.get_parts_for_messages([m["id"] for m in messages])
+        for m in messages:
+            m["parts"] = parts.get(m["id"], [])
+        return messages
+
+    # ------------------------------------------------------------------- helpers
+    @staticmethod
+    def _row_to_dict(r: sqlite3.Row) -> dict:
+        d = {k: r[k] for k in r.keys()}
+        for key in ("model", "metadata", "summary_diffs", "revert", "permission"):
+            if isinstance(d.get(key), str):
+                try:
+                    d[key] = json.loads(d[key])
+                except Exception:
+                    pass
+        return d
+
+    @staticmethod
+    def ts(ms: int | None) -> datetime | None:
+        if not isinstance(ms, int) or ms <= 0:
+            return None
+        t = datetime.fromtimestamp(ms / 1000, tz=timezone.utc).astimezone()
+        return t