oh-my-opencode 4.13.0 → 4.14.1

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

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
+
+from .jsonio import as_map, iter_jsonl, read_json, text
+from .timeparse import file_time
+from .transcript import content_text, env_path, existing, jsonl_parallel, recent
+from .types import Session
+
+
+def scan_claude(extra_roots: tuple[Path, ...], workers: int) -> list[Session]:
+    appdata = env_path("APPDATA")
+    roots = existing([Path.home() / ".claude", *(path / "Claude" for path in (appdata,) if path is not None), *extra_roots])
+    mains: list[Path] = []
+    subagents: list[Path] = []
+    for root in roots:
+        mains.extend((root / "transcripts").glob("*.jsonl"))
+        mains.extend((root / "projects").glob("*/*.jsonl"))
+        mains.extend((root / "pre-compact-session-histories").glob("*.jsonl"))
+        subagents.extend((root / "projects").glob("*/*/subagents/**/agent-*.jsonl"))
+    sessions = jsonl_parallel(recent(mains), workers, "claude", lambda path: path.stem)
+    sessions.extend(_subagent_parallel(recent(subagents), workers))
+    return sessions
+
+
+def _subagent_parallel(paths: list[Path], workers: int) -> list[Session]:
+    if not paths:
+        return []
+    sessions: list[Session] = []
+    with ThreadPoolExecutor(max_workers=min(workers, max(len(paths), 1))) as pool:
+        futures = [pool.submit(_subagent_session, path) for path in paths]
+        for future in as_completed(futures):
+            session = future.result()
+            if session is not None:
+                sessions.append(session)
+    return sessions
+
+
+def _subagent_session(path: Path) -> Session | None:
+    parts = path.parts
+    if "subagents" not in parts:
+        return None
+    parent_sid = parts[parts.index("subagents") - 1]
+    meta = as_map(read_json(path.with_name(path.stem + ".meta.json"))) or {}
+    first = next(iter_jsonl(path), None) or {}
+    message = as_map(first.get("message")) or {}
+    description = text(meta.get("description")) or ""
+    task = content_text(message.get("content"))
+    prompt = "\n".join(part for part in (description, task) if part)
+    created = text(first.get("timestamp")) or file_time(path)
+    return Session(
+        "claude",
+        path.stem.removeprefix("agent-"),
+        str(path),
+        text(first.get("cwd")),
+        created,
+        file_time(path) or created,
+        None,
+        None,
+        prompt,
+        {},
+        parent_sid,
+        text(meta.get("agentType")),
+        prompt,
+    )

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

