opencode-db 0.3.0__py3-none-any.whl

cmd_search.py

@@ -0,0 +1,111 @@
+"""Команда search: поиск по тексту сообщений и частей."""
+
+import json
+from typing import Literal
+
+from db import resolve_session_id
+from i18n import _
+from utils import format_ts
+
+
+def register(subparsers) -> None:
+    p = subparsers.add_parser("search", help=_("help.cmd.search"))
+    p.add_argument("query", help="Search text")
+    p.add_argument("--session", type=str, help="Limit to session")
+    p.add_argument("--limit", type=int, default=30, help="Max results")
+    p.add_argument("--json", action="store_true", help="JSON output")
+
+
+def _search_in_part_data(
+    data, query_lower
+) -> tuple[Literal[False], Literal[""]] | tuple[Literal[True], str]:
+    """Ищет query в part.data (JSON), проверяя текстовые поля."""
+    if not data:
+        return False, ""
+    try:
+        parsed = json.loads(data) if isinstance(data, str) else data
+    except (json.JSONDecodeError, TypeError):
+        return False, ""
+
+    text = parsed.get("text", "")
+    if isinstance(text, str) and query_lower in text.lower():
+        return True, text[:200]
+
+    state = parsed.get("state", {})
+    if isinstance(state, dict):
+        t_input = state.get("input", {})
+        t_output = state.get("output", "")
+        if isinstance(t_input, dict):
+            for v in t_input.values():
+                if isinstance(v, str) and query_lower in v.lower():
+                    return True, f"[tool] {str(v)[:200]}"
+        if isinstance(t_output, str) and query_lower in t_output.lower():
+            return True, f"[output] {t_output[:200]}"
+
+    return False, ""
+
+
+def run(args, db) -> Literal[0]:
+    query_lower = args.query.lower()
+
+    conditions = []
+    params = []
+
+    if args.session:
+        full_id = resolve_session_id(db, args.session)
+        conditions.append("p.session_id = ?")
+        params.append(full_id)
+
+    where = " AND ".join(conditions) if conditions else "1=1"
+
+    rows = db.execute(
+        f"""
+        SELECT p.id, p.session_id, p.message_id, p.data,
+               m.time_created,
+               json_extract(m.data, '$.role') as role
+        FROM part p
+        JOIN message m ON m.id = p.message_id
+        WHERE {where}
+          AND p.data IS NOT NULL
+        ORDER BY p.time_created DESC
+        LIMIT ?
+    """,
+        (*params, args.limit * 5),
+    ).fetchall()
+
+    results = []
+    for r in rows:
+        found, snippet = _search_in_part_data(r["data"], query_lower)
+        if found:
+            results.append(
+                {
+                    "session_id": r["session_id"][:24],
+                    "message_id": r["message_id"][:12],
+                    "role": r["role"],
+                    "time": format_ts(r["time_created"]) if r["time_created"] else "—",
+                    "snippet": snippet,
+                }
+            )
+        if len(results) >= args.limit:
+            break
+
+    if args.json:
+        from formatters import print_json
+
+        print_json(results)
+        return 0
+
+    if not results:
+        print(_("search.none", query=args.query))
+        return 0
+
+    print(_("search.header", query=args.query))
+    print(f"  {'─' * 60}")
+
+    for r in results:
+        print(f"  [{r['time']}] {r['role']}  {r['session_id']}  msg:{r['message_id']}")
+        print(f"    {r['snippet']}")
+        print()
+
+    print(_("search.found", n=len(results)))
+    return 0

cmd_stats.py

