opencode-db 0.3.0__py3-none-any.whl

cmd_help.py

@@ -0,0 +1,210 @@
+"""Команда help: подробная справка по opencode-db."""
+
+from typing import Literal
+
+from i18n import _
+
+
+def register(subparsers) -> None:
+    p = subparsers.add_parser("help", help=_("help.cmd.help"))
+    p.add_argument("topic", nargs="?", help="Command name")
+    p.add_argument("--json", action="store_true", help="JSON output")
+
+
+_COMMANDS = [
+    (
+        "list",
+        "help.cmd.list",
+        [
+            ("", "help.list.e0"),
+            ("--limit 10", "help.list.e1"),
+            ("--sort cost", "help.list.e2"),
+            ("--project proj_xxx", "help.list.e3"),
+            ("--json", "help.list.e4"),
+        ],
+    ),
+    (
+        "info",
+        "help.cmd.info",
+        [
+            ("<session_id>", "help.info.e0"),
+            ("<session_id> --json", "help.info.e1"),
+        ],
+    ),
+    (
+        "export",
+        "help.cmd.export",
+        [
+            ("<session_id>", "help.export.e0"),
+            ("--latest", "help.export.e1"),
+            ("", "help.export.e2"),
+            ("--full", "help.export.e3"),
+            ("--force", "help.export.e4"),
+            ('--note "text"', "help.export.e5"),
+        ],
+    ),
+    (
+        "delete",
+        "help.cmd.delete",
+        [
+            ("<session_id>", "help.delete.e0"),
+            ("<session_id> --dry-run", "help.delete.e1"),
+            ("<session_id> --force", "help.delete.e2"),
+        ],
+    ),
+    (
+        "costs",
+        "help.cmd.costs",
+        [
+            ("", "help.costs.e0"),
+            ("<session_id>", "help.costs.e1"),
+            ("--total", "help.costs.e2"),
+            ("--project proj_xxx", "help.costs.e3"),
+            ("--json", "help.costs.e4"),
+        ],
+    ),
+    (
+        "prune",
+        "help.cmd.prune",
+        [
+            ("--older-than 90d", "help.prune.e0"),
+            ("--keep-last 20", "help.prune.e1"),
+            ("--dry-run", "help.prune.e2"),
+            ("--force", "help.prune.e3"),
+        ],
+    ),
+    (
+        "search",
+        "help.cmd.search",
+        [
+            ('"text"', "help.search.e0"),
+            ('"text" --session ses_1c9d', "help.search.e1"),
+            ('"text" --json', "help.search.e2"),
+        ],
+    ),
+    (
+        "tree",
+        "help.cmd.tree",
+        [
+            ("", "help.tree.e0"),
+            ("<session_id>", "help.tree.e1"),
+            ("--depth 3", "help.tree.e2"),
+        ],
+    ),
+    (
+        "projects",
+        "help.cmd.projects",
+        [
+            ("", "help.projects.e0"),
+            ("--json", "help.projects.e1"),
+        ],
+    ),
+    (
+        "stats",
+        "help.cmd.stats",
+        [
+            ("", "help.stats.e0"),
+            ("--json", "help.stats.e1"),
+        ],
+    ),
+    (
+        "todos",
+        "help.cmd.todos",
+        [
+            ("", "help.todos.e0"),
+            ("<session_id>", "help.todos.e1"),
+            ("--status pending", "help.todos.e2"),
+            ("--json", "help.todos.e3"),
+        ],
+    ),
+    (
+        "vacuum",
+        "help.cmd.vacuum",
+        [
+            ("", "help.vacuum.e0"),
+            ("--force", "help.vacuum.e1"),
+        ],
+    ),
+]
+
+_COMMAND_MAP: dict[str, tuple[str, list]] = {}
+for name, desc_key, examples in _COMMANDS:
+    _COMMAND_MAP[name] = (desc_key, examples)
+
+
+def _print_general_help() -> None:
+    """Вывод полной справки."""
+    print()
+    print(f"  {_('help.header_box_top')}")
+    print(f"  {_('help.header_title')}")
+    print(f"  {_('help.header_box_bottom')}")
+    print()
+    print(f"  {_('help.intro')}")
+    print(f"  {_('help.intro2')}")
+    print()
+    print(f"  {_('help.usage')}")
+    print()
+
+    for name, desc_key, examples in _COMMANDS:
+        desc = _(desc_key)
+        print(f"  {name:12s}  {desc}")
+        for flag, example_key in examples:
+            example_desc = _(example_key)
+            if flag:
+                print(f"    {'':12s}  opencode-db {name} {flag:30s}  # {example_desc}")
+            else:
+                print(f"    {'':12s}  opencode-db {name:33s}  # {example_desc}")
+        print()
+
+    print(f"  {'─' * 58}")
+    print(f"  {_('help.footer')}")
+    print(f"  {_('help.footer2')}")
+    print(f"  {_('help.footer3')}")
+    print()
+
+
+def _print_command_help(cmd_name) -> Literal[1] | Literal[0]:
+    """Вывод справки по одной команде."""
+    entry = _COMMAND_MAP.get(cmd_name)
+    if not entry:
+        print(f"{_('help.unknown', cmd=cmd_name)}")
+        print(f"   {_('help.available', cmds=', '.join(_COMMAND_MAP))}")
+        return 1
+
+    desc_key, examples = entry
+    print()
+    print(_("help.cmd_header", cmd=cmd_name, desc=_(desc_key)))
+    print()
+    for flag, example_key in examples:
+        example_desc = _(example_key)
+        if flag:
+            print(f"    opencode-db {cmd_name} {flag:30s}  # {example_desc}")
+        else:
+            print(f"    opencode-db {cmd_name:33s}  # {example_desc}")
+    print()
+    return 0
+
+
+def run(args, db) -> Literal[1] | Literal[0]:
+    import json
+
+    if args.topic:
+        return _print_command_help(args.topic)
+
+    if args.json:
+        data = []
+        for name, desc_key, examples in _COMMANDS:
+            data.append(
+                {
+                    "name": name,
+                    "description": _(desc_key),
+                    "examples": [
+                        {"args": flag, "comment": _(example_key)} for flag, example_key in examples
+                    ],
+                }
+            )
+        print(json.dumps(data, ensure_ascii=False, indent=2))
+        return 0
+
+    _print_general_help()
+    return 0

