opencode-db 0.3.0__py3-none-any.whl

cli.py

@@ -0,0 +1,70 @@
+"""Точка входа: парсинг аргументов и диспетчеризация команд.
+
+Каждая команда регистрирует свой subparser через register(subparsers).
+Это даёт:
+  - Автоматический --help для каждой команды
+  - Валидацию аргументов
+  - Единообразный интерфейс
+"""
+
+import argparse
+import sys
+from typing import Any, Literal
+
+import commands
+from db import get_db
+from i18n import _, set_lang
+
+
+def build_parser() -> argparse.ArgumentParser:
+    """Создаёт парсер аргументов со всеми подкомандами."""
+    parser = argparse.ArgumentParser(
+        prog="opencode-db",
+        description="OpenCode database manager: browse, export, analyze, clean up sessions.",
+    )
+    parser.add_argument(
+        "--lang",
+        choices=["en", "ru"],
+        default=None,
+        help="Output language / язык вывода (en/ru)",
+    )
+
+    subparsers = parser.add_subparsers(dest="command", required=True)
+    for _name, mod in commands.get_all().items():
+        mod.register(subparsers)
+    return parser
+
+
+def main(argv=None) -> Any | Literal[0] | Literal[1]:
+    """Главная функция. Парсит аргументы, открывает БД, запускает команду.
+
+    Args:
+      argv: список аргументов (по умолчанию sys.argv[1:])
+
+    Returns:
+      int: код возврата (0 = успех, 1 = ошибка)
+    """
+    parser = build_parser()
+
+    if argv is None:
+        argv = sys.argv[1:]
+
+    if not argv:
+        parser.print_help()
+        return 0
+
+    args = parser.parse_args(argv)
+
+    if args.lang:
+        set_lang(args.lang)
+
+    db = get_db()
+
+    try:
+        handler = commands.get_handler(args.command)
+        if handler is None:
+            print(_("cmd.unknown", cmd=args.command))
+            return 1
+        return handler.run(args, db)
+    finally:
+        db.close()

cmd_costs.py

