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

chat_exporter/gui.py

@@ -0,0 +1,546 @@
+"""OpenCode Chat Exporter GUI - a friendly desktop interface.
+
+Browse every OpenCode conversation from the local database and export it
+into one continuous, verbatim Markdown transcript - including every command,
+search, file operation and message, exactly as it happened.
+"""
+import base64
+import json
+import os
+import queue
+import re
+import threading
+import time
+import tkinter as tk
+from pathlib import Path
+from tkinter import filedialog, messagebox
+
+import customtkinter as ctk
+
+from .db import DEFAULT_DB, make_db
+from .render import Exporter
+
+CONFIG_DIR = Path(os.getenv("APPDATA") or str(Path.home())) / "OpenCodeChatExporter"
+CONFIG_FILE = CONFIG_DIR / "paths.json"
+
+ctk.set_appearance_mode("dark")
+
+BG = "#0e0e12"
+PANEL = "#17171c"
+SURFACE = "#1e1e26"
+LINE = "#2b2b34"
+ACCENT = "#7aa2ff"
+GREEN = "#86d0a0"
+RED = "#e07080"
+MUTED = "#8b8b99"
+
+FONT = "Segoe UI"
+
+
+class ChatViewer(tk.Text):
+    """Renders the conversation as colored chat blocks using a fast tag-based Text."""
+
+    def __init__(self, master, **kw):
+        self._container = ctk.CTkFrame(master, fg_color="#101014", corner_radius=8, border_width=1,
+                                       border_color="#2b2b34")
+        self._container.grid_columnconfigure(0, weight=1)
+        self._container.grid_rowconfigure(0, weight=1)
+        kw.setdefault("bg", "#101014")
+        kw.setdefault("fg", "#e8e8f0")
+        kw.setdefault("insertbackground", "#e8e8f0")
+        kw.setdefault("wrap", "word")
+        kw.setdefault("padx", 14)
+        kw.setdefault("pady", 12)
+        kw.setdefault("borderwidth", 0)
+        kw.setdefault("highlightthickness", 0)
+        kw.setdefault("state", "disabled")
+        kw.setdefault("selectbackground", "#2a4a80")
+        super().__init__(self._container, **kw)
+        self.grid(row=0, column=0, sticky="nsew")
+        vsb = ctk.CTkScrollbar(self._container, command=self.yview)
+        vsb.grid(row=0, column=1, sticky="ns", padx=(0, 6), pady=6)
+        self.configure(yscrollcommand=vsb.set)
+
+        self.tag_config("user", background="#232f46", foreground="#cfe4ff")
+        self.tag_config("user_head", background="#232f46", foreground="#7aa2ff",
+                        font=(FONT, 12, "bold"))
+        self.tag_config("assistant", background="#1c2820", foreground="#dceee0")
+        self.tag_config("asst_head", background="#1c2820", foreground="#86d0a0",
+                        font=(FONT, 12, "bold"))
+        self.tag_config("tool", background="#241d2e", foreground="#d6c8ec",
+                        font=("Consolas", 11))
+        self.tag_config("meta", background="#15151a", foreground="#8b8b99",
+                        font=(FONT, 10, "italic"))
+        self.tag_config("error", background="#3a1e22", foreground="#ffb3bd")
+
+    def clear(self):
+        self.configure(state="normal")
+        self.delete("1.0", "end")
+        self.configure(state="disabled")
+
+    @property
+    def container(self):
+        return self._container
+
+    def add(self, kind: str, text: str):
+        if not text:
+            return
+        kind = kind if kind in ("user", "user_head", "asst_head", "tool", "meta", "error") else "asst"
+        self.configure(state="normal")
+        self.insert("end", text + "\n\n", kind)
+        self.configure(state="disabled")
+
+
+class App(ctk.CTk):
+    def __init__(self):
+        super().__init__()
+        self.title("OpenCode Chat Exporter")
+        self.geometry("1280x860")
+        self.minsize(1024, 700)
+        self.configure(fg_color=BG)
+
+        self.db = None
+        self.sessions: list[dict] = []
+        self.current: dict | None = None
+        self.source = "opencode"
+        self._paths: dict[str, str] = self._load_paths()
+        self.watch_job = None
+        self._preview_q: queue.Queue = queue.Queue()
+
+        self._build_ui()
+        self._apply_path()
+        self._load_db()
+        self.after(200, self.refresh)
+        self.after(120, self._drain_preview)
+
+    # ---------------------------------------------------------------- ui build
+    def _build_ui(self):
+        self.grid_columnconfigure(1, weight=1)
+        self.grid_rowconfigure(1, weight=1)
+
+        # ---------------- header ----------------
+        header = ctk.CTkFrame(self, fg_color=PANEL, corner_radius=0, height=64)
+        header.grid(row=0, column=0, columnspan=2, sticky="ew")
+        header.grid_columnconfigure(2, weight=1)
+
+        ctk.CTkLabel(header, text="💬  Chat Exporter", font=(FONT, 17, "bold"),
+                     text_color="#ffffff").grid(row=0, column=0, padx=(16, 8), pady=14)
+
+        self.status = ctk.CTkLabel(header, text="loading…", text_color=MUTED, font=(FONT, 12))
+        self.status.grid(row=0, column=2, sticky="e", padx=16)
+
+        # ---------------- sidebar ----------------
+        self.sidebar = ctk.CTkFrame(self, fg_color=PANEL, corner_radius=0, width=320)
+        self.sidebar.grid(row=1, column=0, sticky="nsw", padx=(0, 1))
+        self.sidebar.grid_propagate(False)
+        self.sidebar.grid_columnconfigure(0, weight=1)
+
+        # db path row
+        seg = ctk.CTkSegmentedButton(self.sidebar, values=["OpenCode", "AntiGravity"],
+                                      command=self._source_changed, font=(FONT, 12))
+        seg.grid(row=0, column=0, sticky="ew", padx=10, pady=(10, 6))
+        seg.set("OpenCode")
+
+        row = ctk.CTkFrame(self.sidebar, fg_color="transparent")
+        row.grid(row=1, column=0, sticky="ew", padx=10, pady=(0, 4))
+        row.grid_columnconfigure(0, weight=1)
+        self.db_entry = ctk.CTkEntry(row, height=30, font=(FONT, 11))
+        self.db_entry.grid(row=0, column=0, sticky="ew", padx=(0, 6))
+        self.db_entry.insert(0, str(DEFAULT_DB))
+        ctk.CTkButton(row, text="…", width=30, command=self._browse_db).grid(row=0, column=1)
+        ctk.CTkButton(row, text="⟳", width=34, command=self.refresh).grid(row=0, column=2, padx=(6, 0))
+
+        # search
+        self.search_entry = ctk.CTkEntry(self.sidebar, placeholder_text="🔎  search sessions…",
+                                         height=32, font=(FONT, 12))
+        self.search_entry.grid(row=2, column=0, sticky="ew", padx=10, pady=6)
+        self.search_entry.bind("<KeyRelease>", lambda e: self._filter_sessions())
+
+        # session list
+        self.list_frame = ctk.CTkScrollableFrame(self.sidebar, fg_color="transparent")
+        self.list_frame.grid(row=3, column=0, sticky="nsew", padx=6, pady=2)
+        self.sidebar.grid_rowconfigure(3, weight=1)
+
+        # options
+        opts = ctk.CTkFrame(self.sidebar, fg_color=SURFACE, corner_radius=10)
+        opts.grid(row=4, column=0, sticky="ew", padx=10, pady=(8, 10))
+        opts.grid_columnconfigure(0, weight=1)
+
+        self.ck_reasoning = ctk.CTkCheckBox(opts, text="Include reasoning", font=(FONT, 11))
+        self.ck_reasoning.grid(row=0, column=0, sticky="w", padx=8, pady=(8, 2))
+
+        self.ck_watch = ctk.CTkCheckBox(opts, text="Live watch (auto re-export)", font=(FONT, 11),
+                                        command=self._toggle_watch)
+        self.ck_watch.grid(row=1, column=0, sticky="w", padx=8, pady=(2, 2))
+
+        export_row = ctk.CTkFrame(opts, fg_color="transparent")
+        export_row.grid(row=2, column=0, sticky="ew", padx=8, pady=(6, 8))
+        export_row.grid_columnconfigure(0, weight=1)
+        export_row.grid_columnconfigure(1, weight=1)
+        ctk.CTkButton(export_row, text="📄 Export session", command=self._export_one,
+                      fg_color=ACCENT, text_color="#0d1117", font=(FONT, 12, "bold")).grid(
+            row=0, column=0, sticky="ew", padx=(0, 4))
+        ctk.CTkButton(export_row, text="🗂 Export all", command=self._export_all,
+                      fg_color=ACCENT, text_color="#0d1117", font=(FONT, 12, "bold")).grid(
+            row=0, column=1, sticky="ew", padx=(4, 0))
+
+        # ---------------- main preview ----------------
+        self.main = ctk.CTkFrame(self, fg_color=BG, corner_radius=0)
+        self.main.grid(row=1, column=1, sticky="nsew")
+        self.main.grid_columnconfigure(0, weight=1)
+        self.main.grid_rowconfigure(1, weight=1)
+
+        self.title_label = ctk.CTkLabel(self.main, text="Select a session…", font=(FONT, 16, "bold"),
+                                        text_color="#ffffff", anchor="w")
+        self.title_label.grid(row=0, column=0, sticky="ew", padx=18, pady=(14, 2))
+
+        self.meta_label = ctk.CTkLabel(self.main, text="", text_color=MUTED, font=(FONT, 11), anchor="w")
+        self.meta_label.grid(row=1, column=0, sticky="n", padx=18, pady=(0, 4))
+        self.main.grid_rowconfigure(1, weight=0)
+
+        self.viewer = ChatViewer(self.main)
+        self.viewer.container.grid(row=2, column=0, sticky="nsew", padx=14, pady=(4, 14))
+        self.main.grid_rowconfigure(2, weight=1)
+
+    # ---------------------------------------------------------------- database
+    def _load_paths(self) -> dict[str, str]:
+        try:
+            with open(CONFIG_FILE, encoding="utf-8") as f:
+                data = json.load(f)
+            return {k: str(v) for k, v in data.items() if k in ("opencode", "antigravity") and v}
+        except Exception:
+            return {}
+
+    def _save_paths(self):
+        try:
+            CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+            with open(CONFIG_FILE, "w", encoding="utf-8") as f:
+                json.dump(self._paths, f, ensure_ascii=False, indent=2)
+        except Exception:
+            pass
+
+    def _apply_path(self):
+        p = self._paths.get(self.source)
+        if not p:
+            if self.source == "antigravity":
+                from .antigravity import DEFAULT_AG_DIR
+                p = str(DEFAULT_AG_DIR)
+            else:
+                p = str(DEFAULT_DB)
+        self.db_entry.delete(0, "end")
+        self.db_entry.insert(0, p)
+
+    def _source_changed(self, value: str):
+        new = value.lower()
+        if new != self.source:
+            self._paths[self.source] = self.db_entry.get().strip()
+            self._save_paths()
+        self.source = new
+        self._apply_path()
+        self.refresh()
+
+    def _browse_db(self):
+        if self.source == "antigravity":
+            p = filedialog.askdirectory(
+                title="Select the AntiGravity folder (contains conversations\\ and brain\\)",
+                initialdir=self.db_entry.get().strip(),
+            )
+        else:
+            p = filedialog.askopenfilename(
+                title="Select opencode.db",
+                initialdir=Path(self.db_entry.get()).parent,
+                filetypes=[("SQLite database", "*.db"), ("All files", "*.*")],
+            )
+        if p:
+            self.db_entry.delete(0, "end")
+            self.db_entry.insert(0, p)
+            self._paths[self.source] = p
+            self._save_paths()
+            self.refresh()
+
+    def _load_db(self) -> bool:
+        path = self.db_entry.get().strip()
+        try:
+            self.db = make_db(self.source, path)
+            return True
+        except Exception as e:
+            self.db = None
+            self._status(f"⚠ DB error: {e}", RED)
+            return False
+
+    def refresh(self):
+        if not self._load_db():
+            self.viewer.clear()
+            return
+        try:
+            self.sessions = self.db.list_sessions()
+        except Exception as e:
+            self._status(f"⚠ {e}", RED)
+            return
+        self._filter_sessions()
+        self._status(f"✓ {len(self.sessions)} sessions", GREEN)
+
+    def _filter_sessions(self):
+        q = self.search_entry.get().strip().lower()
+        for w in self.list_frame.winfo_children():
+            w.destroy()
+        shown = 0
+        for s in self.sessions:
+            title = (s["title"] or "").lower()
+            if q and q not in title and q not in s["id"].lower():
+                continue
+            self._session_button(s)
+            shown += 1
+        if not shown:
+            ctk.CTkLabel(self.list_frame, text="no matches", text_color=MUTED).pack(pady=20)
+
+    def _session_button(self, s: dict):
+        created = self.db.ts(s["time_created"])
+        created_s = created.strftime("%Y-%m-%d %H:%M") if created else ""
+        n = s["message_count"]
+        active = s["id"] == (self.current or {}).get("id")
+        row = ctk.CTkFrame(
+            self.list_frame,
+            fg_color=ACCENT if active else SURFACE,
+            corner_radius=8,
+            height=52,
+            cursor="hand2",
+        )
+        row.pack(fill="x", padx=2, pady=2)
+        row.pack_propagate(False)
+        label = ctk.CTkLabel(
+            row,
+            text=f"{s['title'] or '(untitled)'}\n{created_s}  ·  {n} messages",
+            text_color="#0d1117" if active else "#d9d9e3",
+            font=(FONT, 12),
+            justify="left",
+            anchor="w",
+        )
+        label.pack(fill="both", expand=True, padx=10, pady=4)
+        for w in (row, label):
+            w.bind("<Button-1>", lambda e, sid=s["id"]: self._select(sid))
+            w.bind("<Enter>", lambda e, r=row, a=active: r.configure(fg_color=ACCENT if a else "#2a2a35"))
+            w.bind("<Leave>", lambda e, r=row, a=active: r.configure(fg_color=ACCENT if a else SURFACE))
+
+    # ------------------------------------------------------------------ select
+    def _select(self, session_id: str):
+        if self.db is None:
+            return
+        s = next((x for x in self.sessions if x["id"] == session_id), None)
+        if not s:
+            return
+        self.current = s
+        self.title_label.configure(text=s["title"] or "(untitled)")
+        meta = []
+        if self.source == "antigravity":
+            meta.append("source: AntiGravity")
+        agent = s.get("agent")
+        if agent and agent != "antigravity":
+            meta.append(f"agent: {agent}")
+        model = s.get("model")
+        if isinstance(model, dict) and model.get("modelID"):
+            meta.append(f"model: {model['modelID']}")
+        created = self.db.ts(s["time_created"])
+        if created:
+            meta.append(created.strftime("%Y-%m-%d %H:%M"))
+        tokens = int(s.get("tokens_input") or 0) + int(s.get("tokens_output") or 0)
+        meta.append(f"{tokens:,} tokens" if tokens else "- tokens")
+        if s.get("directory"):
+            meta.append(str(s["directory"]))
+        self.meta_label.configure(text="  ·  ".join(meta))
+        self._filter_sessions()
+        self._status(f"loading {s['title']}…", MUTED)
+        threading.Thread(target=self._load_preview, args=(s["id"],), daemon=True).start()
+
+    def _drain_preview(self):
+        try:
+            while True:
+                item = self._preview_q.get_nowait()
+                if isinstance(item, tuple) and len(item) == 2 and item[0] == "__popup__":
+                    title, msg, is_err = item[1]
+                    if is_err:
+                        messagebox.showerror(title, msg)
+                    else:
+                        messagebox.showinfo(title, msg)
+                else:
+                    self._show_rows(item)
+        except queue.Empty:
+            pass
+        self.after(120, self._drain_preview)
+
+    def _load_preview(self, session_id: str):
+        try:
+            messages = self.db.get_session_messages(session_id)
+            rows = []
+            for m in messages:
+                role = m["data"].get("role")
+                if role == "user":
+                    rows.append(("user_head", f"🟢  YOU   ·   {self._fmt(m['time_created'])}"))
+                    for p in m["parts"]:
+                        t = p["data"].get("text")
+                        if p["data"].get("type") == "text" and t:
+                            rows.append(("user", t))
+                elif role == "assistant":
+                    rows.append(("asst_head", f"🔵  OpenCode   ·   {self._fmt(m['time_created'])}"))
+                    for p in m["parts"]:
+                        d = p["data"]
+                        kind = d.get("type")
+                        if kind == "text" and d.get("text"):
+                            rows.append(("assistant", d["text"]))
+                        elif kind == "tool":
+                            rows.append(("tool", self._tool_block(d)))
+                        elif kind == "reasoning" and self.ck_reasoning.get():
+                            rows.append(("meta", "🧠 reasoning"))
+                            rows.append(("meta", str(d.get("text", ""))[:4000]))
+                        elif kind == "file":
+                            rows.append(("tool", f"📎 {d.get('filename')} ({d.get('mime','')})"))
+            if not rows:
+                rows = [("meta", "(no messages)")]
+            self._preview_q.put(rows)
+        except Exception as e:
+            self._preview_q.put([("error", f"failed to load: {e}")])
+
+    def _show_rows(self, rows):
+        self.viewer.clear()
+        for kind, text in rows:
+            self.viewer.add(kind, text)
+        self.viewer.see("1.0")
+        if self.current:
+            self._status(f"✓ {len(rows)} blocks", GREEN)
+
+    @staticmethod
+    def _fmt(ms):
+        try:
+            import datetime
+            return datetime.datetime.fromtimestamp(ms / 1000).strftime("%H:%M:%S")
+        except Exception:
+            return ""
+
+    def _tool_block(self, d: dict) -> str:
+        tool = d.get("tool") or d.get("name") or "tool"
+        state = d.get("state") or {}
+        status = state.get("status", "")
+        icon = {"completed": "✅", "error": "⛔", "cancelled": "🚫"}.get(status, "⏳")
+        lines = [f"{icon}  {tool}  ·  {status}"]
+        inp = state.get("input") or {}
+        title = ""
+        for k in ("command", "pattern", "filePath", "path", "url", "query"):
+            if inp.get(k) is not None:
+                title = str(inp[k])
+                break
+        if title:
+            lines.append(f"   in: {title}")
+        elif inp:
+            lines.append("   in: " + json.dumps(inp, ensure_ascii=False)[:600])
+        out = state.get("output")
+        if isinstance(out, str) and out.startswith("data:"):
+            try:
+                out = base64.b64decode(out.split(",", 1)[1]).decode("utf-8", errors="replace")
+            except Exception:
+                out = "(attachment)"
+        if isinstance(out, (dict, list)):
+            out = json.dumps(out, ensure_ascii=False)
+        if out:
+            out = str(out)
+            out = out[:4000] + " …" if len(out) > 4000 else out
+            lines.append("")
+            lines.append(out)
+        return "\n".join(lines)
+
+    # ------------------------------------------------------------------- export
+    def _make_exporter(self) -> Exporter:
+        return Exporter(
+            make_db(self.source, self.db_entry.get().strip()),
+            include_reasoning=bool(self.ck_reasoning.get()),
+            include_metadata=False,
+            output_dir=None,
+            max_output=None,
+        )
+
+    def _export_one(self):
+        if not self.current:
+            messagebox.showinfo("Chat Exporter", "Select a session first.")
+            return
+        s = self.current
+        default_name = re.sub(r'[\\/:*?"<>|]', "_", s["title"] or s["id"]) + ".md"
+        dest = filedialog.asksaveasfilename(
+            title="Export session as Markdown",
+            defaultextension=".md",
+            initialfile=default_name,
+            filetypes=[("Markdown", "*.md"), ("Text", "*.txt"), ("All files", "*.*")],
+        )
+        if not dest:
+            return
+        self._status("exporting…", MUTED)
+        threading.Thread(target=self._do_export, args=(dest, [s["id"]]), daemon=True).start()
+
+    def _export_all(self):
+        folder = filedialog.askdirectory(title="Choose folder to export all sessions into")
+        if not folder:
+            return
+        ids = [s["id"] for s in self.sessions]
+        self._status(f"exporting {len(ids)} sessions…", MUTED)
+        threading.Thread(target=self._do_export, args=(Path(folder), ids), daemon=True).start()
+
+    def _do_export(self, dest, ids):
+        try:
+            exporter = self._make_exporter()
+            n = 0
+            if isinstance(dest, Path):
+                dest.mkdir(parents=True, exist_ok=True)
+                for sid in ids:
+                    s = next((x for x in self.sessions if x["id"] == sid), {})
+                    name = re.sub(r'[\\/:*?"<>|]', "_", s.get("title") or sid) + ".md"
+                    (dest / name).write_text(exporter.render_session(sid), encoding="utf-8")
+                    n += 1
+                self._preview_q.put([("meta", f"✓ exported {n} sessions → {dest}")])
+                self._preview_q.put(("__popup__", ("Done", f"Exported {n} sessions to:\n{dest}", False)))
+            else:
+                dest = Path(dest)
+                dest.write_text(exporter.render_session(ids[0]), encoding="utf-8")
+                self._preview_q.put([("meta", f"✓ exported → {dest}")])
+        except Exception as e:
+            self._preview_q.put([("error", f"✗ export failed: {e}")])
+            self._preview_q.put(("__popup__", ("Export failed", str(e), True)))
+
+    # --------------------------------------------------------------------- misc
+    def _toggle_watch(self):
+        if self.ck_watch.get():
+            self._start_watch()
+        else:
+            self._stop_watch()
+
+    def _start_watch(self):
+        self._stop_watch()
+        self._watch_loop()
+
+    def _stop_watch(self):
+        if self.watch_job:
+            self.after_cancel(self.watch_job)
+            self.watch_job = None
+
+    def _watch_loop(self):
+        if not self.ck_watch.get():
+            return
+        try:
+            self.refresh()
+        except Exception:
+            pass
+        self.watch_job = self.after(8000, self._watch_loop)
+
+    def _status(self, text: str, color: str = MUTED):
+        self.status.configure(text=text, text_color=color)
+
+    def on_close(self):
+        self._stop_watch()
+        self.destroy()
+
+
+def main():
+    app = App()
+    app.protocol("WM_DELETE_WINDOW", app.on_close)
+    app.mainloop()
+
+
+if __name__ == "__main__":
+    main()