cmd_info.py

@@ -0,0 +1,152 @@
+"""Команда info: детальная информация о сессии."""
+
+# import db as db_module
+from typing import Literal
+
+from db import (
+    get_children_sessions,
+    get_message_count,
+    get_parent_session,
+    get_part_count,
+    get_project_name,
+    get_session_info,
+    get_session_title,
+    get_session_todos,
+    parse_model,
+)
+from i18n import _
+from utils import format_cost, format_tokens, format_ts
+
+
+def register(subparsers) -> None:
+    p = subparsers.add_parser("info", help=_("help.cmd.info"))
+    p.add_argument("session_id", help="Session ID")
+    p.add_argument("--json", action="store_true", help="JSON output")
+
+
+def run(args, db) -> Literal[0]:
+    info = get_session_info(db, args.session_id)
+    session_id = info["id"]
+    msg_count = get_message_count(db, session_id)
+    part_count = get_part_count(db, session_id)
+    children = get_children_sessions(db, session_id)
+    parent = get_parent_session(db, session_id)
+    todos = get_session_todos(db, session_id)
+    project_name = get_project_name(db, info["project_id"]) if info["project_id"] else "—"
+
+    model = parse_model(info)
+    title = get_session_title(info)
+    created = format_ts(info["time_created"])
+    updated = format_ts(info["time_updated"])
+
+    if info["time_updated"] and info["time_created"]:
+        duration_sec = (info["time_updated"] - info["time_created"]) / 1000
+        if duration_sec < 60:
+            duration = _("info.dur_sec", n=int(duration_sec))
+        elif duration_sec < 3600:
+            duration = _("info.dur_min", n=int(duration_sec / 60))
+        else:
+            hours = int(duration_sec / 3600)
+            mins = int((duration_sec % 3600) / 60)
+            duration = _("info.dur_hours", h=hours, m=mins)
+    else:
+        duration = "—"
+
+    if args.json:
+        data = {
+            "id": info["id"],
+            "title": title,
+            "project": {"id": info["project_id"], "name": project_name},
+            "model": model,
+            "agent": info["agent"],
+            "version": info["version"],
+            "directory": info["directory"],
+            "parent_id": info["parent_id"],
+            "time_created": created,
+            "time_updated": updated,
+            "duration": duration,
+            "messages": msg_count,
+            "parts": part_count,
+            "cost": info["cost"],
+            "tokens": {
+                "input": info["tokens_input"],
+                "output": info["tokens_output"],
+                "reasoning": info["tokens_reasoning"],
+                "cache_read": info["tokens_cache_read"],
+                "cache_write": info["tokens_cache_write"],
+            },
+            "code_changes": {
+                "additions": info["summary_additions"],
+                "deletions": info["summary_deletions"],
+                "files": info["summary_files"],
+            },
+            "children": [{"id": c["id"], "title": c["title"]} for c in children]
+            if children
+            else [],
+            "todos": [{"content": t["content"], "status": t["status"]} for t in todos]
+            if todos
+            else [],
+        }
+        if parent:
+            data["parent"] = {"id": parent["id"], "title": parent["title"]}
+
+        from formatters import print_json
+
+        print_json(data)
+        return 0
+
+    print(f"\n{'=' * 60}")
+    print(f"  {title}")
+    print(f"{'=' * 60}")
+    print(f"  {_('info.id')}:        {session_id}")
+    print(f"  {_('info.project')}:    {project_name} ({info['project_id'][:24]})")
+    print(f"  {_('info.model')}:    {model}")
+    print(f"  {_('info.agent')}:     {info['agent'] or '—'}")
+    print(f"  {_('info.version')}:    {info['version'] or '—'}")
+    print(f"  {_('info.created')}:   {created}")
+    print(f"  {_('info.updated')}:   {updated}")
+    print(f"  {_('info.duration')}:  {duration}")
+
+    if parent:
+        parent_title = parent["title"] or _("info.unnamed")
+        print(f"  {_('info.parent')}:  {parent['id'][:24]} — {parent_title}")
+
+    if children:
+        print(f"  {_('info.branches')}:     {len(children)}")
+        for c in children:
+            c_title = c["title"] or _("info.unnamed")
+            print(_("info.children_prefix", id=c["id"][:24], title=c_title))
+
+    print(f"\n  {'─' * 56}")
+    print(f"  {_('info.messages')}: {msg_count}")
+    print(f"  {_('info.parts')}:    {part_count}")
+    print(f"  {'─' * 56}")
+
+    print(f"  {_('info.tokens_input')}:     {format_tokens(info['tokens_input'])}")
+    print(f"  {_('info.tokens_output')}:    {format_tokens(info['tokens_output'])}")
+    print(f"  {_('info.tokens_reasoning')}: {format_tokens(info['tokens_reasoning'])}")
+    if info["tokens_cache_read"]:
+        print(f"  {_('info.cache_read')}:     {format_tokens(info['tokens_cache_read'])}")
+    if info["tokens_cache_write"]:
+        print(f"  {_('info.cache_write')}:      {format_tokens(info['tokens_cache_write'])}")
+    total_tokens = (info["tokens_input"] or 0) + (info["tokens_output"] or 0)
+    print(f"  {_('info.tokens_total')}:    {format_tokens(total_tokens)}")
+    print(f"  {_('info.cost')}:        {format_cost(info['cost'])}")
+
+    if info["summary_files"]:
+        print(f"\n  {'─' * 56}")
+        print(f"  {_('info.code_changes')}:")
+        print(f"    {_('info.files_changed')}:    {info['summary_files']}")
+        print(f"    {_('info.lines_added')}: {info['summary_additions'] or 0}")
+        print(f"    {_('info.lines_deleted')}:   {info['summary_deletions'] or 0}")
+
+    if todos:
+        print(f"\n  {'─' * 56}")
+        print(f"  {_('info.todos')}:")
+        status_icon = {"pending": "⏳", "completed": "✅", "cancelled": "❌"}
+        for t in todos:
+            icon = status_icon.get(t["status"], "📝")
+            print(f"    {icon} {t['content'][:60]}")
+
+    print()
+    return 0

