oh-my-opencode 4.13.0 → 4.14.0

package/packages/shared-skills/skills/coding-agent-sessions/scripts/agent_sessions/jsonio.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+import json
+from collections.abc import Iterator
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from .types import Json, JsonMap
+
+if TYPE_CHECKING:
+    def _loads(_text: str) -> Json: ...
+else:
+    def _loads(text_value: str) -> Json:
+        return json.loads(text_value)
+
+
+def as_map(value: Json | None) -> JsonMap | None:
+    return value if isinstance(value, dict) else None
+
+
+def text(value: Json | None) -> str | None:
+    return value if isinstance(value, str) else None
+
+
+def int_value(value: Json | None) -> int | None:
+    return value if isinstance(value, int) else None
+
+
+def parse_json_text(value: str) -> Json | None:
+    try:
+        return _loads(value)
+    except json.JSONDecodeError:
+        return None
+
+
+def read_json(path: Path) -> Json | None:
+    try:
+        return parse_json_text(path.read_text(encoding="utf-8", errors="replace"))
+    except OSError:
+        return None
+
+
+def iter_jsonl(path: Path) -> Iterator[JsonMap]:
+    try:
+        with path.open(encoding="utf-8", errors="replace") as handle:
+            for line in handle:
+                value = parse_json_text(line)
+                if isinstance(value, dict):
+                    yield value
+    except OSError:
+        return
+
+
+def dumps(value: JsonMap) -> str:
+    return json.dumps(value, ensure_ascii=False, indent=2)

package/packages/shared-skills/skills/coding-agent-sessions/scripts/agent_sessions/kiro_scanner.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from .jsonio import as_map, iter_jsonl, read_json, text
+from .timeparse import file_time, unix_seconds
+from .transcript import existing, flat_parallel, recent
+from .types import Json, JsonMap, Session
+
+
+def scan_kiro(extra_roots: tuple[Path, ...], workers: int) -> list[Session]:
+    roots = _roots([Path.home() / ".kiro"], extra_roots, (".kiro", "kiro"))
+    paths = [path for root in roots for path in (root / "sessions" / "cli").glob("*.json")]
+    return flat_parallel(recent(paths), workers, _kiro_sessions)
+
+
+def _kiro_sessions(path: Path) -> list[Session]:
+    data = as_map(read_json(path))
+    if data is None:
+        return []
+    state = as_map(data.get("session_state")) or {}
+    rts_state = as_map(state.get("rts_model_state")) or {}
+    model_info = as_map(rts_state.get("model_info")) or {}
+    metadata = as_map(state.get("conversation_metadata")) or {}
+    turns = metadata.get("user_turn_metadatas")
+    first_user, last_user, created = _kiro_prompt_edges(path.with_suffix(".jsonl"))
+    if not first_user:
+        return []
+    usage: JsonMap = {"turn_count": len(turns)} if isinstance(turns, list) else {}
+    return [
+        Session(
+            "kiro",
+            text(data.get("session_id")) or text(data.get("sessionId")) or path.stem,
+            str(path),
+            text(data.get("cwd")),
+            created or file_time(path),
+            file_time(path),
+            "amazon-bedrock",
+            text(model_info.get("model_id")),
+            first_user,
+            usage,
+            last_user_message=last_user,
+        )
+    ]
+
+
+def _kiro_prompt_edges(path: Path) -> tuple[str, str, str | None]:
+    first_user = last_user = ""
+    created = None
+    for row in iter_jsonl(path):
+        if row.get("kind") != "Prompt":
+            continue
+        data = as_map(row.get("data")) or {}
+        prompt = _kiro_content(data.get("content"))
+        if prompt:
+            first_user = first_user or prompt
+            last_user = prompt
+        meta = as_map(data.get("meta")) or {}
+        stamp = meta.get("timestamp")
+        if created is None and isinstance(stamp, int | float):
+            created = unix_seconds(stamp)
+    return first_user, last_user, created
+
+
+def _kiro_content(value: Json | None) -> str:
+    if not isinstance(value, list):
+        return text(value) or ""
+    parts: list[str] = []
+    for item in value:
+        part = _kiro_content_part(item)
+        if part:
+            parts.append(part)
+    return "\n".join(parts)
+
+
+def _kiro_content_part(value: Json) -> str:
+    if not isinstance(value, dict):
+        return ""
+    item: JsonMap = value
+    kind = text(item.get("kind"))
+    if kind is not None and kind != "text":
+        return ""
+    return text(item.get("data")) or text(item.get("text")) or text(item.get("content")) or ""
+
+
+def _roots(defaults: list[Path], extra_roots: tuple[Path, ...], children: tuple[str, ...]) -> list[Path]:
+    candidates = [*defaults]
+    for root in extra_roots:
+        candidates.append(root)
+        candidates.extend(root / child for child in children)
+    return existing(candidates)

package/packages/shared-skills/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/shared-skills/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)