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

claude_opencode_sessions/__init__.py

@@ -0,0 +1,10 @@
+"""Import opencode sessions into Claude Code, scoped to the current repository."""
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("claude-opencode-sessions")
+except PackageNotFoundError:  # running from a source checkout, e.g. as the plugin
+    __version__ = "0+source"
+
+__all__ = ["__version__"]

claude_opencode_sessions/__main__.py

@@ -0,0 +1,3 @@
+from claude_opencode_sessions.cli import main
+
+raise SystemExit(main())

claude_opencode_sessions/cli.py

@@ -0,0 +1,196 @@
+"""Command line interface: ``claude-opencode-sessions``."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import platform
+import shutil
+import sqlite3
+import sys
+from collections.abc import Sequence
+
+from . import __version__
+from .errors import OpencodeSessionsError
+from .import_command import add_import_arguments, cmd_hook, cmd_import
+from .locate import candidate_paths, find_db
+from .render import render_list
+from .scope import Scope, resolve_scope
+from .service import BACKENDS, Context, open_context
+
+__all__ = ["build_parser", "main"]
+
+PROG = "claude-opencode-sessions"
+
+
+def _add_common(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument(
+        "--path",
+        help="directory to scope to (default: current directory)",
+    )
+    group = parser.add_mutually_exclusive_group()
+    group.add_argument(
+        "--worktrees",
+        dest="scope",
+        action="store_const",
+        const="repo",
+        help="include every worktree of the current git repository",
+    )
+    group.add_argument(
+        "--all",
+        dest="scope",
+        action="store_const",
+        const="all",
+        help="include sessions from every directory",
+    )
+    parser.set_defaults(scope="worktree")
+    parser.add_argument(
+        "--include-archived", action="store_true", help="show archived sessions"
+    )
+    parser.add_argument(
+        "--include-subagents", action="store_true", help="show sub-agent sessions"
+    )
+    parser.add_argument("--format", choices=("md", "json"), default="md")
+    parser.add_argument("--backend", choices=BACKENDS, default="auto")
+    parser.add_argument("--db", help="path to opencode.db (default: auto-detect)")
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog=PROG,
+        description=(
+            "Import opencode sessions for the current repository into Claude "
+            "Code (so they open with /resume), or list them. Scoping mirrors "
+            "Claude Code's /resume: current worktree by default, --worktrees "
+            "for all worktrees."
+        ),
+    )
+    parser.add_argument(
+        "--version", action="version", version=f"%(prog)s {__version__}"
+    )
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    p_list = sub.add_parser("list", help="list sessions in scope, newest first")
+    _add_common(p_list)
+    p_list.add_argument(
+        "-n", "--limit", type=int, default=20, help="max rows (0 = all)"
+    )
+
+    p_import = sub.add_parser(
+        "import",
+        help="import sessions into Claude Code (they then show up in /resume)",
+    )
+    add_import_arguments(p_import)
+
+    sub.add_parser(
+        "hook",
+        help="Claude Code UserPromptExpansion hook (reads the event from stdin)",
+    )
+
+    p_doctor = sub.add_parser("doctor", help="diagnose environment and database")
+    p_doctor.add_argument("--path")
+    p_doctor.add_argument("--db")
+    return parser
+
+
+def _emit(text: str) -> None:
+    sys.stdout.write(text)
+    sys.stdout.flush()
+
+
+def _scope(args: argparse.Namespace) -> Scope:
+    return resolve_scope(args.path, args.scope)
+
+
+def cmd_list(args: argparse.Namespace, ctx: Context) -> int:
+    scope = _scope(args)
+    listing = ctx.listing(scope, args.include_archived, args.include_subagents)
+    shown = listing.shown[: args.limit] if args.limit > 0 else listing.shown
+    if args.format == "json":
+        payload = {
+            "scope": {"mode": scope.mode, "roots": scope.roots, "cwd": scope.cwd},
+            "backend": ctx.backend_name,
+            "total": len(listing.shown),
+            "hidden_archived": listing.hidden_archived,
+            "hidden_subagents": listing.hidden_subagents,
+            "sessions": [
+                {"index": i, **s.to_dict()} for i, s in enumerate(shown, start=1)
+            ],
+            "notes": ctx.notes,
+        }
+        _emit(json.dumps(payload, indent=2, ensure_ascii=False) + "\n")
+        return 0
+    _emit(
+        render_list(
+            shown,
+            scope,
+            hidden_archived=listing.hidden_archived,
+            hidden_subagents=listing.hidden_subagents,
+            total=len(listing.shown),
+            backend=ctx.describe(),
+            notes=ctx.notes,
+        )
+    )
+    return 0
+
+
+def cmd_doctor(args: argparse.Namespace) -> int:
+    lines = [
+        f"{PROG} {__version__}",
+        f"python: {sys.version.split()[0]} ({sys.executable})",
+        f"platform: {platform.platform()}",
+    ]
+    opencode = shutil.which("opencode")
+    lines.append(f"opencode on PATH: {opencode or 'no'}")
+    lines.append("db candidates: " + ", ".join(str(p) for p in candidate_paths()))
+    status = 0
+    try:
+        db = find_db(args.db)
+        lines.append(f"db: {db} ({db.stat().st_size:,} bytes)")
+        from .sqlite_backend import SqliteBackend
+
+        backend = SqliteBackend(db)
+        lines.append(f"layout: {backend.describe()}")
+        for table, count in backend.table_report().items():
+            lines.append(f"  {table}: {count:,} rows")
+        sessions = backend.list_sessions()
+        lines.append(f"sessions readable: {len(sessions)}")
+        backend.close()
+    except (OpencodeSessionsError, sqlite3.Error) as exc:
+        lines.append(f"db: NOT USABLE — {exc}")
+        status = 3
+    try:
+        for mode in ("worktree", "repo"):
+            scope = resolve_scope(args.path, mode)
+            lines.append(f"scope {mode}: {scope.describe()} roots={scope.roots}")
+    except OSError as exc:  # pragma: no cover
+        lines.append(f"scope: error — {exc}")
+    lines.append(f"cwd: {os.getcwd()}")
+    _emit("\n".join(lines) + "\n")
+    return status
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    if hasattr(sys.stdout, "reconfigure"):
+        sys.stdout.reconfigure(errors="replace")
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    try:
+        if args.command == "doctor":
+            return cmd_doctor(args)
+        if args.command == "hook":
+            return cmd_hook(args)
+        if args.command == "import":
+            return cmd_import(args)
+        ctx = open_context(args.backend, args.db)
+        return cmd_list(args, ctx)
+    except OpencodeSessionsError as exc:
+        print(f"{PROG}: {exc}", file=sys.stderr)
+        return exc.exit_code
+    except BrokenPipeError:  # pragma: no cover
+        return 0
+
+
+if __name__ == "__main__":  # pragma: no cover
+    raise SystemExit(main())

claude_opencode_sessions/cli_backend.py

@@ -0,0 +1,140 @@
+"""Fallback backend that shells out to the ``opencode`` CLI.
+
+Used when the database can't be read directly (missing, locked, or a schema
+this package doesn't recognise):
+
+* ``opencode session list --format json`` for listing,
+* ``opencode export <id>`` for transcripts.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import shutil
+import subprocess
+from typing import Any
+
+from .errors import BackendError, NotFoundError
+from .models import Message, Session, format_model
+from .parse import as_dict, as_list, parse_v1_message
+
+__all__ = ["MIN_VERSION", "CliBackend", "parse_version"]
+
+MIN_VERSION = (1, 2)
+
+
+def parse_version(text: str) -> tuple[int, ...] | None:
+    match = re.search(r"(\d+)\.(\d+)(?:\.(\d+))?", text)
+    if not match:
+        return None
+    return tuple(int(g) for g in match.groups() if g is not None)
+
+
+def _extract_json(text: str) -> Any:
+    """Parse the first JSON document in ``text`` (skipping log lines)."""
+    decoder = json.JSONDecoder()
+    for index, char in enumerate(text):
+        if char in "[{":
+            try:
+                value, _ = decoder.raw_decode(text[index:])
+            except ValueError:
+                continue
+            return value
+    raise BackendError("opencode CLI did not return JSON")
+
+
+def _get(obj: dict[str, Any], *keys: str) -> Any:
+    for key in keys:
+        if key in obj and obj[key] is not None:
+            return obj[key]
+    return None
+
+
+def session_from_info(info: dict[str, Any]) -> Session:
+    time = as_dict(info.get("time"))
+    return Session(
+        id=str(info.get("id", "")),
+        title=str(info.get("title") or "(untitled)"),
+        directory=str(_get(info, "directory", "cwd", "path") or ""),
+        project_id=_get(info, "projectID", "project_id"),
+        parent_id=_get(info, "parentID", "parent_id"),
+        time_created=_get(time, "created") or _get(info, "time_created", "created"),
+        time_updated=_get(time, "updated") or _get(info, "time_updated", "updated"),
+        time_archived=_get(time, "archived") or _get(info, "time_archived"),
+        agent=info.get("agent"),
+        model=format_model(info.get("model")),
+        version=info.get("version"),
+        origin="cli",
+    )
+
+
+class CliBackend:
+    name = "cli"
+
+    def __init__(self, executable: str = "opencode", timeout: float = 120) -> None:
+        exe = shutil.which(executable)
+        if not exe:
+            raise BackendError(f"`{executable}` not found on PATH")
+        self.exe = exe
+        self.timeout = timeout
+        version_text = self._run(["--version"]).strip()
+        self.version = parse_version(version_text)
+        if self.version is None or self.version[:2] < MIN_VERSION:
+            raise BackendError(
+                f"opencode {version_text or '?'} is too old; "
+                f"need >= {'.'.join(map(str, MIN_VERSION))}"
+            )
+
+    def _run(self, args: list[str], cwd: str | None = None) -> str:
+        try:
+            result = subprocess.run(
+                [self.exe, *args],
+                capture_output=True,
+                text=True,
+                timeout=self.timeout,
+                cwd=cwd,
+                check=False,
+            )
+        except (OSError, subprocess.SubprocessError) as exc:
+            raise BackendError(f"opencode {' '.join(args)} failed: {exc}") from exc
+        if result.returncode != 0:
+            detail = (result.stderr or result.stdout).strip().splitlines()
+            raise BackendError(
+                f"opencode {' '.join(args)} exited {result.returncode}: "
+                f"{detail[-1] if detail else ''}"
+            )
+        return result.stdout
+
+    def describe(self) -> str:
+        return f"opencode CLI {'.'.join(map(str, self.version or ()))}"
+
+    def list_sessions(self, cwd: str | None = None) -> list[Session]:
+        workdir = cwd if cwd and os.path.isdir(cwd) else None
+        data = _extract_json(
+            self._run(["session", "list", "--format", "json"], cwd=workdir)
+        )
+        if isinstance(data, dict):
+            data = data.get("sessions") or data.get("data") or []
+        if not isinstance(data, list):
+            raise BackendError("unexpected `opencode session list` output")
+        return [session_from_info(item) for item in data if isinstance(item, dict)]
+
+    def export(self, session_id: str) -> tuple[Session | None, list[Message]]:
+        data = _extract_json(self._run(["export", session_id]))
+        if not isinstance(data, dict):
+            raise NotFoundError(f"opencode export {session_id}: unexpected output")
+        info = data.get("info")
+        session = session_from_info(info) if isinstance(info, dict) else None
+        messages: list[Message] = []
+        for index, item in enumerate(data.get("messages") or [], start=1):
+            if not isinstance(item, dict):
+                continue
+            parts = as_list(item.get("parts"))
+            messages.append(parse_v1_message(item.get("info"), parts, index))
+        return session, messages
+
+    def load_messages(self, session_id: str) -> tuple[list[Message], int]:
+        _, messages = self.export(session_id)
+        return messages, 0