cmd_list.py

@@ -0,0 +1,124 @@
+"""Команда list: список сессий с фильтрацией и сортировкой."""
+
+from typing import Literal
+
+import db as db_module
+from db import get_session_title, parse_model
+from formatters import print_json, print_table_simple
+from i18n import _
+from utils import format_ts
+
+
+def register(subparsers) -> None:
+    p = subparsers.add_parser("list", help=_("help.cmd.list"))
+    p.add_argument("--limit", type=int, default=25, help="Max results (default 25)")
+    p.add_argument("--offset", type=int, default=0, help="Offset")
+    p.add_argument("--project", type=str, help="Filter by project ID")
+    p.add_argument("--agent", type=str, help="Filter by agent type")
+    p.add_argument("--model", type=str, help="Filter by model name")
+    p.add_argument(
+        "--sort",
+        choices=["date", "cost", "tokens", "messages"],
+        default="date",
+        help="Sort order (default: date)",
+    )
+    p.add_argument("--json", action="store_true", help="JSON output")
+    p.add_argument("--all", action="store_true", help="Show all (no limit)")
+
+
+def run(args, db) -> Literal[0]:
+    conditions = []
+    params = []
+
+    if args.project:
+        conditions.append("s.project_id = ?")
+        params.append(args.project)
+
+    if args.agent:
+        conditions.append("s.agent = ?")
+        params.append(args.agent)
+
+    if args.model:
+        conditions.append("s.model LIKE ?")
+        params.append(f"%{args.model}%")
+
+    where = " AND ".join(conditions) if conditions else "1=1"
+
+    sort_map = {
+        "date": "COALESCE(MAX(m.time_created), s.time_created) DESC",
+        "cost": "s.cost DESC",
+        "tokens": "(s.tokens_input + s.tokens_output) DESC",
+        "messages": "msg_count DESC",
+    }
+    order = sort_map.get(args.sort, "COALESCE(MAX(m.time_created), s.time_created) DESC")
+
+    limit = 999999 if args.all else args.limit
+
+    rows = db.execute(
+        f"""
+        SELECT s.id, s.title, s.model, s.project_id, s.agent,
+               s.cost, s.tokens_input, s.tokens_output,
+               MAX(m.time_created) as last_time,
+               COUNT(DISTINCT m.id) as msg_count
+        FROM session s
+        LEFT JOIN message m ON m.session_id = s.id
+        WHERE {where}
+        GROUP BY s.id
+        ORDER BY {order}
+        LIMIT ? OFFSET ?
+    """,
+        (*params, limit, args.offset),
+    ).fetchall()
+
+    if args.json:
+        data = []
+        for r in rows:
+            data.append(
+                {
+                    "id": r["id"],
+                    "title": get_session_title(r),
+                    "project_id": r["project_id"],
+                    "model": parse_model(r),
+                    "agent": r["agent"],
+                    "cost": r["cost"],
+                    "tokens_input": r["tokens_input"],
+                    "tokens_output": r["tokens_output"],
+                    "messages": r["msg_count"],
+                    "last_activity": format_ts(r["last_time"]) if r["last_time"] else None,
+                }
+            )
+        print_json(data)
+        return 0
+
+    table_rows = []
+    for r in rows:
+        project_name = db_module.get_project_name(db, r["project_id"]) if r["project_id"] else "—"
+        model_name = parse_model(r)
+        last_act = format_ts(r["last_time"], "%Y-%m-%d %H:%M") if r["last_time"] else "—"
+
+        table_rows.append(
+            [
+                r["id"][:24],
+                get_session_title(r)[:32],
+                project_name[:16],
+                model_name[:20],
+                last_act,
+                str(r["msg_count"]),
+                f"${r['cost']:.4f}" if r["cost"] else "—",
+            ]
+        )
+
+    print_table_simple(
+        [
+            _("list.header.id"),
+            _("list.header.title"),
+            _("list.header.project"),
+            _("list.header.model"),
+            _("list.header.activity"),
+            _("list.header.messages"),
+            _("list.header.cost"),
+        ],
+        table_rows,
+    )
+
+    return 0