@@ -0,0 +1,197 @@
+"""Команда costs: анализ расходов на токены.
+
+Стоимость берётся напрямую из поля session.cost БД OpenCode.
+"""
+
+from typing import Literal
+
+from db import get_session_info, get_session_title, parse_model
+from i18n import _
+from utils import format_cost, format_tokens
+
+
+def register(subparsers) -> None:
+    p = subparsers.add_parser("costs", help=_("help.cmd.costs"))
+    p.add_argument("session_id", nargs="?", help="Session ID")
+    p.add_argument("--project", type=str, help="Filter by project")
+    p.add_argument("--total", action="store_true", help="Total across all sessions")
+    p.add_argument("--json", action="store_true", help="JSON output")
+    p.add_argument("--limit", type=int, default=30, help="Max rows")
+
+
+def run(args, db) -> Literal[0]:
+    if args.session_id:
+        return _show_session(db, args.session_id, args.json)
+
+    if args.total:
+        return _show_total(db, args.project, args.json)
+
+    return _show_list(db, args.project, args.limit, args.json)
+
+
+def _show_session(db, session_id, as_json) -> Literal[0]:
+    info = get_session_info(db, session_id)
+    title = get_session_title(info)
+    model = parse_model(info)
+
+    ti = info["tokens_input"] or 0
+    to = info["tokens_output"] or 0
+    tr = info["tokens_reasoning"] or 0
+    cost = info["cost"] or 0
+
+    if as_json:
+        from formatters import print_json
+
+        print_json(
+            {
+                "id": info["id"],
+                "title": title,
+                "model": model,
+                "tokens_input": ti,
+                "tokens_output": to,
+                "tokens_reasoning": tr,
+                "tokens_total": ti + to + tr,
+                "cost": cost,
+            }
+        )
+        return 0
+
+    print(f"\n  {_('costs.session')}: {title}")
+    print(f"  {_('costs.model')}: {model}")
+    print(f"  {'─' * 50}")
+    print(f"  {_('costs.input')}:        {format_tokens(ti)}")
+    print(f"  {_('costs.output')}:       {format_tokens(to)}")
+    print(f"  {_('costs.reasoning')}:   {format_tokens(tr)}")
+    if info["tokens_cache_read"]:
+        print(f"  {_('costs.cache_read')}: {format_tokens(info['tokens_cache_read'])}")
+    if info["tokens_cache_write"]:
+        print(f"  {_('costs.cache_write')}:  {format_tokens(info['tokens_cache_write'])}")
+    print(f"  {'─' * 50}")
+    print(f"  {_('costs.total')}:       {format_tokens(ti + to + tr)}")
+    print(f"  {_('costs.cost')}:   {format_cost(cost)}")
+    print()
+    return 0
+
+
+def _show_total(db, project_id, as_json) -> Literal[0]:
+    where = "1=1"
+    params = []
+
+    if project_id:
+        where = "s.project_id = ?"
+        params.append(project_id)
+
+    row = db.execute(
+        f"""
+        SELECT COUNT(*) as cnt,
+               SUM(tokens_input) as ti, SUM(tokens_output) as tok_out,
+               SUM(tokens_reasoning) as tr, SUM(cost) as c
+        FROM session WHERE {where}
+    """,
+        params,
+    ).fetchone()
+
+    cnt = row["cnt"] or 0
+    total_cost = row["c"] or 0
+    total_ti = row["ti"] or 0
+    total_to = row["tok_out"] or 0
+    total_tr = row["tr"] or 0
+
+    if as_json:
+        from formatters import print_json
+
+        print_json(
+            {
+                "sessions": cnt,
+                "tokens_input": total_ti,
+                "tokens_output": total_to,
+                "tokens_reasoning": total_tr,
+                "tokens_total": total_ti + total_to + total_tr,
+                "cost": total_cost,
+            }
+        )
+        return 0
+
+    scope = _("costs.scope_project") if project_id else _("costs.scope_all")
+    print(f"\n  {'=' * 45}")
+    print(f"  {_('costs.total_header', scope=scope)}")
+    print(f"  {_('costs.sessions')}:        {cnt}")
+    print(f"  {'=' * 45}")
+    print(f"  {_('costs.tokens_input')}:     {format_tokens(total_ti)}")
+    print(f"  {_('costs.tokens_output')}:    {format_tokens(total_to)}")
+    print(f"  {_('costs.tokens_reasoning')}: {format_tokens(total_tr)}")
+    print(f"  {_('costs.tokens_total')}:     {format_tokens(total_ti + total_to + total_tr)}")
+    print(f"  {_('costs.cost')}:         {format_cost(total_cost)}")
+    print()
+    return 0
+
+
+def _show_list(db, project_id, limit, as_json) -> Literal[0]:
+    where = "1=1"
+    params = []
+
+    if project_id:
+        where = "s.project_id = ?"
+        params.append(project_id)
+
+    rows = db.execute(
+        f"""
+        SELECT s.id, s.title, s.model,
+               s.tokens_input, s.tokens_output, s.tokens_reasoning,
+               s.cost
+        FROM session s
+        WHERE {where}
+        ORDER BY (s.tokens_input + s.tokens_output) DESC
+        LIMIT ?
+    """,
+        (*params, limit),
+    ).fetchall()
+
+    if as_json:
+        from formatters import print_json
+
+        data = []
+        for r in rows:
+            data.append(
+                {
+                    "id": r["id"],
+                    "title": get_session_title(r),
+                    "model": parse_model(r),
+                    "tokens_total": (r["tokens_input"] or 0)
+                    + (r["tokens_output"] or 0)
+                    + (r["tokens_reasoning"] or 0),
+                    "cost": r["cost"] or 0,
+                }
+            )
+        print_json(data)
+        return 0
+
+    from formatters import print_table_simple
+
+    table = []
+    for r in rows:
+        total_tokens = (
+            (r["tokens_input"] or 0) + (r["tokens_output"] or 0) + (r["tokens_reasoning"] or 0)
+        )
+        table.append(
+            [
+                r["id"][:24],
+                get_session_title(r)[:28],
+                parse_model(r)[:20],
+                format_tokens(total_tokens),
+                format_cost(r["cost"] or 0),
+            ]
+        )
+
+    print_table_simple(
+        [
+            _("list.header.id"),
+            _("list.header.title"),
+            _("list.header.model"),
+            _("costs.total"),
+            _("costs.cost"),
+        ],
+        table,
+    )
+
+    return 0

cmd_delete.py