claude_opencode_sessions/errors.py

@@ -0,0 +1,39 @@
+"""Exceptions shared by the backends and the CLI."""
+
+__all__ = [
+    "BackendError",
+    "DatabaseNotFoundError",
+    "NotFoundError",
+    "OpencodeSessionsError",
+    "SchemaError",
+]
+
+
+class OpencodeSessionsError(Exception):
+    """Base class; ``exit_code`` is used by the CLI."""
+
+    exit_code = 1
+
+
+class NotFoundError(OpencodeSessionsError):
+    """A session reference did not match anything."""
+
+    exit_code = 2
+
+
+class DatabaseNotFoundError(OpencodeSessionsError):
+    """No opencode database could be located."""
+
+    exit_code = 3
+
+
+class SchemaError(OpencodeSessionsError):
+    """The database exists but does not look like a supported opencode DB."""
+
+    exit_code = 3
+
+
+class BackendError(OpencodeSessionsError):
+    """No backend could serve the request."""
+
+    exit_code = 4

claude_opencode_sessions/import_command.py

@@ -0,0 +1,216 @@
+"""``import`` command and the Claude Code ``UserPromptExpansion`` hook."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import shlex
+import sqlite3
+import sys
+from collections import Counter
+from collections.abc import Sequence
+from pathlib import Path
+from typing import Any
+
+from .errors import OpencodeSessionsError
+from .importer import (
+    ImportResult,
+    claude_project_dir,
+    existing_imports,
+    import_session,
+)
+from .render import cell, tilde
+from .scope import Scope, resolve_scope
+from .service import Context, open_context
+
+__all__ = ["add_import_arguments", "hook_main", "render_report", "run_import"]
+
+COMMAND_NAMES = {"import", "opencode-sessions:import"}
+
+
+def add_import_arguments(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument("--path", help="project directory (default: current directory)")
+    parser.add_argument(
+        "--worktrees",
+        action="store_true",
+        help="include sessions from every worktree of the repository",
+    )
+    parser.add_argument(
+        "--dry-run", action="store_true", help="show what would be imported"
+    )
+    parser.add_argument(
+        "--with-tool-output",
+        action="store_true",
+        help="include (truncated) tool output in the imported conversation",
+    )
+    parser.add_argument("--include-archived", action="store_true")
+    parser.add_argument("--include-subagents", action="store_true")
+    parser.add_argument(
+        "--claude-project-dir",
+        help="Claude Code transcript directory to import into "
+        "(default: derived from the project path)",
+    )
+    parser.add_argument("--backend", choices=("auto", "sqlite", "cli"), default="auto")
+    parser.add_argument("--db", help="path to opencode.db (default: auto-detect)")
+
+
+def run_import(
+    ctx: Context,
+    scope: Scope,
+    *,
+    project_dir: Path,
+    cwd: str,
+    dry_run: bool = False,
+    with_tool_output: bool = False,
+    include_archived: bool = False,
+    include_subagents: bool = False,
+) -> tuple[list[ImportResult], dict[str, int]]:
+    listing = ctx.listing(scope, include_archived, include_subagents)
+    existing = existing_imports(project_dir)
+    results = []
+    for session in reversed(listing.shown):  # oldest first
+        messages = ctx.messages(session)
+        results.append(
+            import_session(
+                session,
+                messages,
+                project_dir=project_dir,
+                cwd=cwd,
+                existing=existing,
+                with_tool_output=with_tool_output,
+                dry_run=dry_run,
+            )
+        )
+    hidden = {
+        "archived": listing.hidden_archived,
+        "sub-agent": listing.hidden_subagents,
+    }
+    return results, hidden
+
+
+def render_report(
+    results: list[ImportResult],
+    hidden: dict[str, int],
+    scope: Scope,
+    project_dir: Path,
+    notes: Sequence[str] = (),
+) -> str:
+    lines = [
+        f"opencode → Claude Code import · {scope.describe()}",
+        f"into {tilde(str(project_dir))}",
+        "",
+    ]
+    if not results:
+        lines.append("No opencode sessions found for this project.")
+    for result in reversed(results):  # newest first, like /resume
+        label = result.title or f"[opencode] {result.session.title}"
+        if result.status == "empty":
+            label += " (no conversation text)"
+        lines.append(f"  {result.status:<12} {cell(label, 80)}")
+    counts = Counter(r.status for r in results)
+    order = ("imported", "would-import", "unchanged", "empty")
+    summary = ", ".join(f"{counts[k]} {k}" for k in order if counts.get(k))
+    extra = ", ".join(f"{n} {kind}" for kind, n in hidden.items() if n)
+    lines.append("")
+    if summary:
+        lines.append(summary + (f" · skipped: {extra}" if extra else ""))
+    lines.extend(f"note: {note}" for note in notes)
+    if counts.get("imported"):
+        lines.append('Open them with /resume — titles start with "[opencode]".')
+    elif counts.get("would-import"):
+        lines.append("Dry run: nothing was written.")
+    return "\n".join(lines) + "\n"
+
+
+def cmd_import(args: argparse.Namespace) -> int:
+    ctx = open_context(args.backend, args.db)
+    scope = resolve_scope(args.path, "repo" if args.worktrees else "worktree")
+    cwd = scope.cwd
+    project_dir = claude_project_dir(cwd, explicit=args.claude_project_dir)
+    results, hidden = run_import(
+        ctx,
+        scope,
+        project_dir=project_dir,
+        cwd=cwd,
+        dry_run=args.dry_run,
+        with_tool_output=args.with_tool_output,
+        include_archived=args.include_archived,
+        include_subagents=args.include_subagents,
+    )
+    sys.stdout.write(render_report(results, hidden, scope, project_dir, ctx.notes))
+    return 0
+
+
+def _hook_argv(data: dict[str, Any]) -> list[str]:
+    raw: Any = data.get("command_args")
+    if raw is None:
+        raw = data.get("command_input")
+    if isinstance(raw, dict):
+        raw = " ".join(str(v) for v in raw.values() if isinstance(v, (str, int)))
+    if not isinstance(raw, str):
+        return []
+    try:
+        return shlex.split(raw)
+    except ValueError:
+        return raw.split()
+
+
+def hook_main(stdin: str) -> str | None:
+    """Handle a ``UserPromptExpansion`` event; return the JSON to print.
+
+    Returns ``None`` for commands that aren't ours (the hook then stays
+    silent and Claude Code proceeds normally).
+    """
+    try:
+        data = json.loads(stdin)
+    except ValueError:
+        return None
+    if not isinstance(data, dict):
+        return None
+    if str(data.get("command_name", "")) not in COMMAND_NAMES:
+        return None
+    parser = argparse.ArgumentParser(prog="/opencode-sessions:import", add_help=False)
+    add_import_arguments(parser)
+    try:
+        args = parser.parse_args(_hook_argv(data))
+    except SystemExit:
+        reason = "Usage: " + parser.format_usage().replace("usage: ", "")
+        return json.dumps({"decision": "block", "reason": reason})
+    cwd = (
+        args.path
+        or os.environ.get("CLAUDE_PROJECT_DIR")
+        or str(data.get("cwd") or "")
+        or os.getcwd()
+    )
+    try:
+        ctx = open_context(args.backend, args.db)
+        scope = resolve_scope(cwd, "repo" if args.worktrees else "worktree")
+        project_dir = claude_project_dir(
+            cwd,
+            transcript_path=None
+            if args.claude_project_dir
+            else data.get("transcript_path"),
+            explicit=args.claude_project_dir,
+        )
+        results, hidden = run_import(
+            ctx,
+            scope,
+            project_dir=project_dir,
+            cwd=cwd,
+            dry_run=args.dry_run,
+            with_tool_output=args.with_tool_output,
+            include_archived=args.include_archived,
+            include_subagents=args.include_subagents,
+        )
+        reason = render_report(results, hidden, scope, project_dir, ctx.notes)
+    except (OpencodeSessionsError, sqlite3.Error, OSError) as exc:
+        reason = f"opencode import failed: {exc}"
+    return json.dumps({"decision": "block", "reason": reason.rstrip()})
+
+
+def cmd_hook(_args: argparse.Namespace) -> int:
+    output = hook_main(sys.stdin.read())
+    if output is not None:
+        sys.stdout.write(output + "\n")
+    return 0