cmd_projects.py

@@ -0,0 +1,82 @@
+"""Команда projects: список проектов со статистикой."""
+
+from typing import Literal
+
+from i18n import _
+from utils import format_cost, format_tokens, format_ts
+
+
+def register(subparsers) -> None:
+    p = subparsers.add_parser("projects", help=_("help.cmd.projects"))
+    p.add_argument("--json", action="store_true", help="JSON output")
+
+
+def run(args, db) -> Literal[0]:
+    rows = db.execute("""
+        SELECT p.id, p.name, p.worktree, p.time_created, p.time_updated,
+               COUNT(DISTINCT s.id) as session_count,
+               COALESCE(SUM(s.cost), 0) as total_cost,
+               COALESCE(SUM(s.tokens_input), 0) as total_ti,
+               COALESCE(SUM(s.tokens_output), 0) as total_to,
+               COALESCE(SUM(s.tokens_reasoning), 0) as total_tr
+        FROM project p
+        LEFT JOIN session s ON s.project_id = p.id
+        GROUP BY p.id
+        ORDER BY p.time_updated DESC
+    """).fetchall()
+
+    if args.json:
+        from formatters import print_json
+
+        data = []
+        for r in rows:
+            data.append(
+                {
+                    "id": r["id"],
+                    "name": r["name"],
+                    "worktree": r["worktree"],
+                    "time_created": format_ts(r["time_created"]) if r["time_created"] else None,
+                    "time_updated": format_ts(r["time_updated"]) if r["time_updated"] else None,
+                    "sessions": r["session_count"],
+                    "cost": r["total_cost"],
+                    "tokens_input": r["total_ti"],
+                    "tokens_output": r["total_to"],
+                    "tokens_reasoning": r["total_tr"],
+                    "tokens_total": r["total_ti"] + r["total_to"] + r["total_tr"],
+                }
+            )
+        print_json(data)
+        return 0
+
+    from formatters import print_table_simple
+
+    table = []
+    for r in rows:
+        name = r["name"] or "—"
+        updated = format_ts(r["time_updated"], "%Y-%m-%d") if r["time_updated"] else "—"
+        total_tokens = r["total_ti"] + r["total_to"] + r["total_tr"]
+
+        table.append(
+            [
+                r["id"][:12],
+                name[:20],
+                updated,
+                str(r["session_count"]),
+                format_tokens(total_tokens),
+                format_cost(r["total_cost"]),
+            ]
+        )
+
+    print_table_simple(
+        [
+            _("projects.header.id"),
+            _("projects.header.name"),
+            _("projects.header.activity"),
+            _("projects.header.sessions"),
+            _("projects.header.tokens"),
+            _("projects.header.cost"),
+        ],
+        table,
+    )
+
+    return 0

