oh-my-opencode 4.13.0 → 4.14.0

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

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

@@ -0,0 +1,177 @@
+from __future__ import annotations
+
+import sqlite3
+from pathlib import Path
+from typing import TypeAlias
+
+from .jsonio import as_map, parse_json_text, text
+from .timeparse import file_time, unix_millis
+from .transcript import content_text, env_path, existing, flat_parallel, recent
+from .types import Json, JsonMap, Session
+
+SqlValue: TypeAlias = str | int | float | bytes | None
+SqlRow: TypeAlias = tuple[SqlValue, ...]
+
+
+def scan_kodu(extra_roots: tuple[Path, ...], workers: int) -> list[Session]:
+    appdata = env_path("APPDATA")
+    roots = _roots(
+        [
+            Path.home() / "Library" / "Application Support" / "Code" / "User" / "globalStorage" / "kodu-ai.claude-dev-experimental",
+            Path.home() / ".config" / "Code" / "User" / "globalStorage" / "kodu-ai.claude-dev-experimental",
+            *(path / "Code" / "User" / "globalStorage" / "kodu-ai.claude-dev-experimental" for path in (appdata,) if path is not None),
+        ],
+        extra_roots,
+        ("kodu-ai.claude-dev-experimental",),
+    )
+    paths = [root / "db" / "Azad.db" for root in roots if (root / "db" / "Azad.db").exists()]
+    return flat_parallel(recent(paths), workers, _kodu_db)
+
+
+def scan_cursor_cli(extra_roots: tuple[Path, ...], workers: int) -> list[Session]:
+    roots = _roots([Path.home() / ".cursor"], extra_roots, (".cursor",))
+    paths = [path for root in roots for path in (root / "chats").glob("*/*/store.db")]
+    return flat_parallel(recent(paths), workers, _cursor_db)
+
+
+def _kodu_db(path: Path) -> list[Session]:
+    try:
+        with sqlite3.connect(path) as conn:
+            tasks = _fetch_all(
+                conn,
+                "select id, name, dir_absolute_path, created_at, updated_at, tokens_in, tokens_out, cache_reads, cache_writes, cost from tasks"
+            )
+            return [_kodu_session(path, conn, row) for row in tasks]
+    except sqlite3.Error:
+        return []
+
+
+def _kodu_session(path: Path, conn: sqlite3.Connection, row: SqlRow) -> Session:
+    sid = _row_text(row, 0) or ""
+    messages = _fetch_all(
+        conn,
+        "select role, content, model_id, started_at, finished_at, tokens_in, tokens_out, cache_reads, cache_writes, cost from messages where task_id = ? order by started_at",
+        (sid,),
+    )
+    first_user = last_user = ""
+    model = None
+    for message in messages:
+        model = model or _row_text(message, 2)
+        if _row_text(message, 0) == "user":
+            prompt = _content(_row_text(message, 1))
+            first_user = first_user or prompt
+            last_user = prompt
+    return Session(
+        "kodu",
+        sid,
+        str(path),
+        _row_text(row, 2),
+        unix_millis(_row_int(row, 3)),
+        unix_millis(_row_int(row, 4)) or file_time(path),
+        None,
+        model,
+        first_user,
+        _usage(row, (5, "input"), (6, "output"), (7, "cacheRead"), (8, "cacheWrite"), (9, "cost_total")),
+        last_user_message=last_user,
+    )
+
+
+def _cursor_db(path: Path) -> list[Session]:
+    try:
+        with sqlite3.connect(path) as conn:
+            rows = _fetch_all(conn, "select data from blobs")
+    except sqlite3.Error:
+        return []
+    first_user = last_user = ""
+    for row in rows:
+        data = _json_blob(_row_bytes(row, 0))
+        if data is None or data.get("role") != "user":
+            continue
+        prompt = _cursor_prompt(_content(data.get("content")))
+        if prompt:
+            first_user = first_user or prompt
+            last_user = prompt
+    if not first_user:
+        return []
+    return [
+        Session(
+            "cursor-cli",
+            path.parent.name,
+            str(path),
+            None,
+            file_time(path),
+            file_time(path),
+            "cursor",
+            None,
+            first_user,
+            {"blob_count": len(rows)},
+            last_user_message=last_user,
+        )
+    ]
+
+
+def _content(value: Json | None) -> str:
+    parsed = parse_json_text(value) if isinstance(value, str) else value
+    return content_text(parsed) or (value if isinstance(value, str) else "")
+
+
+def _json_blob(value: bytes | None) -> JsonMap | None:
+    if value is None:
+        return None
+    try:
+        decoded = value.decode()
+    except UnicodeDecodeError:
+        return None
+    return as_map(parse_json_text(decoded))
+
+
+def _cursor_prompt(value: str) -> str:
+    start = value.find("<user_query>")
+    end = value.find("</user_query>")
+    if start >= 0 and end > start:
+        return value[start + len("<user_query>") : end].strip()
+    if value.lstrip().startswith("<user_info>"):
+        return ""
+    return value.strip()
+
+
+def _usage(row: SqlRow, *fields: tuple[int, str]) -> JsonMap:
+    result: JsonMap = {}
+    for index, key in fields:
+        value = _row_number(row, index)
+        if value is not None:
+            result[key] = value
+    return result
+
+
+def _fetch_all(conn: sqlite3.Connection, sql: str, params: tuple[str, ...] = ()) -> list[SqlRow]:
+    rows: list[SqlRow] = conn.execute(sql, params).fetchall()
+    return rows
+
+
+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 _row_number(row: SqlRow, 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: SqlRow, index: int) -> int | None:
+    value = row[index] if index < len(row) else None
+    return value if isinstance(value, int) else None
+
+
+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/timeparse.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+
+
+def date_bound(value: str | None, end: bool = False) -> datetime | None:
+    if value is None:
+        return None
+    text = value.strip().lower()
+    now = datetime.now(timezone.utc)
+    if text == "today":
+        base = now.replace(hour=0, minute=0, second=0, microsecond=0)
+    elif text == "yesterday":
+        base = (now - timedelta(days=1)).replace(hour=0, minute=0, second=0, microsecond=0)
+    elif text.endswith("d") and text[:-1].isdigit():
+        base = (now - timedelta(days=int(text[:-1]))).replace(hour=0, minute=0, second=0, microsecond=0)
+    else:
+        parts = [int(part) for part in text.split("-")]
+        base = datetime(parts[0], parts[1] if len(parts) > 1 else 1, parts[2] if len(parts) > 2 else 1, tzinfo=timezone.utc)
+    if not end:
+        return base
+    if text in {"today", "yesterday"} or text.endswith("d") or len(text.split("-")) == 3:
+        return base + timedelta(days=1)
+    if len(text.split("-")) == 2:
+        return datetime(base.year + (base.month // 12), (base.month % 12) + 1, 1, tzinfo=timezone.utc)
+    return datetime(base.year + 1, 1, 1, tzinfo=timezone.utc)
+
+
+def parse_stamp(value: str | None) -> datetime | None:
+    if value is None:
+        return None
+    try:
+        return datetime.fromisoformat(value.replace("Z", "+00:00")).astimezone(timezone.utc)
+    except ValueError:
+        return None
+
+
+def unix_seconds(value: int | float | None) -> str | None:
+    return datetime.fromtimestamp(value, timezone.utc).isoformat() if value is not None else None
+
+
+def unix_millis(value: int | None) -> str | None:
+    return datetime.fromtimestamp(value / 1000, timezone.utc).isoformat() if value is not None else None
+
+
+def file_time(path: Path) -> str | None:
+    try:
+        return datetime.fromtimestamp(path.stat().st_mtime, timezone.utc).isoformat()
+    except OSError:
+        return None

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

@@ -0,0 +1,149 @@
+from __future__ import annotations
+
+import os
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from heapq import nlargest
+from pathlib import Path
+from typing import Callable
+
+from .jsonio import as_map, iter_jsonl, parse_json_text, text
+from .timeparse import file_time
+from .types import Json, JsonMap, Session
+
+MAX_PLATFORM_FILES = 2000
+
+
+def jsonl_parallel(paths: list[Path], workers: int, platform: str, fallback_id: Callable[[Path], str]) -> list[Session]:
+    if not paths:
+        return []
+    sessions: list[Session] = []
+    with ThreadPoolExecutor(max_workers=min(workers, max(len(paths), 1))) as pool:
+        futures = [pool.submit(jsonl_session, platform, path, fallback_id(path)) for path in paths]
+        for future in as_completed(futures):
+            sessions.append(future.result())
+    return sessions
+
+
+def flat_parallel(paths: list[Path], workers: int, read: Callable[[Path], list[Session]]) -> list[Session]:
+    if not paths:
+        return []
+    sessions: list[Session] = []
+    with ThreadPoolExecutor(max_workers=min(workers, max(len(paths), 1))) as pool:
+        futures = [pool.submit(read, path) for path in paths]
+        for future in as_completed(futures):
+            sessions.extend(future.result())
+    return sessions
+
+
+def jsonl_session(platform: str, path: Path, fallback_id: str) -> Session:
+    sid = fallback_id
+    cwd = provider = model = first_user = parent = agent = None
+    last_user = ""
+    created = updated = None
+    usage: JsonMap = {}
+    for data in iter_jsonl(path):
+        event_type = data.get("type")
+        session_line_id = text(data.get("id")) if event_type == "session" else None
+        sid = text(data.get("sessionId")) or session_line_id or sid
+        cwd = cwd or text(data.get("cwd"))
+        created = created or text(data.get("timestamp"))
+        updated = text(data.get("timestamp")) or updated
+        provider = provider or text(data.get("provider"))
+        model = model or text(data.get("modelId")) or text(data.get("model"))
+        payload = as_map(data.get("payload"))
+        if event_type == "session_meta" and payload is not None:
+            sid = text(payload.get("id")) or sid
+            cwd = cwd or text(payload.get("cwd"))
+            provider = provider or text(payload.get("model_provider"))
+            source_parent, source_agent = spawn_info(payload.get("source"))
+            parent = parent or source_parent
+            agent = agent or source_agent or nick_role(text(payload.get("agent_nickname")), text(payload.get("agent_role")))
+        message = as_map(data.get("message")) or payload or {}
+        provider = provider or text(message.get("provider"))
+        model = model or text(message.get("model"))
+        prompt = user_text(data, message)
+        if prompt:
+            first_user = first_user or prompt
+            last_user = prompt
+        merge_usage(usage, as_map(message.get("usage")) or as_map(data.get("usage")))
+    return Session(platform, sid, str(path), cwd, created or file_time(path), updated or created or file_time(path), provider, model, first_user or "", usage, parent, agent, last_user)
+
+
+def spawn_info(source: Json | None) -> tuple[str | None, str | None]:
+    data = as_map(parse_json_text(source) if isinstance(source, str) else source)
+    if data is None:
+        return None, None
+    subagent = data.get("subagent")
+    if isinstance(subagent, str):
+        return None, subagent
+    subagent_map = as_map(subagent)
+    spawn = as_map(subagent_map.get("thread_spawn")) if subagent_map is not None else None
+    if spawn is None:
+        return None, None
+    return text(spawn.get("parent_thread_id")), nick_role(text(spawn.get("agent_nickname")), text(spawn.get("agent_role")))
+
+
+def nick_role(nickname: str | None, role: str | None) -> str | None:
+    if nickname and role:
+        return f"{nickname} ({role})"
+    return nickname or role
+
+
+def user_text(data: JsonMap, message: JsonMap) -> str:
+    if data.get("type") == "user":
+        value = content_text(data.get("content"))
+        if value:
+            return value
+    if message.get("role") == "user":
+        return content_text(message.get("content"))
+    return ""
+
+
+def content_text(value: Json | None) -> str:
+    if isinstance(value, str):
+        return value
+    if isinstance(value, list):
+        parts = [text(item.get("text")) or text(item.get("content")) or "" for item in value if isinstance(item, dict)]
+        return "\n".join(part for part in parts if part)
+    return ""
+
+
+def merge_usage(target: JsonMap, value: JsonMap | None) -> None:
+    if value is None:
+        return
+    for key in ("totalTokens", "total_tokens", "input", "output", "cacheRead", "cacheWrite"):
+        if key in value:
+            target[key] = value[key]
+    cost = as_map(value.get("cost"))
+    if cost is not None and "total" in cost:
+        target["cost_total"] = cost["total"]
+
+
+def existing(paths: list[Path]) -> list[Path]:
+    seen: set[Path] = set()
+    result: list[Path] = []
+    for path in paths:
+        if str(path) and path.exists() and path not in seen:
+            seen.add(path)
+            result.append(path)
+    return result
+
+
+def recent(paths: list[Path]) -> list[Path]:
+    return nlargest(MAX_PLATFORM_FILES, paths, key=modified_time)
+
+
+def modified_time(path: Path) -> float:
+    try:
+        return path.stat().st_mtime
+    except OSError:
+        return 0.0
+
+
+def stem_id(path: Path, marker: str) -> str:
+    return path.stem.split(marker)[-1].split("_")[-1]
+
+
+def env_path(name: str) -> Path | None:
+    value = os.environ.get(name)
+    return Path(value).expanduser() if value else None

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

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import TypeAlias
+
+
+Json: TypeAlias = str | int | float | bool | None | list["Json"] | dict[str, "Json"]
+JsonMap: TypeAlias = dict[str, Json]
+
+
+@dataclass(frozen=True, slots=True)
+class Options:
+    platforms: frozenset[str]
+    roots: tuple[Path, ...]
+    queries: tuple[str, ...]
+    date_from: str | None
+    date_to: str | None
+    cwd: str | None
+    model: str | None
+    limit: int
+    workers: int
+    include_subagents: bool
+
+
+@dataclass(frozen=True, slots=True)
+class Session:
+    platform: str
+    id: str
+    path: str
+    cwd: str | None
+    created_at: str | None
+    updated_at: str | None
+    provider: str | None
+    model: str | None
+    first_user_message: str
+    usage: JsonMap
+    parent_id: str | None = None
+    agent: str | None = None
+    last_user_message: str = ""
+
+    def to_json(self) -> JsonMap:
+        return {
+            "platform": self.platform,
+            "id": self.id,
+            "path": self.path,
+            "cwd": self.cwd,
+            "created_at": self.created_at,
+            "updated_at": self.updated_at,
+            "provider": self.provider,
+            "model": self.model,
+            "first_user_message": self.first_user_message[:300],
+            "last_user_message": (self.last_user_message or self.first_user_message)[:300],
+            "usage": self.usage,
+            "parent_id": self.parent_id,
+            "agent": self.agent,
+        }

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

@@ -0,0 +1,19 @@
+#!/usr/bin/env python3
+# /// script
+# requires-python = ">=3.11"
+# ///
+# --- How to run ---
+# python3 scripts/find-agent-sessions.py list --limit 20
+# python3 scripts/find-agent-sessions.py search "commit" --from 7d
+# python3 scripts/find-agent-sessions.py get <session-id>
+from __future__ import annotations
+
+import sys
+import runpy
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+
+if __name__ == "__main__":
+    _ = runpy.run_module("agent_sessions.cli", run_name="__main__")