@@ -0,0 +1,283 @@
+from __future__ import annotations
+
+import os
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from pathlib import Path
+
+from .jsonio import as_map, dumps, iter_jsonl
+from .scanners import DEFAULT_PLATFORMS, scan
+from .timeparse import date_bound, parse_stamp
+from .transcript import user_text
+from .types import Json, JsonMap, Options, Session
+
+
+def main() -> int:
+    command, opts, rest = _parse()
+    sessions = sorted(scan(opts.platforms, opts.roots, opts.workers), key=lambda item: item.created_at or "", reverse=True)
+    if command == "list":
+        _emit(_list_payload(_filter(sessions, opts), sessions, opts.limit, include_subagents=opts.include_subagents))
+        return 0
+    if command == "search":
+        queries = _queries(opts, rest)
+        _require(list(queries), "search requires a query")
+        _emit(_search_payload(_filter(sessions, opts), sessions, queries, opts.limit, opts.workers, include_subagents=opts.include_subagents))
+        return 0
+    if command == "get":
+        _require(rest, "read requires at least one session id")
+        _emit(_get_payload(sessions, rest))
+        return 0
+    raise SystemExit(f"unknown command: {command}")
+
+
+def _parse() -> tuple[str, Options, list[str]]:
+    import sys
+
+    args = sys.argv[1:]
+    if not args or args[0] in {"-h", "--help"}:
+        usage = (
+            "Usage: find-agent-sessions.py list|find|search|read|get [query|ids...] [--query TEXT ...] "
+            "[--platform NAME ...] [--root PATH] [--from DATE] [--to DATE] [--cwd TEXT] "
+            "[--model TEXT] [--limit N] [--workers N] [--include-subagents]"
+        )
+        print(usage)
+        raise SystemExit(0)
+    command = args.pop(0)
+    if command == "find":
+        command = "search"
+    elif command == "read":
+        command = "get"
+    roots: list[Path] = []
+    queries: list[str] = []
+    platforms: list[str] = []
+    date_from = date_to = cwd = model = None
+    limit = 20
+    workers = _default_workers()
+    include_subagents = False
+    rest: list[str] = []
+    index = 0
+    while index < len(args):
+        arg = args[index]
+        if arg == "--root":
+            roots.append(Path(args[index + 1]).expanduser())
+            index += 2
+        elif arg == "--query":
+            queries.append(args[index + 1])
+            index += 2
+        elif arg == "--platform":
+            platform = args[index + 1].strip().lower()
+            if "," in platform:
+                raise SystemExit("Use repeated --platform flags, for example: --platform senpi --platform opencode")
+            platforms.append(platform)
+            index += 2
+        elif arg == "--from":
+            date_from = args[index + 1]
+            index += 2
+        elif arg == "--to":
+            date_to = args[index + 1]
+            index += 2
+        elif arg == "--cwd":
+            cwd = args[index + 1].lower()
+            index += 2
+        elif arg == "--model":
+            model = args[index + 1].lower()
+            index += 2
+        elif arg == "--limit":
+            limit = int(args[index + 1])
+            index += 2
+        elif arg == "--workers":
+            workers = max(int(args[index + 1]), 1)
+            index += 2
+        elif arg == "--include-subagents":
+            include_subagents = True
+            index += 1
+        else:
+            rest.append(arg)
+            index += 1
+    selected_platforms = frozenset(platforms) if platforms else DEFAULT_PLATFORMS
+    return command, Options(selected_platforms, tuple(roots), tuple(queries), date_from, date_to, cwd, model, limit, workers, include_subagents), rest
+
+
+def _filter(sessions: list[Session], opts: Options) -> list[Session]:
+    start = date_bound(opts.date_from)
+    end = date_bound(opts.date_to, end=True)
+    result: list[Session] = []
+    for item in sessions:
+        stamp = parse_stamp(item.created_at)
+        if start is not None and stamp is not None and stamp < start:
+            continue
+        if end is not None and stamp is not None and stamp >= end:
+            continue
+        if opts.cwd is not None and opts.cwd not in (item.cwd or "").lower():
+            continue
+        if opts.model is not None and opts.model not in (item.model or "").lower():
+            continue
+        result.append(item)
+    return result
+
+
+def _child_counts(sessions: list[Session]) -> dict[tuple[str, str], int]:
+    counts: dict[tuple[str, str], int] = {}
+    for item in sessions:
+        if item.parent_id is not None:
+            key = (item.platform, item.parent_id)
+            counts[key] = counts.get(key, 0) + 1
+    return counts
+
+
+def _annotate(item: Session, counts: dict[tuple[str, str], int]) -> JsonMap:
+    data = item.to_json()
+    data["subagent_count"] = counts.get((item.platform, item.id), 0)
+    data["detail_hint"] = _detail_hint(item)
+    return data
+
+
+def _list_payload(filtered: list[Session], all_sessions: list[Session], limit: int, include_subagents: bool = False) -> JsonMap:
+    counts = _child_counts(all_sessions)
+    candidates = filtered if include_subagents else [item for item in filtered if item.parent_id is None]
+    results: list[Json] = [_annotate(item, counts) for item in candidates[:limit]]
+    return {"count": len(results), "results": results}
+
+
+def _search_payload(filtered: list[Session], all_sessions: list[Session], queries: tuple[str, ...], limit: int, workers: int, include_subagents: bool = False) -> JsonMap:
+    counts = _child_counts(all_sessions)
+    candidates = filtered if include_subagents else [item for item in filtered if item.parent_id is None]
+    per_query: list[Json] = []
+    merged: dict[tuple[str, str], tuple[Session, list[JsonMap]]] = {}
+    with ThreadPoolExecutor(max_workers=min(workers, max(len(queries), 1))) as pool:
+        futures = [pool.submit(_search_one, candidates, query, limit) for query in queries]
+        for future in as_completed(futures):
+            query, matches = future.result()
+            per_query.append({"query": query, "count": len(matches), "results": [_annotate_search(item, counts, reasons) for item, reasons in matches]})
+            for item, reasons in matches:
+                key = (item.platform, item.id)
+                if key not in merged:
+                    merged[key] = (item, reasons)
+    results: list[Json] = [_annotate_search(item, counts, reasons) for item, reasons in list(merged.values())[:limit]]
+    return {"count": len(results), "queries": per_query, "results": results}
+
+
+def _get_payload(sessions: list[Session], ids: list[str]) -> JsonMap:
+    counts = _child_counts(sessions)
+    results: list[Json] = []
+    for item in sessions:
+        if item.id not in ids and not any(item.id.startswith(prefix) for prefix in ids):
+            continue
+        events = _events(item)
+        first_prompt, last_prompt = _prompt_edges(item, events)
+        session = _annotate(item, counts)
+        session["first_user_message"] = first_prompt[:300]
+        session["last_user_message"] = last_prompt[:300]
+        children = sorted(
+            (child for child in sessions if child.platform == item.platform and child.parent_id == item.id),
+            key=lambda child: child.created_at or "",
+        )
+        results.append(
+            {
+                "session": session,
+                "prompts": {"first_user_message": first_prompt, "last_user_message": last_prompt},
+                "events": events,
+                "subagents": [_annotate(child, counts) for child in children],
+                "detail_hint": _detail_hint(item),
+            }
+        )
+    return {"count": len(results), "results": results}
+
+
+def _annotate_search(item: Session, counts: dict[tuple[str, str], int], reasons: list[JsonMap]) -> JsonMap:
+    data = _annotate(item, counts)
+    reason_rows: list[Json] = []
+    reason_rows.extend(reasons)
+    data["match_reasons"] = reason_rows
+    return data
+
+
+def _detail_hint(item: Session) -> str:
+    return f"python3 scripts/find-agent-sessions.py read {item.id} --platform {item.platform}"
+
+
+def _events(item: Session) -> list[Json]:
+    if item.path.endswith(".jsonl"):
+        return list(iter_jsonl(Path(item.path)))
+    events: list[Json] = []
+    if item.first_user_message:
+        events.append({"type": "message", "message": {"role": "user", "content": item.first_user_message}})
+    if item.last_user_message and item.last_user_message != item.first_user_message:
+        events.append({"type": "message", "message": {"role": "user", "content": item.last_user_message}})
+    return events
+
+
+def _prompt_edges(item: Session, events: list[Json]) -> tuple[str, str]:
+    first_prompt = item.first_user_message
+    last_prompt = item.last_user_message or item.first_user_message
+    for event in events:
+        if not isinstance(event, dict):
+            continue
+        message = as_map(event.get("message")) or as_map(event.get("payload")) or {}
+        prompt = user_text(event, message)
+        if prompt:
+            first_prompt = first_prompt or prompt
+            last_prompt = prompt
+    return first_prompt, last_prompt
+
+
+def _match_reasons(item: Session, query: str) -> list[JsonMap]:
+    needle = query.lower()
+    reasons: list[JsonMap] = []
+    for field, value in _search_fields(item):
+        if needle in value.lower():
+            reasons.append({"query": query, "platform": item.platform, "field": field, "snippet": _snippet(value, needle)})
+    return reasons
+
+
+def _search_fields(item: Session) -> tuple[tuple[str, str], ...]:
+    return (
+        ("platform", item.platform),
+        ("id", item.id),
+        ("path", item.path),
+        ("cwd", item.cwd or ""),
+        ("provider", item.provider or ""),
+        ("model", item.model or ""),
+        ("agent", item.agent or ""),
+        ("first_user_message", item.first_user_message),
+        ("last_user_message", item.last_user_message),
+    )
+
+
+def _snippet(value: str, needle: str) -> str:
+    start = max(value.lower().find(needle) - 60, 0)
+    end = min(start + 160, len(value))
+    return value[start:end]
+
+
+def _queries(opts: Options, rest: list[str]) -> tuple[str, ...]:
+    if opts.queries:
+        return opts.queries
+    joined = " ".join(rest).strip()
+    return (joined,) if joined else ()
+
+
+def _search_one(sessions: list[Session], query: str, limit: int) -> tuple[str, list[tuple[Session, list[JsonMap]]]]:
+    matches: list[tuple[Session, list[JsonMap]]] = []
+    for item in sessions:
+        reasons = _match_reasons(item, query)
+        if reasons:
+            matches.append((item, reasons))
+    return query, matches[:limit]
+
+
+def _emit(value: JsonMap) -> None:
+    print(dumps(value))
+
+
+def _require(values: list[str], message: str) -> None:
+    if not values:
+        raise SystemExit(message)
+
+
+def _default_workers() -> int:
+    cpu = os.cpu_count() or 4
+    return min(max(cpu * 4, 8), 64)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

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