cmd_prune.py

@@ -0,0 +1,127 @@
+"""Команда prune: массовая очистка старых сессий."""
+
+# from db import get_session_info, get_session_title, parse_model, \
+#     get_message_count, get_part_count
+from typing import Literal
+
+from i18n import _
+from utils import confirm, format_ts, parse_time_spec
+
+
+def register(subparsers) -> None:
+    p = subparsers.add_parser("prune", help=_("help.cmd.prune"))
+    p.add_argument("--older-than", type=str, help="Delete sessions older than (30d, 6m, 1y)")
+    p.add_argument("--keep-last", type=int, help="Keep N most recent sessions")
+    p.add_argument("--project", type=str, help="Limit to project")
+    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[1] | Literal[0]:
+    if not args.older_than and not args.keep_last and not args.project:
+        print(_("prune.filter_required"))
+        print(_("prune.filter_example"))
+        return 1
+
+    conditions = []
+    params = []
+
+    if args.project:
+        conditions.append("s.project_id = ?")
+        params.append(args.project)
+
+    if args.older_than:
+        cutoff = parse_time_spec(args.older_than)
+        if cutoff is None:
+            print(_("prune.bad_spec", spec=args.older_than))
+            print(_("prune.bad_spec_hint"))
+            return 1
+        cutoff_ms = int(cutoff.timestamp() * 1000)
+        conditions.append("s.time_created < ?")
+        params.append(cutoff_ms)
+
+    exclude_ids = set()
+    if args.keep_last:
+        inner_where = " AND ".join(conditions) if conditions else "1=1"
+        keep_rows = db.execute(
+            f"""
+            SELECT s.id FROM session s
+            WHERE {inner_where}
+            ORDER BY s.time_created DESC
+            LIMIT ?
+        """,
+            (*params, args.keep_last),
+        ).fetchall()
+        exclude_ids = {r["id"] for r in keep_rows}
+
+    where = " AND ".join(conditions) if conditions else "1=1"
+
+    if exclude_ids:
+        placeholders = ",".join("?" for _ in exclude_ids)
+        target_rows = db.execute(
+            f"""
+            SELECT s.id, s.title, s.model, s.time_created, s.cost
+            FROM session s
+            WHERE {where}
+              AND s.id NOT IN ({placeholders})
+            ORDER BY s.time_created DESC
+        """,
+            (*params, *exclude_ids),
+        ).fetchall()
+    else:
+        target_rows = db.execute(
+            f"""
+            SELECT s.id, s.title, s.model, s.time_created, s.cost
+            FROM session s
+            WHERE {where}
+            ORDER BY s.time_created DESC
+        """,
+            params,
+        ).fetchall()
+
+    if not target_rows:
+        print(_("prune.none"))
+        return 0
+
+    total_cost = sum(r["cost"] or 0 for r in target_rows)
+    total_tokens = sum(
+        db.execute(
+            "SELECT COALESCE(SUM(tokens_input + tokens_output), 0) FROM session WHERE id = ?",
+            (r["id"],),
+        ).fetchone()[0]
+        for r in target_rows
+    )
+
+    print(f"\n  {'=' * 55}")
+    print(f"  {_('prune.header', n=len(target_rows))}")
+    print(f"  {'=' * 55}")
+
+    for r in target_rows[:20]:
+        created = format_ts(r["time_created"])
+        print(f"    • {r['id'][:24]}  {created}  {r['title'] or '—'}")
+
+    if len(target_rows) > 20:
+        print(f"    … и ещё {len(target_rows) - 20}")
+
+    print(f"\n  {_('prune.cost_total', cost=f'${total_cost:.4f}')}")
+    print(f"  {_('prune.tokens_total', n=str(total_tokens))}")
+
+    if args.dry_run:
+        print(f"\n{_('prune.dry_run')}")
+        return 0
+
+    if not args.force and not confirm(_("prune.confirm", n=len(target_rows))):
+        print(_("canceled"))
+        return 0
+
+    ids_to_delete = [r["id"] for r in target_rows]
+    placeholders = ",".join("?" for _ in ids_to_delete)
+
+    db.execute(f"DELETE FROM part WHERE session_id IN ({placeholders})", ids_to_delete)
+    db.execute(f"DELETE FROM message WHERE session_id IN ({placeholders})", ids_to_delete)
+    db.execute(f"DELETE FROM todo WHERE session_id IN ({placeholders})", ids_to_delete)
+    db.execute(f"DELETE FROM session WHERE id IN ({placeholders})", ids_to_delete)
+    db.commit()
+
+    print(f"\n{_('prune.done', n=len(ids_to_delete))}")
+    return 0