@@ -0,0 +1,58 @@
+"""Команда delete: удаление сессии."""
+
+from typing import Literal
+
+from db import (
+    get_message_count,
+    get_part_count,
+    get_session_info,
+    get_session_title,
+    parse_model,
+)
+from i18n import _
+from utils import confirm, format_cost, format_ts
+
+
+def register(subparsers) -> None:
+    p = subparsers.add_parser("delete", help=_("help.cmd.delete"))
+    p.add_argument("session_id", help="Session ID to delete")
+    p.add_argument("--dry-run", action="store_true", help="Preview without deleting")
+    p.add_argument("--force", "-f", action="store_true", help="Skip confirmation")
+
+
+def run(args, db) -> Literal[0]:
+    info = get_session_info(db, args.session_id)
+    session_id = info["id"]
+    title = get_session_title(info)
+    model = parse_model(info)
+
+    msg_count = get_message_count(db, session_id)
+    part_count = get_part_count(db, session_id)
+    created = format_ts(info["time_created"])
+
+    print(f"\n{'=' * 50}")
+    print(f"  {_('delete.header')}")
+    print(f"{'=' * 50}")
+    print(f"  {_('delete.id')}:         {session_id}")
+    print(f"  {_('delete.title')}:   {title}")
+    print(f"  {_('delete.model')}:     {model}")
+    print(f"  {_('delete.created')}:    {created}")
+    print(f"  {_('delete.messages')}:  {msg_count}")
+    print(f"  {_('delete.parts')}:     {part_count}")
+    print(f"  {_('delete.cost')}:  {format_cost(info['cost'])}")
+
+    if args.dry_run:
+        print(f"\n{_('delete.dry_run')}")
+        print(f"  {_('delete.dry_run_hint')}")
+        return 0
+
+    if not args.force and not confirm(_("delete.confirm", id=session_id[:24])):
+        print(_("canceled"))
+        return 0
+
+    db.execute("DELETE FROM session WHERE id = ?", (session_id,))
+    db.commit()
+
+    print(f"\n{_('delete.done', id=session_id[:24])}")
+    print(_("delete.done_detail", msg=msg_count, parts=part_count))
+    return 0

cmd_export.py