@@ -0,0 +1,115 @@
+"""Команда stats: общая статистика по базе данных."""
+
+from typing import Literal
+
+from db import parse_model
+from i18n import _
+from utils import format_cost, format_tokens, format_ts
+
+
+def register(subparsers) -> None:
+    p = subparsers.add_parser("stats", help=_("help.cmd.stats"))
+    p.add_argument("--json", action="store_true", help="JSON output")
+
+
+def run(args, db) -> Literal[0]:
+    session_count = db.execute("SELECT COUNT(*) FROM session").fetchone()[0]
+    message_count = db.execute("SELECT COUNT(*) FROM message").fetchone()[0]
+    part_count = db.execute("SELECT COUNT(*) FROM part").fetchone()[0]
+    project_count = db.execute("SELECT COUNT(*) FROM project").fetchone()[0]
+    todo_count = db.execute("SELECT COUNT(*) FROM todo").fetchone()[0]
+
+    totals = db.execute("""
+        SELECT
+            COALESCE(SUM(cost), 0) as total_cost,
+            COALESCE(SUM(tokens_input), 0) as total_ti,
+            COALESCE(SUM(tokens_output), 0) as total_to,
+            COALESCE(SUM(tokens_reasoning), 0) as total_tr,
+            COALESCE(SUM(tokens_cache_read), 0) as total_cr,
+            COALESCE(SUM(tokens_cache_write), 0) as total_cw
+        FROM session
+    """).fetchone()
+
+    first_last = db.execute("""
+        SELECT MIN(time_created) as first_ts, MAX(time_created) as last_ts
+        FROM session
+    """).fetchone()
+
+    top_models = db.execute("""
+        SELECT model, COUNT(*) as cnt, SUM(cost) as cost
+        FROM session
+        WHERE model IS NOT NULL
+        GROUP BY model
+        ORDER BY cnt DESC
+        LIMIT 5
+    """).fetchall()
+
+    agents = db.execute("""
+        SELECT agent, COUNT(*) as cnt
+        FROM session
+        WHERE agent IS NOT NULL
+        GROUP BY agent
+        ORDER BY cnt DESC
+    """).fetchall()
+
+    if args.json:
+        from formatters import print_json
+
+        data = {
+            "sessions": session_count,
+            "messages": message_count,
+            "parts": part_count,
+            "projects": project_count,
+            "todos": todo_count,
+            "cost": totals["total_cost"],
+            "tokens_input": totals["total_ti"],
+            "tokens_output": totals["total_to"],
+            "tokens_reasoning": totals["total_tr"],
+            "tokens_cache_read": totals["total_cr"],
+            "tokens_cache_write": totals["total_cw"],
+            "tokens_total": totals["total_ti"] + totals["total_to"] + totals["total_tr"],
+            "first_session": format_ts(first_last["first_ts"]) if first_last["first_ts"] else None,
+            "last_session": format_ts(first_last["last_ts"]) if first_last["last_ts"] else None,
+            "top_models": [
+                {"model": parse_model(m), "count": m["cnt"], "cost": m["cost"]} for m in top_models
+            ],
+            "agents": [{"agent": a["agent"], "count": a["cnt"]} for a in agents],
+        }
+        print_json(data)
+        return 0
+
+    total_tokens = totals["total_ti"] + totals["total_to"] + totals["total_tr"]
+    first_date = format_ts(first_last["first_ts"], "%Y-%m-%d") if first_last["first_ts"] else "—"
+    last_date = format_ts(first_last["last_ts"], "%Y-%m-%d") if first_last["last_ts"] else "—"
+
+    print(f"\n  {'=' * 50}")
+    print(f"  {_('stats.header')}")
+    print(f"  {'=' * 50}")
+    print(f"  {_('stats.projects')}:       {project_count}")
+    print(f"  {_('stats.sessions')}:         {session_count}")
+    print(f"  {_('stats.messages')}:      {message_count}")
+    print(f"  {_('stats.parts')}:         {part_count}")
+    print(f"  {_('stats.todos')}:   {todo_count}")
+    print(f"  {'─' * 50}")
+    print(f"  {_('stats.first_session')}:  {first_date}")
+    print(f"  {_('stats.last_session')}:      {last_date}")
+    print(f"  {'─' * 50}")
+    print(f"  {_('stats.tokens_input')}:     {format_tokens(totals['total_ti'])}")
+    print(f"  {_('stats.tokens_output')}:    {format_tokens(totals['total_to'])}")
+    print(f"  {_('stats.tokens_reasoning')}: {format_tokens(totals['total_tr'])}")
+    print(f"  {_('stats.tokens_total')}:     {format_tokens(total_tokens)}")
+    print(f"  {_('stats.cost')}:         {format_cost(totals['total_cost'])}")
+
+    if top_models:
+        print(f"\n  {_('stats.top_models')}:")
+        for m in top_models:
+            model_str = parse_model(m)
+            print(f"    {m['cnt']:4d}×  {model_str:30s}  ({format_cost(m['cost'] or 0)})")
+
+    if agents:
+        print(f"\n  {_('stats.agents')}:")
+        for a in agents:
+            print(f"    {a['cnt']:4d}×  {a['agent']}")
+
+    print()
+    return 0

cmd_todos.py

