oh-my-opencode 4.13.0 → 4.14.0

package/packages/omo-codex/plugin/skills/coding-agent-sessions/scripts/agent_sessions/opencode.py

@@ -0,0 +1,289 @@
+from __future__ import annotations
+
+import shutil
+import sqlite3
+import subprocess
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
+from typing import TypeAlias
+
+from .jsonio import as_map, int_value, parse_json_text, read_json, text
+from .timeparse import unix_millis
+from .transcript import env_path, existing
+from .types import JsonMap, Session
+
+MAX_OPENCODE_SESSIONS = 50000
+MAX_OPENCODE_CLI_SESSIONS = 100
+OPENCODE_TIMEOUT_SECONDS = 8
+SESSION_SQL = (
+    "select id, title, directory, time_created, time_updated, cost, tokens_input, tokens_output, "
+    "tokens_reasoning, tokens_cache_read, tokens_cache_write, model, parent_id, agent "
+    "from session where time_archived is null "
+    f"order by time_updated desc limit {MAX_OPENCODE_SESSIONS}"
+)
+LEGACY_SESSION_SQL = (
+    "select id, title, directory, time_created, time_updated, cost, tokens_input, tokens_output, "
+    "tokens_reasoning, tokens_cache_read, tokens_cache_write, model "
+    "from session where time_archived is null "
+    "order by time_updated desc limit 2000"
+)
+SqlValue: TypeAlias = str | int | float | bytes | None
+OpenCodeRow: TypeAlias = tuple[SqlValue, ...]
+
+
+def scan_opencode(extra_roots: tuple[Path, ...], workers: int) -> list[Session]:
+    if not extra_roots:
+        sessions = _db_sessions()
+        if sessions:
+            return sessions
+        sessions = _cli_sessions()
+        if sessions:
+            return sessions
+    appdata = env_path("APPDATA")
+    roots = existing([
+        *(path for path in (env_path("OPENCODE_HOME"),) if path is not None),
+        Path.home() / ".opencode",
+        Path.home() / ".local" / "share" / "opencode",
+        *(path / "opencode" for path in (appdata,) if path is not None),
+        *extra_roots,
+    ])
+    message_dirs = [message_dir for root in roots for message_dir in (root / "messages").glob("ses_*")]
+    sessions: list[Session] = []
+    if message_dirs:
+        with ThreadPoolExecutor(max_workers=min(workers, len(message_dirs))) as pool:
+            futures = [pool.submit(_file_session, message_dir.parents[1], message_dir) for message_dir in message_dirs]
+            for future in as_completed(futures):
+                session = future.result()
+                if session is not None:
+                    sessions.append(session)
+    sessions.extend(_storage_sessions(roots))
+    return sessions
+
+
+def _storage_sessions(roots: list[Path]) -> list[Session]:
+    sessions: list[Session] = []
+    for root in roots:
+        for path in (root / "storage" / "session").glob("*/ses_*.json"):
+            info = as_map(read_json(path))
+            if info is None:
+                continue
+            time_info = as_map(info.get("time")) or {}
+            sessions.append(
+                Session(
+                    "opencode",
+                    text(info.get("id")) or path.stem,
+                    str(path),
+                    text(info.get("directory")),
+                    unix_millis(int_value(time_info.get("created"))),
+                    unix_millis(int_value(time_info.get("updated"))),
+                    None,
+                    None,
+                    text(info.get("title")) or "",
+                    {},
+                    text(info.get("parentID")),
+                    text(info.get("agent")),
+                )
+            )
+    return sessions
+
+
+def _db_sessions() -> list[Session]:
+    path = _db_path()
+    if path is None:
+        return []
+    conn: sqlite3.Connection | None = None
+    try:
+        conn = sqlite3.connect(str(path), timeout=3)
+        rows: list[OpenCodeRow] = _session_rows(conn)
+    except sqlite3.Error:
+        return []
+    finally:
+        if conn is not None:
+            conn.close()
+    return [_db_session(row) for row in rows]
+
+
+def _session_rows(conn: sqlite3.Connection) -> list[OpenCodeRow]:
+    try:
+        return conn.execute(SESSION_SQL).fetchall()
+    except sqlite3.Error:
+        return conn.execute(LEGACY_SESSION_SQL).fetchall()
+
+
+def _db_path() -> Path | None:
+    data = _opencode_text(["db", "path"])
+    candidates = [Path(data.strip()).expanduser()] if data else []
+    appdata = env_path("APPDATA")
+    candidates.extend([Path.home() / ".local" / "share" / "opencode" / "opencode.db"])
+    candidates.extend(path / "opencode" / "opencode.db" for path in (appdata,) if path is not None)
+    for path in candidates:
+        if str(path) and path.exists():
+            return path
+    return None
+
+
+def _db_session(row: OpenCodeRow) -> Session:
+    session_id = _row_text(row, 0) or ""
+    title = _row_text(row, 1) or ""
+    model = as_map(parse_json_text(_row_text(row, 11) or ""))
+    return Session(
+        "opencode",
+        session_id,
+        f"opencode://{session_id}",
+        _row_text(row, 2),
+        unix_millis(_row_int(row, 3)),
+        unix_millis(_row_int(row, 4)),
+        text(model.get("providerID")) if model is not None else None,
+        text(model.get("id")) if model is not None else None,
+        title,
+        _db_usage(row),
+        _row_text(row, 12),
+        _row_text(row, 13),
+    )
+
+
+def _db_usage(row: OpenCodeRow) -> JsonMap:
+    usage: JsonMap = {}
+    for index, key in ((5, "cost_total"), (6, "input"), (7, "output"), (8, "reasoning"), (9, "cacheRead"), (10, "cacheWrite")):
+        value = _row_number(row, index)
+        if value is not None:
+            usage[key] = value
+    return usage
+
+
+def _row_text(row: OpenCodeRow, index: int) -> str | None:
+    value = row[index] if index < len(row) else None
+    return value if isinstance(value, str) else None
+
+
+def _row_number(row: OpenCodeRow, index: int) -> int | float | None:
+    value = row[index] if index < len(row) else None
+    return value if isinstance(value, int | float) else None
+
+
+def _row_int(row: OpenCodeRow, index: int) -> int | None:
+    value = row[index] if index < len(row) else None
+    return value if isinstance(value, int) else None
+
+
+def _cli_sessions() -> list[Session]:
+    data = _opencode_json(["session", "list", "--format", "json", "--max-count", str(MAX_OPENCODE_CLI_SESSIONS)])
+    if not isinstance(data, list):
+        return []
+    return [_cli_session(item) for item in data]
+
+
+def _cli_session(item: JsonMap) -> Session:
+    session_id = text(item.get("id")) or ""
+    title = text(item.get("title")) or ""
+    usage = _usage(item)
+    return Session(
+        "opencode",
+        session_id,
+        f"opencode://{session_id}",
+        text(item.get("directory")),
+        unix_millis(int_value(item.get("created"))),
+        unix_millis(int_value(item.get("updated"))),
+        None,
+        None,
+        title,
+        usage,
+    )
+
+
+def _opencode_json(args: list[str]) -> JsonMap | list[JsonMap] | None:
+    data = _opencode_text(args)
+    return _json_result(data) if data is not None else None
+
+
+def _opencode_text(args: list[str]) -> str | None:
+    binary = shutil.which("opencode")
+    if binary is None:
+        return None
+    try:
+        proc = subprocess.run(
+            [binary, *args],
+            check=False,
+            capture_output=True,
+            text=True,
+            timeout=OPENCODE_TIMEOUT_SECONDS,
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        return None
+    if proc.returncode != 0:
+        return None
+    return proc.stdout
+
+
+def _json_result(value: str) -> JsonMap | list[JsonMap] | None:
+    data = parse_json_text(value)
+    if isinstance(data, dict):
+        return data
+    if isinstance(data, list):
+        rows = [item for item in data if isinstance(item, dict)]
+        return rows
+    return None
+
+
+def _usage(item: JsonMap) -> JsonMap:
+    usage: JsonMap = {}
+    cost = item.get("cost")
+    tokens = as_map(item.get("tokens"))
+    if isinstance(cost, int | float):
+        usage["cost_total"] = cost
+    if tokens is not None:
+        for key in ("input", "output", "reasoning", "cacheRead", "cacheWrite"):
+            value = tokens.get(key)
+            if isinstance(value, int | float):
+                usage[key] = value
+    return usage
+
+
+def _file_session(root: Path, message_dir: Path) -> Session | None:
+    messages = sorted(message_dir.glob("*.json"), key=lambda item: item.name)
+    first = as_map(read_json(messages[0])) if messages else None
+    if first is None:
+        return None
+    session_id = text(first.get("sessionID")) or message_dir.name
+    model = as_map(first.get("model")) or {}
+    path_info = as_map(first.get("path")) or {}
+    stamps = [_message_millis(path) for path in messages]
+    known = [stamp for stamp in stamps if stamp is not None]
+    first_prompt, last_prompt = _prompt_edges(root, session_id, messages)
+    return Session(
+        "opencode",
+        session_id,
+        str(message_dir),
+        text(path_info.get("cwd")),
+        unix_millis(min(known) if known else None),
+        unix_millis(max(known) if known else None),
+        text(model.get("providerID")),
+        text(model.get("modelID")),
+        first_prompt,
+        {"message_count": len(messages)},
+        last_user_message=last_prompt,
+    )
+
+
+def _prompt_edges(root: Path, session_id: str, messages: list[Path]) -> tuple[str, str]:
+    first_prompt = ""
+    last_prompt = ""
+    for path in messages:
+        data = as_map(read_json(path))
+        if data is None or data.get("role") != "user":
+            continue
+        message_id = text(data.get("id"))
+        for part in (root / "parts" / (message_id or "")).glob("*.json"):
+            part_data = as_map(read_json(part))
+            if part_data is not None and part_data.get("sessionID") == session_id:
+                value = text(part_data.get("text"))
+                if value:
+                    first_prompt = first_prompt or value
+                    last_prompt = value
+    return first_prompt, last_prompt
+
+
+def _message_millis(path: Path) -> int | None:
+    data = as_map(read_json(path))
+    time_data = as_map(data.get("time")) if data is not None else None
+    return int_value(time_data.get("created")) if time_data is not None else None

package/packages/omo-codex/plugin/skills/coding-agent-sessions/scripts/agent_sessions/scanners.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
+from typing import Callable, TypeAlias
+
+from .claude import scan_claude
+from .codex import scan_codex
+from .file_scanners import (
+    scan_aider,
+    scan_amp,
+    scan_cline,
+    scan_codebuff,
+    scan_droid,
+    scan_gemini,
+    scan_kilocode,
+    scan_kimi,
+    scan_openclaw,
+    scan_qwen,
+    scan_roocode,
+)
+from .kiro_scanner import scan_kiro
+from .opencode import scan_opencode
+from .sqlite_optional_scanners import scan_crush, scan_goose, scan_hermes, scan_kilo_cli, scan_zed
+from .sqlite_scanners import scan_cursor_cli, scan_kodu
+from .transcript import existing, jsonl_parallel, recent, stem_id
+from .types import Session
+
+Scanner: TypeAlias = Callable[[tuple[Path, ...], int], list[Session]]
+
+PLATFORM_SCANNERS: dict[str, Scanner] = {
+    "codex": scan_codex,
+    "claude": scan_claude,
+    "senpi": lambda roots, workers: scan_senpi(roots, workers),
+    "opencode": scan_opencode,
+    "openclaw": scan_openclaw,
+    "droid": scan_droid,
+    "amp": scan_amp,
+    "gemini": scan_gemini,
+    "kimi": scan_kimi,
+    "qwen": scan_qwen,
+    "codebuff": scan_codebuff,
+    "roo-code": scan_roocode,
+    "kilo-code": scan_kilocode,
+    "cline": scan_cline,
+    "kodu": scan_kodu,
+    "cursor-cli": scan_cursor_cli,
+    "aider": scan_aider,
+    "kilo-cli": scan_kilo_cli,
+    "hermes": scan_hermes,
+    "goose": scan_goose,
+    "crush": scan_crush,
+    "zed": scan_zed,
+    "kiro": scan_kiro,
+}
+DEFAULT_PLATFORMS = frozenset(PLATFORM_SCANNERS)
+PLATFORM_ALIASES = {"cursor": "cursor-cli", "factory": "droid", "roo": "roo-code", "roocode": "roo-code", "kilocode": "kilo-code", "kilo": "kilo-cli"}
+
+__all__ = ["DEFAULT_PLATFORMS", "PLATFORM_SCANNERS", "scan", "scan_claude", "scan_codex", "scan_opencode", "scan_senpi"]
+
+
+def scan(platforms: frozenset[str], roots: tuple[Path, ...], workers: int) -> list[Session]:
+    selected = frozenset(PLATFORM_ALIASES.get(platform, platform) for platform in platforms)
+    tasks = [task for platform, task in PLATFORM_SCANNERS.items() if platform in selected]
+    if not tasks:
+        return []
+    sessions: list[Session] = []
+    with ThreadPoolExecutor(max_workers=min(workers, max(len(tasks), 1))) as pool:
+        futures = [pool.submit(task, roots, workers) for task in tasks]
+        for future in as_completed(futures):
+            sessions.extend(future.result())
+    return _dedupe(sessions)
+
+
+def scan_senpi(extra_roots: tuple[Path, ...], workers: int) -> list[Session]:
+    roots = existing([Path.home() / ".senpi" / "agent", Path.home() / ".pi" / "agent", *extra_roots])
+    paths = [path for root in roots for path in (root / "sessions").rglob("*.jsonl")]
+    return jsonl_parallel(recent(paths), workers, "senpi", lambda path: stem_id(path, "_"))
+
+
+def _dedupe(sessions: list[Session]) -> list[Session]:
+    found: dict[tuple[str, str], Session] = {}
+    for session in sessions:
+        key = (session.platform, session.id)
+        current = found.get(key)
+        if current is None or _linkage_score(session) > _linkage_score(current):
+            found[key] = session
+    return list(found.values())
+
+
+def _linkage_score(session: Session) -> int:
+    return int(session.parent_id is not None) + int(session.agent is not None)

package/packages/omo-codex/plugin/skills/coding-agent-sessions/scripts/agent_sessions/sqlite_optional_scanners.py

@@ -0,0 +1,203 @@
+from __future__ import annotations
+
+import sqlite3
+from collections.abc import Iterable
+from pathlib import Path
+
+from .jsonio import as_map, parse_json_text, text
+from .timeparse import file_time, unix_millis
+from .transcript import content_text, existing, flat_parallel, recent
+from .types import JsonMap, Session
+
+SqlValue = str | int | float | bytes | None
+SqlRow = tuple[SqlValue, ...]
+
+
+def scan_kilo_cli(extra_roots: tuple[Path, ...], workers: int) -> list[Session]:
+    paths = existing([Path.home() / ".local" / "share" / "kilo" / "kilo.db", *(root / "kilo.db" for root in extra_roots)])
+    return flat_parallel(recent(paths), workers, lambda path: _message_table_sessions(path, "kilo-cli", "message"))
+
+
+def scan_hermes(extra_roots: tuple[Path, ...], workers: int) -> list[Session]:
+    paths = existing([Path.home() / ".hermes" / "state.db", *(root / "state.db" for root in extra_roots)])
+    return flat_parallel(recent(paths), workers, lambda path: _message_table_sessions(path, "hermes", "messages"))
+
+
+def scan_goose(extra_roots: tuple[Path, ...], workers: int) -> list[Session]:
+    defaults = [
+        Path.home() / ".local" / "share" / "goose" / "sessions" / "sessions.db",
+        Path.home() / "Library" / "Application Support" / "goose" / "sessions" / "sessions.db",
+    ]
+    paths = existing([*defaults, *(root / "sessions.db" for root in extra_roots)])
+    return flat_parallel(recent(paths), workers, lambda path: _message_table_sessions(path, "goose", "messages"))
+
+
+def scan_crush(extra_roots: tuple[Path, ...], workers: int) -> list[Session]:
+    paths = existing([Path.home() / ".local" / "share" / "crush" / "crush.db", *(root / "crush.db" for root in extra_roots)])
+    return flat_parallel(recent(paths), workers, _crush_sessions)
+
+
+def scan_zed(extra_roots: tuple[Path, ...], workers: int) -> list[Session]:
+    paths = existing([Path.home() / "Library" / "Application Support" / "Zed" / "threads" / "threads.db", *(root / "threads.db" for root in extra_roots)])
+    return flat_parallel(recent(paths), workers, _zed_sessions)
+
+
+def _message_table_sessions(path: Path, platform: str, table: str) -> list[Session]:
+    try:
+        with sqlite3.connect(path) as conn:
+            rows = _fetch_all(conn, f"select session_id, role, data, created_at from {table} order by created_at")
+    except sqlite3.Error:
+        return []
+    return _group_message_rows(platform, path, rows)
+
+
+def _crush_sessions(path: Path) -> list[Session]:
+    try:
+        with sqlite3.connect(path) as conn:
+            rows = _fetch_all(conn, "select session_id, role, parts, created_at from messages order by created_at")
+    except sqlite3.Error:
+        return []
+    return _group_message_rows("crush", path, rows)
+
+
+def _zed_sessions(path: Path) -> list[Session]:
+    try:
+        with sqlite3.connect(path) as conn:
+            rows = _fetch_all(conn, "select id, data_type, data, updated_at from threads")
+    except sqlite3.Error:
+        return []
+    sessions: list[Session] = []
+    for row in rows:
+        if _row_text(row, 1) != "json":
+            continue
+        data = _json_blob(_row_bytes(row, 2))
+        messages = _json_messages(data)
+        first_user, last_user = _message_edges(messages)
+        if not first_user:
+            continue
+        sid = _row_text(row, 0) or path.stem
+        sessions.append(Session("zed", sid, str(path), None, _row_text(row, 3) or file_time(path), _row_text(row, 3) or file_time(path), "zed.dev", _zed_model(data), first_user, {"message_count": len(messages)}, last_user_message=last_user))
+    return sessions
+
+
+def _group_message_rows(platform: str, path: Path, rows: Iterable[SqlRow]) -> list[Session]:
+    grouped: dict[str, list[JsonMap]] = {}
+    stamps: dict[str, str] = {}
+    for row in rows:
+        sid = _row_text(row, 0)
+        if sid is None:
+            continue
+        message = _message_json(row)
+        if message is None:
+            continue
+        if sid not in grouped:
+            grouped[sid] = []
+        grouped[sid].append(message)
+        if sid not in stamps:
+            stamps[sid] = _stamp(row, 3) or file_time(path) or ""
+    sessions: list[Session] = []
+    for sid, messages in grouped.items():
+        first_user, last_user = _message_edges(messages)
+        if not first_user:
+            continue
+        sessions.append(Session(platform, sid, str(path), None, stamps.get(sid) or file_time(path), file_time(path), _provider(messages), _model(messages), first_user, {"message_count": len(messages)}, last_user_message=last_user))
+    return sessions
+
+
+def _message_json(row: SqlRow) -> JsonMap | None:
+    role = _row_text(row, 1)
+    raw = _row_json(row, 2)
+    if raw is None:
+        return {"role": role or "", "content": _row_text(row, 2) or ""}
+    if "role" not in raw:
+        raw["role"] = role or text(raw.get("role")) or ""
+    return raw
+
+
+def _message_edges(messages: list[JsonMap]) -> tuple[str, str]:
+    first_user = last_user = ""
+    for message in messages:
+        if text(message.get("role")) != "user":
+            continue
+        prompt = _content(message)
+        if prompt:
+            first_user = first_user or prompt
+            last_user = prompt
+    return first_user, last_user
+
+
+def _content(message: JsonMap) -> str:
+    for key in ("content", "parts", "text"):
+        value = message.get(key)
+        parsed = parse_json_text(value) if isinstance(value, str) else value
+        result = content_text(parsed) or (value if isinstance(value, str) else "")
+        if result:
+            return result
+    return ""
+
+
+def _json_messages(data: JsonMap | None) -> list[JsonMap]:
+    if data is None:
+        return []
+    for key in ("messages", "turns", "entries"):
+        value = data.get(key)
+        if isinstance(value, list):
+            return [item for item in value if isinstance(item, dict)]
+    return []
+
+
+def _model(messages: list[JsonMap]) -> str | None:
+    for message in messages:
+        model = text(message.get("modelID")) or text(message.get("model_id")) or text(message.get("model"))
+        if model:
+            return model
+    return None
+
+
+def _provider(messages: list[JsonMap]) -> str | None:
+    for message in messages:
+        provider = text(message.get("providerID")) or text(message.get("provider_id")) or text(message.get("provider"))
+        if provider:
+            return provider
+    return None
+
+
+def _zed_model(data: JsonMap | None) -> str | None:
+    model = as_map(data.get("model")) if data is not None else None
+    return text(model.get("model")) if model is not None else None
+
+
+def _fetch_all(conn: sqlite3.Connection, sql: str) -> list[SqlRow]:
+    rows: list[SqlRow] = conn.execute(sql).fetchall()
+    return rows
+
+
+def _row_json(row: SqlRow, index: int) -> JsonMap | None:
+    value = _row_text(row, index)
+    return as_map(parse_json_text(value)) if value is not None else None
+
+
+def _json_blob(value: bytes | None) -> JsonMap | None:
+    if value is None:
+        return None
+    try:
+        return as_map(parse_json_text(value.decode()))
+    except UnicodeDecodeError:
+        return None
+
+
+def _row_text(row: SqlRow, index: int) -> str | None:
+    value = row[index] if index < len(row) else None
+    return text(value) if not isinstance(value, bytes) else None
+
+
+def _row_bytes(row: SqlRow, index: int) -> bytes | None:
+    value = row[index] if index < len(row) else None
+    return value if isinstance(value, bytes) else None
+
+
+def _stamp(row: SqlRow, index: int) -> str | None:
+    value = row[index] if index < len(row) else None
+    if isinstance(value, int):
+        return unix_millis(value) if value > 10_000_000_000 else None
+    return value if isinstance(value, str) else None