@@ -0,0 +1,189 @@
+"""Команда export: экспорт диалога в Markdown.
+
+Режимы выбора сессии:
+  - export <session_id>          — по ID (полный или префикс)
+  - export --latest              — самая свежая сессия
+  - export (без аргументов)      — интерактивный выбор из списка
+"""
+
+import os
+from typing import Literal
+
+from db import (
+    get_latest_session,
+    get_messages,
+    get_recent_sessions,
+    get_session_info,
+    get_session_title,
+    parse_model,
+)
+from formatters import collect_snapshot, format_part_to_md, update_log
+from i18n import _
+from utils import format_cost, format_ts, format_ts_short
+
+
+def register(subparsers) -> None:
+    p = subparsers.add_parser("export", help=_("help.cmd.export"))
+    p.add_argument(
+        "session_id",
+        nargs="?",
+        help="Session ID (optional — interactive mode if omitted)",
+    )
+    p.add_argument("--latest", "-l", action="store_true", help="Export the most recent session")
+    p.add_argument(
+        "--full",
+        "-F",
+        action="store_true",
+        help="Full output (do not truncate tool outputs)",
+    )
+    p.add_argument("--force", "-f", action="store_true", help="Overwrite existing file")
+    p.add_argument("--note", "-n", type=str, help="Description for log.md")
+    p.add_argument(
+        "--output",
+        "-o",
+        type=str,
+        default=None,
+        help="Output directory (default: current)",
+    )
+
+
+def _export_by_id(db, session_id, output_dir, force, note, full) -> Literal[1] | Literal[0]:
+    session_info = get_session_info(db, session_id)
+    return _do_export(db, session_info, output_dir, force, note, full)
+
+
+def _export_latest(db, output_dir, force, note, full) -> Literal[1] | Literal[0]:
+    session_id = get_latest_session(db)
+    session_info = get_session_info(db, session_id)
+    title = get_session_title(session_info)
+    print(_("session.latest", title=title))
+    return _do_export(db, session_info, output_dir, force, note, full)
+
+
+def _export_interactive(db, output_dir, force, note, full) -> Literal[1] | Literal[0]:
+    sessions = get_recent_sessions(db)
+
+    if not sessions:
+        print(_("export.no_sessions"))
+        return 1
+
+    print(f"\n  {'─' * 60}")
+    print(f"  {_('export.interactive_header')}")
+    print(f"  {'─' * 60}")
+
+    for i, s in enumerate(sessions, 1):
+        title = get_session_title(s)
+        created = format_ts(s["time_created"], "%Y-%m-%d %H:%M")
+        cost = format_cost(s["cost"])
+        print(f"  {i:2d}. {s['id'][:24]}  {created}  {title[:40]:40s}  {cost}")
+
+    print(f"  {'─' * 60}")
+
+    while True:
+        try:
+            choice = input("  " + _("export.interactive_prompt")).strip()
+        except (EOFError, KeyboardInterrupt):
+            print()
+            return 1
+
+        if not choice:
+            print(_("export.interactive_abort"))
+            return 1
+
+        try:
+            idx = int(choice) - 1
+            if 0 <= idx < len(sessions):
+                break
+        except ValueError:
+            pass
+
+        print(f"  {_('export.interactive_error', n=len(sessions))}")
+
+    session_id = sessions[idx]["id"]
+    title = get_session_title(sessions[idx])
+    print(_("export.interactive_exporting", title=title))
+    session_info = get_session_info(db, session_id)
+    return _do_export(db, session_info, output_dir, force, note, full)
+
+
+def _do_export(db, session_info, output_dir, force, note, full=False) -> Literal[1] | Literal[0]:
+    """Внутренняя функция: экспорт диалога."""
+    title = get_session_title(session_info)
+    model = parse_model(session_info)
+
+    messages = get_messages(db, session_info["id"])
+
+    date_str = format_ts_short(session_info["time_created"])
+    filename = os.path.join(output_dir, f"opencode-{date_str}.md")
+
+    if os.path.isfile(filename) and not force:
+        print(_("export.exists", path=filename))
+        print(_("export.exists_hint"))
+        return 1
+
+    date_display = format_ts(session_info["time_created"])
+
+    md_header = f"""# {_("md.header.title")}: {title}
+
+- **{_("md.header.date")}**: {date_display}
+- **{_("md.header.model")}**: {model}
+- **{_("md.header.session_id")}**: `{session_info["id"][:24]}`
+- **{_("md.header.messages")}**: {len(messages)}
+
+---
+"""
+
+    md_body = []
+    for msg in messages:
+        if not msg.get("parts"):
+            continue
+
+        ts = format_ts(msg["time"], "%H:%M:%S")
+
+        if msg["role"] == "user":
+            md_body.append(f"## {_('export.role_user', ts=ts)}")
+        else:
+            agent_tag = _("export.agent_tag", agent=msg["agent"]) if msg.get("agent") else ""
+            md_body.append(f"## {_('export.role_assistant', ts=ts, agent=agent_tag)}")
+
+        md_body.append("")
+
+        for part in msg["parts"]:
+            formatted = format_part_to_md(part, full=full)
+            if formatted:
+                md_body.append(formatted)
+                md_body.append("")
+
+        md_body.append("---")
+        md_body.append("")
+
+    content = md_header + "\n".join(md_body)
+
+    with open(filename, "w", encoding="utf-8") as f:
+        f.write(content)
+
+    print(_("export.saved", path=filename))
+    print(_("export.messages", n=len(messages)))
+
+    obsidian_dir = os.getcwd()
+    if os.path.isdir(os.path.join(obsidian_dir, ".obsidian")):
+        snapshot = collect_snapshot(obsidian_dir)
+        now_str = format_ts(session_info["time_created"], "%Y-%m-%d %H:%M")
+        update_log(obsidian_dir, title, note, filename, snapshot, now_str)
+    else:
+        print(_("not_obsidian"))
+
+    return 0
+
+
+def run(args, db) -> Literal[1] | Literal[0]:
+    output_dir = args.output or os.getcwd()
+    full = args.full
+
+    if args.session_id:
+        return _export_by_id(db, args.session_id, output_dir, args.force, args.note, full)
+
+    if args.latest:
+        return _export_latest(db, output_dir, args.force, args.note, full)
+
+    return _export_interactive(db, output_dir, args.force, args.note, full)