@@ -0,0 +1,90 @@
+"""Команда todos: просмотр задач (todo) из сессий."""
+
+from typing import Literal
+
+from db import resolve_session_id
+from i18n import _
+from utils import format_ts
+
+
+def register(subparsers) -> None:
+    p = subparsers.add_parser("todos", help=_("help.cmd.todos"))
+    p.add_argument("session_id", nargs="?", help="Session ID")
+    p.add_argument(
+        "--status",
+        choices=["pending", "completed", "cancelled"],
+        help="Filter by status",
+    )
+    p.add_argument("--limit", type=int, default=30, help="Max entries")
+    p.add_argument("--json", action="store_true", help="JSON output")
+
+
+def run(args, db) -> Literal[0]:
+    conditions = []
+    params = []
+
+    if args.session_id:
+        full_id = resolve_session_id(db, args.session_id)
+        conditions.append("t.session_id = ?")
+        params.append(full_id)
+
+    if args.status:
+        conditions.append("t.status = ?")
+        params.append(args.status)
+
+    where = " AND ".join(conditions) if conditions else "1=1"
+
+    rows = db.execute(
+        f"""
+        SELECT t.session_id, t.content, t.status, t.priority,
+               t.position, t.time_created, t.time_updated,
+               s.title as session_title
+        FROM todo t
+        JOIN session s ON s.id = t.session_id
+        WHERE {where}
+        ORDER BY t.time_created DESC
+        LIMIT ?
+    """,
+        (*params, args.limit),
+    ).fetchall()
+
+    if args.json:
+        from formatters import print_json
+
+        data = []
+        for r in rows:
+            data.append(
+                {
+                    "session_id": r["session_id"][:24],
+                    "session_title": r["session_title"],
+                    "content": r["content"],
+                    "status": r["status"],
+                    "priority": r["priority"],
+                    "created": format_ts(r["time_created"]) if r["time_created"] else None,
+                }
+            )
+        print_json(data)
+        return 0
+
+    if not rows:
+        print(_("todos.none"))
+        return 0
+
+    status_icon = {"pending": "⏳", "completed": "✅", "cancelled": "❌"}
+    priority_mark = {"high": " 🔴", "medium": "", "low": " 🟢"}
+
+    print(_("todos.header", n=len(rows)))
+    print(f"  {'─' * 55}")
+
+    for r in rows:
+        icon = status_icon.get(r["status"], "📝")
+        prio = priority_mark.get(r["priority"], "")
+        created = format_ts(r["time_created"], "%Y-%m-%d") if r["time_created"] else "—"
+        title = r["session_title"] or "—"
+
+        print(f"  {icon} {r['content'][:60]}{prio}")
+        print(f"     {_('todos.session')}: {title[:40]}")
+        print(f"     {_('todos.status')}: {r['status']}, {_('todos.created')}: {created}")
+        print()
+
+    return 0

cmd_tree.py

@@ -0,0 +1,95 @@
+"""Команда tree: дерево ветвления сессий."""
+
+from typing import Literal
+
+from db import get_session_title, resolve_session_id
+from i18n import _
+from utils import format_ts
+
+
+def register(subparsers) -> None:
+    p = subparsers.add_parser("tree", help=_("help.cmd.tree"))
+    p.add_argument("session_id", nargs="?", help="Start from this session")
+    p.add_argument("--project", type=str, help="Filter by project")
+    p.add_argument("--depth", type=int, default=5, help="Max depth")
+
+
+def _build_tree(db, parent_id, depth, max_depth, indent=0, visited=None):
+    if visited is None:
+        visited = set()
+    if depth > max_depth:
+        return []
+
+    lines = []
+
+    if parent_id is None:
+        rows = db.execute("""
+            SELECT id, title, time_created
+            FROM session
+            WHERE parent_id IS NULL
+            ORDER BY time_created
+        """).fetchall()
+    else:
+        rows = db.execute(
+            """
+            SELECT id, title, time_created
+            FROM session
+            WHERE parent_id = ?
+            ORDER BY time_created
+        """,
+            (parent_id,),
+        ).fetchall()
+
+    for r in rows:
+        if r["id"] in visited:
+            continue
+        visited.add(r["id"])
+
+        prefix = "  " * indent + ("└─ " if indent > 0 else "")
+        title = get_session_title(r)
+        created = format_ts(r["time_created"], "%Y-%m-%d")
+        lines.append(f"{prefix}{r['id'][:24]}  {created}  {title}")
+
+        lines.extend(_build_tree(db, r["id"], depth + 1, max_depth, indent + 1, visited))
+
+    return lines
+
+
+def run(args, db) -> Literal[0]:
+    if args.session_id:
+        full_id = resolve_session_id(db, args.session_id)
+        info = db.execute(
+            "SELECT id, title, time_created FROM session WHERE id = ?", (full_id,)
+        ).fetchone()
+
+        title = get_session_title(info)
+        print(f"\n  {_('tree.header', title=title)}")
+        print(f"  {'─' * 55}")
+
+        lines = _build_tree(db, full_id, 1, args.depth, 0)
+        for line in lines:
+            print(f"  {line}")
+
+    elif args.project:
+        print(f"\n  {_('tree.header_project', project=args.project)}")
+        print(f"  {'─' * 55}")
+
+        lines = _build_tree(db, None, 1, args.depth, 0)
+        project_lines = []
+        for line in lines:
+            sid = line.split("  ")[0].strip().lstrip("└─ ")
+            row = db.execute("SELECT project_id FROM session WHERE id = ?", (sid,)).fetchone()
+            if row and row["project_id"] == args.project:
+                project_lines.append(line)
+        for line in project_lines:
+            print(f"  {line}")
+
+    else:
+        print(f"\n  {_('tree.header_all')}")
+        print(f"  {'─' * 55}")
+        lines = _build_tree(db, None, 1, args.depth, 0)
+        for line in lines:
+            print(f"  {line}")
+
+    print()
+    return 0

