claude-opencode-sessions 0.1.0__py3-none-any.whl

claude_opencode_sessions/parse.py

@@ -0,0 +1,224 @@
+"""Parsers turning opencode's stored JSON into :mod:`models` objects.
+
+Two shapes exist:
+
+* opencode 1.x (SQLite era, >= 1.2) and ``opencode export``: a message
+  ``info`` object plus a list of ``part`` objects.
+* opencode 2.x: one ``session_message`` row per event, with the role in the
+  ``type`` column and a JSON ``data`` payload.
+
+Every accessor is defensive: unknown shapes degrade to generic parts
+instead of raising.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from .models import Message, Part, format_model
+
+__all__ = [
+    "as_dict",
+    "as_list",
+    "loads",
+    "parse_v1_message",
+    "parse_v1_part",
+    "parse_v2_row",
+]
+
+_SKIP_V1_PARTS = {"step-start", "step-finish", "snapshot"}
+
+
+def as_dict(value: Any) -> dict[str, Any]:
+    """``value`` if it is a dict, else an empty dict."""
+    return value if isinstance(value, dict) else {}
+
+
+def as_list(value: Any) -> list[Any]:
+    """``value`` if it is a list, else an empty list."""
+    return value if isinstance(value, list) else []
+
+
+def loads(raw: Any) -> Any:
+    """``json.loads`` that returns ``None`` instead of raising."""
+    if raw is None:
+        return None
+    if isinstance(raw, (dict, list)):
+        return raw
+    try:
+        return json.loads(raw)
+    except (TypeError, ValueError):
+        return None
+
+
+def _str(value: Any) -> str:
+    if value is None:
+        return ""
+    if isinstance(value, str):
+        return value
+    try:
+        return json.dumps(value, ensure_ascii=False)
+    except (TypeError, ValueError):
+        return str(value)
+
+
+def _error_text(error: Any) -> str | None:
+    if not error:
+        return None
+    if isinstance(error, dict):
+        name = error.get("name") or "Error"
+        data = error.get("data")
+        message = data.get("message") if isinstance(data, dict) else None
+        message = message or error.get("message")
+        return f"{name}: {message}" if message else str(name)
+    return _str(error)
+
+
+def parse_v1_part(part: Any) -> Part | None:
+    """Parse one 1.x ``part`` object. Returns ``None`` for bookkeeping parts."""
+    if not isinstance(part, dict):
+        return Part(kind="other", text=_str(part))
+    kind = part.get("type") or "other"
+    if kind in _SKIP_V1_PARTS:
+        return None
+    if kind in ("text", "reasoning"):
+        return Part(
+            kind=kind,
+            text=_str(part.get("text")),
+            synthetic=bool(part.get("synthetic") or part.get("ignored")),
+        )
+    if kind == "tool":
+        state = as_dict(part.get("state"))
+        output = state.get("output")
+        if output is None and state.get("error") is not None:
+            output = state.get("error")
+        return Part(
+            kind="tool",
+            tool=_str(part.get("tool")) or "tool",
+            tool_input=state.get("input"),
+            tool_output=None if output is None else _str(output),
+            status=state.get("status"),
+            title=state.get("title"),
+        )
+    if kind == "file":
+        name = part.get("filename") or part.get("url") or ""
+        return Part(kind="file", text=_str(name), files=[_str(name)] if name else [])
+    if kind == "patch":
+        files = as_list(part.get("files"))
+        return Part(kind="patch", files=[_str(f) for f in files])
+    if kind == "compaction":
+        return Part(kind="compaction")
+    if kind in ("agent", "subtask"):
+        text = part.get("prompt") or part.get("description") or part.get("name")
+        return Part(kind=kind, text=_str(text))
+    return Part(kind=_str(kind), text=_str(part.get("text")))
+
+
+def parse_v1_message(info: Any, parts: list[Any], seq: int | None = None) -> Message:
+    """Parse a 1.x message ``info`` object together with its parts."""
+    info = info if isinstance(info, dict) else {}
+    model = format_model(info.get("model"))
+    if model is None and info.get("modelID"):
+        model = format_model(
+            {"id": info.get("modelID"), "providerID": info.get("providerID")}
+        )
+    time = as_dict(info.get("time"))
+    tokens = as_dict(info.get("tokens")) or None
+    cost = info.get("cost")
+    parsed = [p for p in (parse_v1_part(raw) for raw in parts) if p is not None]
+    return Message(
+        id=_str(info.get("id")),
+        role=_str(info.get("role")) or "unknown",
+        time_created=time.get("created"),
+        parts=parsed,
+        seq=seq,
+        model=model,
+        agent=info.get("agent") or info.get("mode"),
+        error=_error_text(info.get("error")),
+        tokens=tokens,
+        cost=cost if isinstance(cost, (int, float)) else None,
+    )
+
+
+def _v2_content_part(item: Any) -> Part | None:
+    if isinstance(item, str):
+        return Part(kind="text", text=item)
+    if not isinstance(item, dict):
+        return None
+    kind = item.get("type")
+    if kind in ("text", "reasoning") or (kind is None and "text" in item):
+        return Part(
+            kind=kind or "text",
+            text=_str(item.get("text")),
+            synthetic=bool(item.get("synthetic")),
+        )
+    is_tool = "tool" in item or (isinstance(kind, str) and kind.startswith("tool"))
+    if is_tool:
+        state = as_dict(item.get("state")) or item
+        output = state.get("output", state.get("result"))
+        if output is None and state.get("error") is not None:
+            output = state.get("error")
+        return Part(
+            kind="tool",
+            tool=_str(item.get("tool") or item.get("name")) or "tool",
+            tool_input=state.get("input", state.get("args")),
+            tool_output=None if output is None else _str(output),
+            status=state.get("status"),
+            title=state.get("title"),
+        )
+    return parse_v1_part(item)
+
+
+def parse_v2_row(
+    row_id: str,
+    row_type: str,
+    data_raw: Any,
+    seq: int | None,
+    time_created: int | None,
+) -> tuple[Message, bool]:
+    """Parse one 2.x ``session_message`` row.
+
+    Returns the message and whether its JSON payload parsed cleanly.
+    """
+    data = loads(data_raw)
+    ok = isinstance(data, dict)
+    data = data if isinstance(data, dict) else {}
+
+    parts: list[Part] = []
+    text = data.get("text")
+    if isinstance(text, str) and text:
+        parts.append(Part(kind="text", text=text, synthetic=row_type == "synthetic"))
+    for key in ("content", "parts"):
+        value = data.get(key)
+        if isinstance(value, str) and value:
+            parts.append(Part(kind="text", text=value))
+        elif isinstance(value, list):
+            parts.extend(p for p in map(_v2_content_part, value) if p is not None)
+    if "tool" in data and not parts:
+        tool_part = _v2_content_part(data)
+        if tool_part is not None:
+            parts.append(tool_part)
+    if not ok:
+        parts.append(Part(kind="other", text="[unparseable message payload]"))
+
+    model = format_model(data.get("model"))
+    if model is None and data.get("modelID"):
+        model = format_model(
+            {"id": data.get("modelID"), "providerID": data.get("providerID")}
+        )
+    tokens = as_dict(data.get("tokens")) or None
+    cost = data.get("cost")
+    message = Message(
+        id=row_id,
+        role=row_type or "unknown",
+        time_created=time_created,
+        parts=parts,
+        seq=seq,
+        model=model,
+        agent=data.get("agent"),
+        error=_error_text(data.get("error")),
+        tokens=tokens,
+        cost=cost if isinstance(cost, (int, float)) else None,
+    )
+    return message, ok

claude_opencode_sessions/render.py

@@ -0,0 +1,169 @@
+"""Plain-text / Markdown rendering helpers."""
+
+from __future__ import annotations
+
+import json
+import os
+import time
+from datetime import datetime
+
+from .models import Part, Session
+from .scope import Scope, normalize
+
+__all__ = [
+    "absolute_time",
+    "cell",
+    "display_dir",
+    "relative_time",
+    "render_list",
+    "tilde",
+    "tool_summary",
+    "truncate",
+]
+
+
+def _now_ms() -> int:
+    return int(time.time() * 1000)
+
+
+def relative_time(ms: int | None, now_ms: int | None = None) -> str:
+    if not ms:
+        return "?"
+    now_ms = now_ms if now_ms is not None else _now_ms()
+    delta = max(0, (now_ms - ms) // 1000)
+    if delta < 60:
+        return "just now"
+    for size, unit in ((86400, "d"), (3600, "h"), (60, "m")):
+        if delta >= size:
+            if unit == "d" and delta >= 30 * 86400:
+                return absolute_time(ms, date_only=True)
+            return f"{delta // size}{unit} ago"
+    return "just now"  # pragma: no cover
+
+
+def absolute_time(ms: int | None, date_only: bool = False) -> str:
+    if not ms:
+        return "?"
+    moment = datetime.fromtimestamp(ms / 1000)
+    return moment.strftime("%Y-%m-%d" if date_only else "%Y-%m-%d %H:%M")
+
+
+def truncate(text: str, limit: int) -> str:
+    if limit <= 0 or len(text) <= limit:
+        return text
+    return text[:limit].rstrip() + f"\n… [{len(text) - limit} more chars]"
+
+
+def cell(text: str, limit: int = 70) -> str:
+    text = " ".join(str(text).split())
+    if len(text) > limit:
+        text = text[: limit - 1] + "…"
+    return text.replace("|", "\\|")
+
+
+def tilde(path: str) -> str:
+    home = os.path.expanduser("~")
+    if path == home or path.startswith(home + os.sep):
+        return "~" + path[len(home) :]
+    return path
+
+
+def display_dir(directory: str, scope: Scope) -> str:
+    if not directory:
+        return "?"
+    path = normalize(directory)
+    if scope.mode != "all":
+        for root in scope.roots:
+            if path == root:
+                return "." if root == scope.root else tilde(root)
+            if path.startswith(root + os.sep):
+                rel = os.path.relpath(path, root)
+                return rel if root == scope.root else tilde(path)
+    return tilde(path)
+
+
+_INPUT_KEYS = (
+    "filePath",
+    "file_path",
+    "path",
+    "command",
+    "pattern",
+    "url",
+    "query",
+    "description",
+    "prompt",
+)
+
+
+def tool_summary(part: Part) -> str:
+    """One-line description of a tool call."""
+    name = part.tool or "tool"
+    args = part.tool_input
+    detail = ""
+    if isinstance(args, dict):
+        for key in _INPUT_KEYS:
+            value = args.get(key)
+            if isinstance(value, str) and value.strip():
+                lines = value.strip().splitlines()
+                detail = lines[0] + (" …" if len(lines) > 1 else "")
+                break
+        if not detail and args:
+            detail = json.dumps(args, ensure_ascii=False)
+    elif isinstance(args, str):
+        detail = args.strip().splitlines()[0] if args.strip() else ""
+    if not detail and part.title:
+        detail = part.title
+    detail = cell(detail, 120).replace("\\|", "|")
+    status = f" ({part.status})" if part.status and part.status != "completed" else ""
+    return f"→ {name}: `{detail}`{status}" if detail else f"→ {name}{status}"
+
+
+def render_list(
+    sessions: list[Session],
+    scope: Scope,
+    *,
+    hidden_archived: int = 0,
+    hidden_subagents: int = 0,
+    total: int | None = None,
+    backend: str = "",
+    notes: list[str] | None = None,
+    now_ms: int | None = None,
+) -> str:
+    lines = [f"opencode sessions — {scope.describe()}", ""]
+    if not sessions:
+        lines.append("No opencode sessions found in this scope.")
+        if scope.mode == "worktree":
+            lines.append("Try `--worktrees` (all worktrees) or `--all` (everything).")
+    else:
+        lines.append("| # | Title | Updated | Msgs | Agent · Model | Dir | ID |")
+        lines.append("|---|---|---|---|---|---|---|")
+        for index, s in enumerate(sessions, start=1):
+            flags = []
+            if s.is_archived:
+                flags.append("archived")
+            if s.is_subagent:
+                flags.append("sub-agent")
+            title = cell(s.title) + (f" _({', '.join(flags)})_" if flags else "")
+            agent = " · ".join(x for x in (s.agent, s.model) if x) or "?"
+            msgs = "?" if s.message_count is None else str(s.message_count)
+            where = cell(display_dir(s.directory, scope), 50)
+            lines.append(
+                f"| {index} | {title} | {relative_time(s.time_updated, now_ms)} | "
+                f"{msgs} | {cell(agent, 50)} | {where} | `{s.id}` |"
+            )
+    footer = []
+    if total is not None and total > len(sessions):
+        footer.append(f"showing {len(sessions)} of {total} (use -n to show more)")
+    hidden = []
+    if hidden_archived:
+        hidden.append(f"{hidden_archived} archived (--include-archived)")
+    if hidden_subagents:
+        hidden.append(f"{hidden_subagents} sub-agent (--include-subagents)")
+    if hidden:
+        footer.append("hidden: " + ", ".join(hidden))
+    if backend:
+        footer.append(f"backend: {backend}")
+    lines.append("")
+    lines.extend(f"_{line}_" for line in footer)
+    lines.extend(f"_note: {note}_" for note in notes or [])
+    return "\n".join(lines).rstrip() + "\n"

claude_opencode_sessions/scope.py

@@ -0,0 +1,160 @@
+"""Decide which sessions belong to "this repository".
+
+Mirrors Claude Code's ``/resume`` picker:
+
+* ``worktree`` (default): the current git worktree, i.e. its top-level
+  directory and everything below it. Outside git: the directory and below.
+* ``repo``: every worktree of the current repository (``Ctrl+W`` in
+  ``/resume``), plus sessions of the same opencode project whose worktree
+  directory no longer exists.
+* ``all``: every session on this machine (``Ctrl+A`` in ``/resume``).
+"""
+
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+import sys
+from collections.abc import Iterable
+from dataclasses import dataclass, field
+
+from .models import Session
+
+__all__ = [
+    "MODES",
+    "Scope",
+    "git_toplevel",
+    "git_worktrees",
+    "is_within",
+    "normalize",
+    "path_key",
+    "resolve_scope",
+]
+
+MODES = ("worktree", "repo", "all")
+_CASE_INSENSITIVE = sys.platform in ("darwin", "win32")
+
+
+def normalize(path: str) -> str:
+    """Absolute, symlink-resolved path without a trailing separator.
+
+    Also repairs directories stored without their leading ``/`` (a known
+    opencode migration bug).
+    """
+    if not path:
+        return ""
+    path = os.path.expanduser(path)
+    if not os.path.isabs(path) and os.sep == "/" and not path.startswith("."):
+        path = "/" + path
+    resolved = os.path.realpath(path)
+    if len(resolved) > 1:
+        resolved = resolved.rstrip(os.sep)
+    return resolved
+
+
+def path_key(path: str) -> str:
+    """Comparison key for a normalised path (case-folded on macOS/Windows)."""
+    return path.casefold() if _CASE_INSENSITIVE else path
+
+
+def is_within(child: str, parent: str) -> bool:
+    """True when ``child`` equals ``parent`` or lives below it (keys)."""
+    if child == parent:
+        return True
+    prefix = parent if parent.endswith(os.sep) else parent + os.sep
+    return child.startswith(prefix)
+
+
+def _git(args: list[str], cwd: str) -> str | None:
+    git = shutil.which("git")
+    if not git or not os.path.isdir(cwd):
+        return None
+    try:
+        result = subprocess.run(
+            [git, "-C", cwd, *args],
+            capture_output=True,
+            text=True,
+            timeout=10,
+            check=False,
+        )
+    except (OSError, subprocess.SubprocessError):
+        return None
+    return result.stdout if result.returncode == 0 else None
+
+
+def git_toplevel(path: str) -> str | None:
+    out = _git(["rev-parse", "--show-toplevel"], path)
+    return normalize(out.strip()) if out and out.strip() else None
+
+
+def git_worktrees(path: str) -> list[str]:
+    out = _git(["worktree", "list", "--porcelain"], path)
+    if not out:
+        return []
+    return [
+        normalize(line[len("worktree ") :])
+        for line in out.splitlines()
+        if line.startswith("worktree ")
+    ]
+
+
+@dataclass
+class Scope:
+    mode: str
+    cwd: str
+    roots: list[str] = field(default_factory=list)
+    in_git: bool = False
+
+    @property
+    def root(self) -> str:
+        return self.roots[0] if self.roots else self.cwd
+
+    def describe(self) -> str:
+        if self.mode == "all":
+            return "all sessions on this machine"
+        if self.mode == "repo":
+            count = len(self.roots)
+            return f"all worktrees of {self.root} ({count} worktree(s))"
+        kind = "git worktree" if self.in_git else "directory"
+        return f"{kind} {self.root}"
+
+    def matches(self, directory: str) -> bool:
+        if self.mode == "all":
+            return True
+        key = path_key(normalize(directory))
+        return any(is_within(key, path_key(root)) for root in self.roots)
+
+    def filter(self, sessions: Iterable[Session]) -> list[Session]:
+        sessions = list(sessions)
+        if self.mode == "all":
+            return sessions
+        selected = [s for s in sessions if self.matches(s.directory)]
+        if self.mode == "repo":
+            projects = {s.project_id for s in selected if s.project_id} - {"global"}
+            chosen = {s.id for s in selected}
+            selected.extend(
+                s
+                for s in sessions
+                if s.id not in chosen
+                and s.project_id in projects
+                and not os.path.isdir(normalize(s.directory))
+            )
+        return selected
+
+
+def resolve_scope(path: str | None = None, mode: str = "worktree") -> Scope:
+    if mode not in MODES:
+        raise ValueError(f"unknown scope {mode!r}; expected one of {MODES}")
+    cwd = normalize(path or os.getcwd())
+    top = git_toplevel(cwd)
+    if mode == "all":
+        return Scope(mode, cwd, [top or cwd], in_git=bool(top))
+    if top is None:
+        return Scope(mode, cwd, [cwd], in_git=False)
+    if mode == "repo":
+        roots = git_worktrees(top) or [top]
+        if top in roots:
+            roots.remove(top)
+        return Scope(mode, cwd, [top, *roots], in_git=True)
+    return Scope(mode, cwd, [top], in_git=True)

claude_opencode_sessions/service.py

@@ -0,0 +1,149 @@
+"""Glue between backends, scoping and the CLI."""
+
+from __future__ import annotations
+
+import sqlite3
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from .cli_backend import CliBackend
+from .errors import (
+    BackendError,
+    OpencodeSessionsError,
+)
+from .locate import find_db
+from .models import Message, Session
+from .scope import Scope
+from .sqlite_backend import SqliteBackend
+
+__all__ = [
+    "BACKENDS",
+    "PARSE_ERROR_THRESHOLD",
+    "Context",
+    "Listing",
+    "open_context",
+]
+
+BACKENDS = ("auto", "sqlite", "cli")
+PARSE_ERROR_THRESHOLD = 0.2
+
+
+@dataclass
+class Listing:
+    shown: list[Session]
+    hidden_archived: int = 0
+    hidden_subagents: int = 0
+
+
+@dataclass
+class Context:
+    """An opened data source plus notes about how it was chosen."""
+
+    mode: str
+    sqlite: SqliteBackend | None = None
+    cli: CliBackend | None = None
+    notes: list[str] = field(default_factory=list)
+    _cli_tried: bool = False
+
+    @property
+    def backend_name(self) -> str:
+        return "sqlite" if self.sqlite else "cli"
+
+    def describe(self) -> str:
+        if self.sqlite:
+            return f"sqlite ({self.sqlite.describe()}) · db: {_tilde(self.sqlite.path)}"
+        assert self.cli is not None
+        return f"cli ({self.cli.describe()})"
+
+    def get_cli(self) -> CliBackend | None:
+        if self.cli is None and not self._cli_tried and self.mode != "sqlite":
+            self._cli_tried = True
+            try:
+                self.cli = CliBackend()
+            except OpencodeSessionsError as exc:
+                self.notes.append(f"cli unavailable: {exc}")
+        return self.cli
+
+    # -- sessions ---------------------------------------------------------
+
+    def all_sessions(self, cwd: str | None = None) -> list[Session]:
+        if self.sqlite:
+            sessions = self.sqlite.list_sessions()
+        else:
+            assert self.cli is not None
+            sessions = self.cli.list_sessions(cwd=cwd)
+        sessions.sort(key=lambda s: s.time_updated or 0, reverse=True)
+        return sessions
+
+    def listing(
+        self,
+        scope: Scope,
+        include_archived: bool = False,
+        include_subagents: bool = False,
+    ) -> Listing:
+        scoped = scope.filter(self.all_sessions(cwd=scope.cwd))
+        result = Listing(shown=[])
+        for session in scoped:
+            if session.is_archived and not include_archived:
+                result.hidden_archived += 1
+            elif session.is_subagent and not include_subagents:
+                result.hidden_subagents += 1
+            else:
+                result.shown.append(session)
+        return result
+
+    # -- messages ---------------------------------------------------------
+
+    def messages(self, session: Session) -> list[Message]:
+        if self.sqlite:
+            try:
+                messages, errors = self.sqlite.load_messages(session.id)
+            except sqlite3.Error as exc:
+                messages, errors = [], -1
+                self.notes.append(f"sqlite read failed: {exc}")
+            broken = errors < 0 or (
+                messages and errors / max(len(messages), 1) > PARSE_ERROR_THRESHOLD
+            )
+            if not broken:
+                return messages
+            cli = self.get_cli()
+            if cli is None:
+                if errors < 0:
+                    raise BackendError("could not read messages; no fallback")
+                self.notes.append(f"{errors} message(s) could not be parsed")
+                return messages
+            self.notes.append("fell back to `opencode export` for this session")
+            return cli.load_messages(session.id)[0]
+        assert self.cli is not None
+        return self.cli.load_messages(session.id)[0]
+
+
+def _tilde(path: Path) -> str:
+    try:
+        return "~/" + str(path.resolve().relative_to(Path.home().resolve()))
+    except ValueError:
+        return str(path)
+
+
+def open_context(backend: str = "auto", db: str | None = None) -> Context:
+    """Open the requested backend (``auto`` = sqlite, falling back to cli)."""
+    if backend not in BACKENDS:
+        raise ValueError(f"unknown backend {backend!r}")
+    ctx = Context(mode=backend)
+    if backend in ("auto", "sqlite"):
+        try:
+            ctx.sqlite = SqliteBackend(find_db(db))
+            return ctx
+        except (OpencodeSessionsError, sqlite3.Error) as exc:
+            if backend == "sqlite":
+                raise
+            ctx.notes.append(f"sqlite unavailable: {exc}")
+    try:
+        ctx.cli = CliBackend()
+    except OpencodeSessionsError as exc:
+        ctx.notes.append(f"cli unavailable: {exc}")
+        raise BackendError("; ".join(ctx.notes)) from exc
+    ctx._cli_tried = True
+    if backend == "auto":
+        ctx.notes.append("using the opencode CLI fallback")
+    return ctx