@@ -0,0 +1,105 @@
+from __future__ import annotations
+
+import sqlite3
+from pathlib import Path
+from typing import TypeAlias
+
+from .timeparse import unix_seconds
+from .transcript import env_path, existing, flat_parallel, jsonl_parallel, nick_role, recent, spawn_info, stem_id
+from .types import Json, Session
+
+THREADS_SQL = (
+    "SELECT id, rollout_path, cwd, created_at, updated_at, model_provider, model, first_user_message, tokens_used, "
+    "source, agent_nickname, agent_role FROM threads"
+)
+LEGACY_THREADS_SQL = (
+    "SELECT id, rollout_path, cwd, created_at, updated_at, model_provider, model, first_user_message, tokens_used FROM threads"
+)
+SPAWN_EDGES_SQL = "SELECT child_thread_id, parent_thread_id FROM thread_spawn_edges"
+
+SqliteScalar: TypeAlias = str | int | float | bytes | None
+CodexRow: TypeAlias = tuple[SqliteScalar, ...]
+
+
+def scan_codex(extra_roots: tuple[Path, ...], workers: int) -> list[Session]:
+    roots = existing([*(path for path in (env_path("CODEX_HOME"),) if path is not None), Path.home() / ".codex", *extra_roots])
+    db_paths: list[Path] = []
+    rollouts: list[Path] = []
+    for root in roots:
+        db_paths.extend(root.glob("state_*.sqlite"))
+        rollouts.extend((root / "sessions").rglob("rollout-*.jsonl"))
+        rollouts.extend((root / "archived_sessions").glob("rollout-*.jsonl"))
+    sessions = flat_parallel(db_paths, workers, _codex_db)
+    sessions.extend(jsonl_parallel(recent(rollouts), workers, "codex", lambda path: stem_id(path, "rollout-")))
+    return sessions
+
+
+def _codex_db(path: Path) -> list[Session]:
+    conn: sqlite3.Connection | None = None
+    try:
+        conn = sqlite3.connect(str(path), timeout=3)
+        edges = _spawn_edges(conn)
+        rows = _thread_rows(conn)
+    except sqlite3.Error:
+        return []
+    finally:
+        if conn is not None:
+            conn.close()
+    return [_codex_row(path, row, edges) for row in rows]
+
+
+def _thread_rows(conn: sqlite3.Connection) -> list[CodexRow]:
+    try:
+        primary_rows: list[CodexRow] = conn.execute(THREADS_SQL).fetchall()
+        return primary_rows
+    except sqlite3.Error:
+        legacy_rows: list[CodexRow] = conn.execute(LEGACY_THREADS_SQL).fetchall()
+        return legacy_rows
+
+
+def _spawn_edges(conn: sqlite3.Connection) -> dict[str, str]:
+    try:
+        rows: list[CodexRow] = conn.execute(SPAWN_EDGES_SQL).fetchall()
+    except sqlite3.Error:
+        return {}
+    edges: dict[str, str] = {}
+    for row in rows:
+        child = _row_text(_row_value(row, 0))
+        parent = _row_text(_row_value(row, 1))
+        if child is not None and parent is not None:
+            edges[child] = parent
+    return edges
+
+
+def _codex_row(path: Path, row: CodexRow, edges: dict[str, str]) -> Session:
+    thread_id = str(_row_value(row, 0))
+    source_parent, source_agent = spawn_info(_row_text(_row_value(row, 9)))
+    return Session(
+        "codex",
+        thread_id,
+        str(_row_value(row, 1) or path),
+        _row_text(_row_value(row, 2)),
+        unix_seconds(_row_number(_row_value(row, 3))),
+        unix_seconds(_row_number(_row_value(row, 4))),
+        _row_text(_row_value(row, 5)),
+        _row_text(_row_value(row, 6)),
+        _row_text(_row_value(row, 7)) or "",
+        {"total_tokens": _row_number(_row_value(row, 8))},
+        edges.get(thread_id) or source_parent,
+        nick_role(_row_text(_row_value(row, 10)), _row_text(_row_value(row, 11))) or source_agent,
+    )
+
+
+def _row_text(value: Json | int | float | None) -> str | None:
+    return value if isinstance(value, str) else None
+
+
+def _row_number(value: Json | int | float | None) -> int | float | None:
+    return value if isinstance(value, int | float) else None
+
+
+def _row_value(row: CodexRow, index: int) -> Json | int | float | None:
+    value = row[index] if index < len(row) else None
+    if value is None or isinstance(value, str | int | float | bool):
+        return value
+    return None