cmd_vacuum.py

@@ -0,0 +1,67 @@
+"""Команда vacuum: оптимизация базы данных."""
+
+import os
+from typing import Literal
+
+from config import OPENCODE_DB
+from i18n import _
+from utils import confirm
+
+
+def register(subparsers) -> None:
+    p = subparsers.add_parser("vacuum", help=_("help.cmd.vacuum"))
+    p.add_argument("--force", "-f", action="store_true", help="Skip confirmation")
+
+
+def run(args, db) -> Literal[0] | Literal[1]:
+    try:
+        size_before = os.path.getsize(OPENCODE_DB)
+    except OSError:
+        size_before = 0
+
+    size_before_mb = size_before / (1024 * 1024)
+
+    print(f"\n  {_('vacuum.header')}")
+    print(f"  {'─' * 40}")
+    print(f"  {_('vacuum.size_before')}:   {size_before_mb:.1f} MB")
+    print(f"  {_('vacuum.path')}:        {OPENCODE_DB}")
+
+    if not args.force and not confirm(_("vacuum.confirm")):
+        print(_("vacuum.canceled"))
+        return 0
+
+    print(f"  {_('vacuum.vacuum')}", end=" ", flush=True)
+    try:
+        db.execute("VACUUM")
+        print(_("vacuum.done"))
+    except Exception as e:
+        print(_("vacuum.error", error=e))
+        return 1
+
+    print(f"  {_('vacuum.reindex')}", end=" ", flush=True)
+    try:
+        db.execute("REINDEX")
+        print(_("vacuum.done"))
+    except Exception as e:
+        print(_("vacuum.error", error=e))
+
+    print(f"  {_('vacuum.analyze')}", end=" ", flush=True)
+    try:
+        db.execute("ANALYZE")
+        print(_("vacuum.done"))
+    except Exception as e:
+        print(_("vacuum.error", error=e))
+
+    try:
+        size_after = os.path.getsize(OPENCODE_DB)
+        size_after_mb = size_after / (1024 * 1024)
+        saved = size_before - size_after
+        saved_mb = saved / (1024 * 1024)
+        print(f"\n  {_('vacuum.size_after')}: {size_after_mb:.1f} MB")
+        if saved > 0:
+            print(f"  {_('vacuum.freed')}:  {saved_mb:.1f} MB")
+    except OSError:
+        pass
+
+    print()
+    return 0

commands/__init__.py

@@ -0,0 +1,51 @@
+"""Реестр команд. Импортирует модули команд и регистрирует их.
+
+Каждый модуль (cmd_xxx.py) экспортирует:
+  - register(subparsers) — регистрирует subparser
+  - run(args, db) — выполняет команду
+
+Добавление новой команды:
+  1. Создать cmd_xxx.py
+  2. Добавить import cmd_xxx
+  3. Добавить "xxx": cmd_xxx в COMMANDS
+"""
+
+import cmd_costs
+import cmd_delete
+import cmd_export
+import cmd_help
+import cmd_info
+import cmd_list
+import cmd_projects
+import cmd_prune
+import cmd_search
+import cmd_stats
+import cmd_todos
+import cmd_tree
+import cmd_vacuum
+
+# Словарь {имя_команды: модуль}
+# Модуль должен иметь register(subparsers) и run(args, db)
+COMMANDS = {
+    "list": cmd_list,
+    "info": cmd_info,
+    "export": cmd_export,
+    "delete": cmd_delete,
+    "costs": cmd_costs,
+    "prune": cmd_prune,
+    "search": cmd_search,
+    "tree": cmd_tree,
+    "projects": cmd_projects,
+    "stats": cmd_stats,
+    "todos": cmd_todos,
+    "vacuum": cmd_vacuum,
+    "help": cmd_help,
+}
+
+
+def get_handler(name):
+    return COMMANDS.get(name)
+
+
+def get_all():
+    return COMMANDS

config.py

@@ -0,0 +1,14 @@
+"""Конфигурация и константы opencode-db.
+
+Здесь централизованы пути и общие настройки.
+Стоимость сессий берётся напрямую из БД (session.cost), а не рассчитывается.
+"""
+
+import os
+
+# --- Пути ---
+# База данных opencode. Стандартное расположение для Linux/macOS.
+OPENCODE_DB = os.path.expanduser("~/.local/share/opencode/opencode.db")
+
+# Директории, игнорируемые при сборе snapshot'а проекта
+IGNORE_DIRS = {".git", "node_modules", ".venv", "__pycache__", ".opencode"}