opencode-db 0.5.0__tar.gz → 0.6.0__tar.gz

{opencode_db-0.5.0/opencode_db.egg-info → opencode_db-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opencode-db
-Version: 0.5.0
+Version: 0.6.0
 Summary: OpenCode database CLI manager — browse, export, analyze, clean up sessions
 Project-URL: Homepage, https://github.com/VasilevNStas/opencode-db
 Project-URL: Source, https://github.com/VasilevNStas/opencode-db

{opencode_db-0.5.0 → opencode_db-0.6.0}/README.md

@@ -210,20 +210,35 @@ If the project directory contains `.obsidian`, a `log.md` file is automatically
 
 ---
 
-### `delete` — delete a session
+### `delete` — delete sessions
 
-Removes a session and all related data (messages, parts, todos) thanks to CASCADE constraints in the database schema.
+Removes sessions and all related data (messages, parts, todos). Supports single deletion by ID or bulk deletion with filters.
 
 ```bash
-opencode-db delete ses_1c9d --dry-run    # show what would be deleted
-opencode-db delete ses_1c9d              # delete with confirmation
-opencode-db delete ses_1c9d --force      # delete without confirmation
+opencode-db delete ses_1c9d                              # single session with confirmation
+opencode-db delete ses_1c9d --force                      # single session, no confirmation
+opencode-db delete ses_1c9d --dry-run                    # preview what would be deleted
+opencode-db delete --older-than 90d                      # sessions older than 90 days
+opencode-db delete --older-than 6m --dry-run             # preview sessions older than 6 months
+opencode-db delete --keep-last 30                        # keep 30 most recent, delete the rest
+opencode-db delete --before 2026-05-20                   # sessions before a specific date
+opencode-db delete --after 2026-01-01                    # sessions after a specific date
+opencode-db delete --project proj_xxx                    # sessions in a specific project
+opencode-db delete --older-than 90d --keep-last 20       # combined filters
+opencode-db delete --interactive                         # choose from a list interactively
 ```
 
 | Flag | Description |
 |---|---|
+| `session_id` | Session ID (optional with `--interactive`) |
+| `--older-than` | Delete sessions older than (e.g. `30d`, `6m`, `1y`) |
+| `--before` | Delete sessions before date (`YYYY-MM-DD`) |
+| `--after` | Delete sessions after date (`YYYY-MM-DD`) |
+| `--keep-last` | Keep N most recent, delete the rest |
+| `--project` | Limit to a specific project |
 | `--dry-run` | Only show what would be deleted |
 | `--force`, `-f` | Skip confirmation prompt |
+| `--interactive` | Pick sessions from a list |
 
 ---
 
@@ -252,31 +267,17 @@ Costs are taken directly from the database (`session.cost`), which stores the ac
 
 ---
 
-### `prune` — bulk cleanup of old sessions
+### `prune` — alias for `delete` (bulk cleanup)
 
-Deletes sessions by age, project, or keeps a specified number of the most recent ones.
+Alias for `delete` with the same flags: `--older-than`, `--keep-last`, `--project`, `--dry-run`, `--force`.
 
 ```bash
-opencode-db prune --older-than 30d --dry-run    # preview deletions
-opencode-db prune --older-than 90d              # delete sessions older than 90 days
-opencode-db prune --older-than 6m               # older than 6 months
-opencode-db prune --older-than 1y               # older than 1 year
-opencode-db prune --keep-last 20                # keep the 20 most recent
-opencode-db prune --older-than 30d --keep-last 10  # combined filters
-opencode-db prune --project proj_xxx            # per project
-opencode-db prune --older-than 30d --force      # skip confirmation
+opencode-db prune --older-than 90d         # same as opencode-db delete --older-than 90d
+opencode-db prune --keep-last 20           # same as opencode-db delete --keep-last 20
 ```
 
 Time spec formats: `30d` (days), `6m` (months), `1y` (years).
 
-| Flag | Description |
-|---|---|
-| `--older-than SPEC` | Delete sessions older than the given duration |
-| `--keep-last N` | Keep N most recent sessions |
-| `--project ID` | Limit to a specific project |
-| `--dry-run` | Only show what would be deleted |
-| `--force`, `-f` | Skip confirmation prompt |
-
 ---
 
 ### `search` — search across messages
@@ -409,7 +410,7 @@ Example output:
 
 ```
   ╔══════════════════════════════════════════════════════════╗
-  ║                 opencode-db — справка                   ║
+  ║                 opencode-db — справка                    ║
   ╚══════════════════════════════════════════════════════════╝
 
   Использование: opencode-db <команда> [флаги]

{opencode_db-0.5.0 → opencode_db-0.6.0}/cmd_costs.py

@@ -3,13 +3,28 @@
 Стоимость берётся напрямую из поля session.cost БД OpenCode.
 """
 
+import argparse
+
 from db import SessionError, get_session_info, get_session_title, parse_model
 from i18n import _
-from utils import format_cost, format_tokens
+from utils import build_help_epilog, format_cost, format_tokens
+
+_COSTS_EXAMPLES = [
+    ("", "help.costs.e0"),
+    ("<session_id>", "help.costs.e1"),
+    ("--total", "help.costs.e2"),
+    ("--project proj_xxx", "help.costs.e3"),
+    ("--json", "help.costs.e4"),
+]
 
 
 def register(subparsers) -> None:
-    p = subparsers.add_parser("costs", help=_("help.cmd.costs"))
+    p = subparsers.add_parser(
+        "costs",
+        help=_("help.cmd.costs"),
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=build_help_epilog("costs", _COSTS_EXAMPLES),
+    )
     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")

opencode_db-0.6.0/cmd_delete.py

@@ -0,0 +1,343 @@
+"""Команда delete: удаление сессии или массовая очистка."""
+
+import argparse
+
+from db import (
+    SessionError,
+    get_message_count,
+    get_part_count,
+    get_recent_sessions,
+    get_session_info,
+    get_session_title,
+    parse_model,
+)
+from i18n import _
+from utils import build_help_epilog, confirm, format_cost, format_ts, parse_date, parse_time_spec
+
+_DELETE_EXAMPLES = [
+    ("<session_id>", "help.delete.e0"),
+    ("<session_id> --dry-run", "help.delete.e1"),
+    ("<session_id> --force", "help.delete.e2"),
+    ("--older-than 90d", "help.delete.e3"),
+    ("--keep-last 30", "help.delete.e4"),
+    ("--before 2026-05-20", "help.delete.e5"),
+    ("--interactive", "help.delete.e6"),
+]
+
+
+def register(subparsers) -> None:
+    p = subparsers.add_parser(
+        "delete",
+        help=_("help.cmd.delete"),
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=build_help_epilog("delete", _DELETE_EXAMPLES),
+    )
+    p.add_argument("session_id", nargs="?", help="Session ID (optional with --interactive)")
+    p.add_argument("--older-than", type=str, help="Delete sessions older than (30d, 6m, 1y)")
+    p.add_argument("--before", type=str, help="Delete sessions before date (YYYY-MM-DD)")
+    p.add_argument("--after", type=str, help="Delete sessions after date (YYYY-MM-DD)")
+    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")
+    p.add_argument("--interactive", action="store_true", help="Choose sessions from a list")
+
+
+def _delete_single(db, session_id, dry_run, force) -> int:
+    """Удаление одной сессии по ID."""
+    try:
+        info = get_session_info(db, session_id)
+    except SessionError as e:
+        print(e.message)
+        return 1
+    sid = info["id"]
+    title = get_session_title(info)
+    model = parse_model(info)
+    msg_count = get_message_count(db, sid)
+    part_count = get_part_count(db, sid)
+    created = format_ts(info["time_created"])
+
+    print(f"\n{'=' * 50}")
+    print(f"  {_('delete.header')}")
+    print(f"{'=' * 50}")
+    print(f"  {_('delete.id')}:         {sid}")
+    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 dry_run:
+        print(f"\n{_('delete.dry_run')}")
+        print(f"  {_('delete.dry_run_hint')}")
+        return 0
+
+    if not force and not confirm(_("delete.confirm", id=sid[:24])):
+        print(_("canceled"))
+        return 0
+
+    db.execute("DELETE FROM session WHERE id = ?", (sid,))
+    db.commit()
+
+    print(f"\n{_('delete.done', id=sid[:24])}")
+    print(_("delete.done_detail", msg=msg_count, parts=part_count))
+    return 0
+
+
+def _build_mass_conditions(args):
+    """Строит условия WHERE для массового удаления."""
+    conditions = []
+    params = []
+    project = _a(args, "project")
+    older_than = _a(args, "older_than")
+    before = _a(args, "before")
+    after = _a(args, "after")
+
+    if project:
+        conditions.append("s.project_id = ?")
+        params.append(project)
+
+    if older_than:
+        cutoff = parse_time_spec(older_than)
+        if cutoff is None:
+            return None, None, _("delete.bad_spec", spec=older_than)
+        conditions.append("s.time_created < ?")
+        params.append(int(cutoff.timestamp() * 1000))
+
+    if before:
+        dt = parse_date(before)
+        if dt is None:
+            return None, None, _("delete.bad_date", date=before)
+        conditions.append("s.time_created < ?")
+        params.append(int(dt.timestamp() * 1000))
+
+    if after:
+        dt = parse_date(after)
+        if dt is None:
+            return None, None, _("delete.bad_date", date=after)
+        conditions.append("s.time_created > ?")
+        params.append(int(dt.timestamp() * 1000))
+
+    return conditions, params, None
+
+
+def _collect_mass_targets(db, conditions, params, keep_last):
+    """Собирает список сессий для массового удаления."""
+    exclude_ids = set()
+    if 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, 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)
+        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:
+        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()
+
+    return rows
+
+
+def _delete_mass(db, args) -> int:
+    """Массовое удаление сессий."""
+    keep_last = _a(args, "keep_last")
+    dry_run = _a(args, "dry_run", False)
+    force = _a(args, "force", False)
+
+    conditions, params, err = _build_mass_conditions(args)
+    if err:
+        print(err)
+        return 1
+
+    if not conditions and not keep_last:
+        print(_("delete.filter_required"))
+        return 1
+
+    target_rows = _collect_mass_targets(db, conditions, params, keep_last)
+
+    if not target_rows:
+        print(_("delete.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"  {_('delete.mass_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  {_('delete.cost_total', cost=f'${total_cost:.4f}')}")
+    print(f"  {_('delete.tokens_total', n=str(total_tokens))}")
+
+    if dry_run:
+        print(f"\n{_('delete.dry_run')}")
+        return 0
+
+    if not force and not confirm(_("delete.mass_confirm", n=len(target_rows))):
+        print(_("canceled"))
+        return 0
+
+    ids = [r["id"] for r in target_rows]
+    placeholders = ",".join("?" for _ in ids)
+
+    db.execute(f"DELETE FROM part WHERE session_id IN ({placeholders})", ids)
+    db.execute(f"DELETE FROM message WHERE session_id IN ({placeholders})", ids)
+    db.execute(f"DELETE FROM todo WHERE session_id IN ({placeholders})", ids)
+    db.execute(f"DELETE FROM session WHERE id IN ({placeholders})", ids)
+    db.commit()
+
+    print(f"\n{_('delete.done_mass', n=len(ids))}")
+    return 0
+
+
+def _delete_interactive(db, args) -> int:
+    """Интерактивное удаление — выбор из списка последних сессий."""
+    sessions = get_recent_sessions(db, limit=20)
+
+    if not sessions:
+        print(_("delete.no_sessions"))
+        return 1
+
+    print(f"\n  {_('delete.interactive_header')}")
+    print(f"  {'─' * 55}")
+    for i, s in enumerate(sessions, 1):
+        title = get_session_title(s)
+        project = s.get("project_id", "") or ""
+        print(f"  {i:2d}) {s['id'][:24]}  {title[:40]:40s}  {project[:20]}")
+
+    print()
+    choices = input(_("delete.interactive_prompt")).strip()
+
+    if not choices:
+        print(_("canceled"))
+        return 0
+
+    selected = _parse_choices(choices, len(sessions))
+    if not selected:
+        return 1
+
+    target_rows = [sessions[i - 1] for i in selected]
+    total_cost = sum(r["cost"] or 0 for r in target_rows)
+
+    print(f"\n  {'=' * 55}")
+    print(f"  {_('delete.mass_header', n=len(target_rows))}")
+    print(f"  {'=' * 55}")
+    for r in target_rows:
+        created = format_ts(r["time_created"])
+        print(f"    • {r['id'][:24]}  {created}  {r['title'] or '—'}")
+
+    dry_run = _a(args, "dry_run", False)
+    force = _a(args, "force", False)
+    print(f"\n  {_('delete.cost_total', cost=f'${total_cost:.4f}')}")
+
+    if dry_run:
+        print(f"\n{_('delete.dry_run')}")
+        return 0
+
+    if not force and not confirm(_("delete.mass_confirm", n=len(target_rows))):
+        print(_("canceled"))
+        return 0
+
+    ids = [r["id"] for r in target_rows]
+    placeholders = ",".join("?" for _ in ids)
+
+    db.execute(f"DELETE FROM part WHERE session_id IN ({placeholders})", ids)
+    db.execute(f"DELETE FROM message WHERE session_id IN ({placeholders})", ids)
+    db.execute(f"DELETE FROM todo WHERE session_id IN ({placeholders})", ids)
+    db.execute(f"DELETE FROM session WHERE id IN ({placeholders})", ids)
+    db.commit()
+
+    print(f"\n{_('delete.done_mass', n=len(ids))}")
+    return 0
+
+
+def _parse_choices(text: str, max_n: int) -> list[int]:
+    """Парсит ввод пользователя вида '1,3-5,7' в список индексов."""
+    result = set()
+    for part in text.replace(" ", "").split(","):
+        if not part:
+            continue
+        if "-" in part:
+            try:
+                a, b = part.split("-", 1)
+                for i in range(int(a), int(b) + 1):
+                    if 1 <= i <= max_n:
+                        result.add(i)
+            except ValueError:
+                continue
+        else:
+            try:
+                i = int(part)
+                if 1 <= i <= max_n:
+                    result.add(i)
+            except ValueError:
+                continue
+    return sorted(result)
+
+
+def _a(args, name: str, default=None):
+    """getattr с дефолтом — для совместимости Namespace из разных парсеров."""
+    return getattr(args, name, default)
+
+
+def run(args, db) -> int:
+    if _a(args, "interactive", False):
+        return _delete_interactive(db, args)
+
+    if _a(args, "session_id"):
+        session_id = _a(args, "session_id")
+        dry_run = _a(args, "dry_run", False)
+        force = _a(args, "force", False)
+        return _delete_single(db, session_id, dry_run, force)
+
+    older_than = _a(args, "older_than")
+    before = _a(args, "before")
+    after = _a(args, "after")
+    keep_last = _a(args, "keep_last")
+    project = _a(args, "project")
+    if older_than or before or after or keep_last or project:
+        return _delete_mass(db, args)
+
+    print(_("delete.usage"))
+    return 1

{opencode_db-0.5.0 → opencode_db-0.6.0}/cmd_export.py

@@ -6,6 +6,7 @@
   - export (без аргументов)      — интерактивный выбор из списка
 """
 
+import argparse
 import os
 
 from db import (
@@ -19,11 +20,25 @@ from db import (
 )
 from formatters import collect_snapshot, format_part_to_md, update_log
 from i18n import _
-from utils import format_cost, format_ts, format_ts_short
+from utils import build_help_epilog, format_cost, format_ts, format_ts_short
+
+_EXPORT_EXAMPLES = [
+    ("<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"),
+]
 
 
 def register(subparsers) -> None:
-    p = subparsers.add_parser("export", help=_("help.cmd.export"))
+    p = subparsers.add_parser(
+        "export",
+        help=_("help.cmd.export"),
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=build_help_epilog("export", _EXPORT_EXAMPLES),
+    )
     p.add_argument(
         "session_id",
         nargs="?",

{opencode_db-0.5.0 → opencode_db-0.6.0}/cmd_help.py

@@ -1,17 +1,37 @@
 """Команда help: подробная справка по opencode-db."""
 
+import argparse
 from typing import Literal
 
 from i18n import _
+from utils import build_help_epilog
+
+_HELP_EXAMPLES = [
+    ("", "help.help.e0"),
+    ("<command>", "help.help.e1"),
+]
 
 
 def register(subparsers) -> None:
-    p = subparsers.add_parser("help", help=_("help.cmd.help"))
+    p = subparsers.add_parser(
+        "help",
+        help=_("help.cmd.help"),
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=build_help_epilog("help", _HELP_EXAMPLES),
+    )
     p.add_argument("topic", nargs="?", help="Command name")
     p.add_argument("--json", action="store_true", help="JSON output")
 
 
 _COMMANDS = [
+    (
+        "help",
+        "help.cmd.help",
+        [
+            ("", "help.help.e0"),
+            ("<command>", "help.help.e1"),
+        ],
+    ),
     (
         "list",
         "help.cmd.list",
@@ -173,8 +193,14 @@ def _print_command_help(cmd_name) -> Literal[1] | Literal[0]:
 
     desc_key, examples = entry
     print()
-    print(_("help.cmd_header", cmd=cmd_name, desc=_(desc_key)))
+    print(f"  {'─' * 55}")
+    print(f"  {_('help.cmd_header', cmd=cmd_name, desc=_(desc_key))}")
+    print(f"  {'─' * 55}")
+    print()
+    print(f"  {_('help.flags_header', cmd=cmd_name)}")
+    print(f"    opencode-db {cmd_name} --help")
     print()
+    print(f"  {_('help.usage_header', cmd=cmd_name)}")
     for flag, example_key in examples:
         example_desc = _(example_key)
         if flag:

{opencode_db-0.5.0 → opencode_db-0.6.0}/cmd_info.py

@@ -1,5 +1,7 @@
 """Команда info: детальная информация о сессии."""
 
+import argparse
+
 from db import (
     SessionError,
     get_children_sessions,
@@ -13,11 +15,21 @@ from db import (
     parse_model,
 )
 from i18n import _
-from utils import format_cost, format_tokens, format_ts
+from utils import build_help_epilog, format_cost, format_tokens, format_ts
+
+_INFO_EXAMPLES = [
+    ("<session_id>", "help.info.e0"),
+    ("<session_id> --json", "help.info.e1"),
+]
 
 
 def register(subparsers) -> None:
-    p = subparsers.add_parser("info", help=_("help.cmd.info"))
+    p = subparsers.add_parser(
+        "info",
+        help=_("help.cmd.info"),
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=build_help_epilog("info", _INFO_EXAMPLES),
+    )
     p.add_argument("session_id", help="Session ID")
     p.add_argument("--json", action="store_true", help="JSON output")
 

{opencode_db-0.5.0 → opencode_db-0.6.0}/cmd_list.py

@@ -1,16 +1,30 @@
 """Команда list: список сессий с фильтрацией и сортировкой."""
 
+import argparse
 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
+from utils import build_help_epilog, format_ts
+
+_LIST_EXAMPLES = [
+    ("", "help.list.e0"),
+    ("--limit 10", "help.list.e1"),
+    ("--sort cost", "help.list.e2"),
+    ("--project proj_xxx", "help.list.e3"),
+    ("--json", "help.list.e4"),
+]
 
 
 def register(subparsers) -> None:
-    p = subparsers.add_parser("list", help=_("help.cmd.list"))
+    p = subparsers.add_parser(
+        "list",
+        help=_("help.cmd.list"),
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=build_help_epilog("list", _LIST_EXAMPLES),
+    )
     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")

{opencode_db-0.5.0 → opencode_db-0.6.0}/cmd_projects.py

@@ -1,13 +1,24 @@
 """Команда projects: список проектов со статистикой."""
 
+import argparse
 from typing import Literal
 
 from i18n import _
-from utils import format_cost, format_tokens, format_ts
+from utils import build_help_epilog, format_cost, format_tokens, format_ts
+
+_PROJECTS_EXAMPLES = [
+    ("", "help.projects.e0"),
+    ("--json", "help.projects.e1"),
+]
 
 
 def register(subparsers) -> None:
-    p = subparsers.add_parser("projects", help=_("help.cmd.projects"))
+    p = subparsers.add_parser(
+        "projects",
+        help=_("help.cmd.projects"),
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=build_help_epilog("projects", _PROJECTS_EXAMPLES),
+    )
     p.add_argument("--json", action="store_true", help="JSON output")
 
 

opencode_db-0.6.0/cmd_prune.py

@@ -0,0 +1,32 @@
+"""Команда prune: массовая очистка (alias для delete)."""
+
+import argparse
+
+from cmd_delete import run as delete_run
+from i18n import _
+from utils import build_help_epilog
+
+_PRUNE_EXAMPLES = [
+    ("--older-than 90d", "help.prune.e0"),
+    ("--keep-last 20", "help.prune.e1"),
+    ("--dry-run", "help.prune.e2"),
+    ("--force", "help.prune.e3"),
+]
+
+
+def register(subparsers) -> None:
+    p = subparsers.add_parser(
+        "prune",
+        help=_("help.cmd.prune"),
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=build_help_epilog("prune", _PRUNE_EXAMPLES),
+    )
+    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) -> int:
+    return delete_run(args, db)

{opencode_db-0.5.0 → opencode_db-0.6.0}/cmd_search.py

@@ -1,14 +1,26 @@
 """Команда search: поиск по тексту сообщений и частей."""
 
+import argparse
 import json
 
 from db import SessionError, resolve_session_id
 from i18n import _
-from utils import format_ts
+from utils import build_help_epilog, format_ts
+
+_SEARCH_EXAMPLES = [
+    ('"text"', "help.search.e0"),
+    ('"text" --session ses_xxx', "help.search.e1"),
+    ('"text" --json', "help.search.e2"),
+]
 
 
 def register(subparsers) -> None:
-    p = subparsers.add_parser("search", help=_("help.cmd.search"))
+    p = subparsers.add_parser(
+        "search",
+        help=_("help.cmd.search"),
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=build_help_epilog("search", _SEARCH_EXAMPLES),
+    )
     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")

{opencode_db-0.5.0 → opencode_db-0.6.0}/cmd_stats.py

@@ -1,14 +1,25 @@
 """Команда stats: общая статистика по базе данных."""
 
+import argparse
 from typing import Literal
 
 from db import parse_model
 from i18n import _
-from utils import format_cost, format_tokens, format_ts
+from utils import build_help_epilog, format_cost, format_tokens, format_ts
+
+_STATS_EXAMPLES = [
+    ("", "help.stats.e0"),
+    ("--json", "help.stats.e1"),
+]
 
 
 def register(subparsers) -> None:
-    p = subparsers.add_parser("stats", help=_("help.cmd.stats"))
+    p = subparsers.add_parser(
+        "stats",
+        help=_("help.cmd.stats"),
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=build_help_epilog("stats", _STATS_EXAMPLES),
+    )
     p.add_argument("--json", action="store_true", help="JSON output")
 
 

{opencode_db-0.5.0 → opencode_db-0.6.0}/cmd_todos.py

@@ -1,12 +1,26 @@
 """Команда todos: просмотр задач (todo) из сессий."""
 
+import argparse
+
 from db import SessionError, resolve_session_id
 from i18n import _
-from utils import format_ts
+from utils import build_help_epilog, format_ts
+
+_TODOS_EXAMPLES = [
+    ("", "help.todos.e0"),
+    ("<session_id>", "help.todos.e1"),
+    ("--status pending", "help.todos.e2"),
+    ("--json", "help.todos.e3"),
+]
 
 
 def register(subparsers) -> None:
-    p = subparsers.add_parser("todos", help=_("help.cmd.todos"))
+    p = subparsers.add_parser(
+        "todos",
+        help=_("help.cmd.todos"),
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=build_help_epilog("todos", _TODOS_EXAMPLES),
+    )
     p.add_argument("session_id", nargs="?", help="Session ID")
     p.add_argument(
         "--status",

{opencode_db-0.5.0 → opencode_db-0.6.0}/cmd_tree.py

@@ -1,12 +1,25 @@
 """Команда tree: дерево ветвления сессий."""
 
+import argparse
+
 from db import SessionError, get_session_title, resolve_session_id
 from i18n import _
-from utils import format_ts
+from utils import build_help_epilog, format_ts
+
+_TREE_EXAMPLES = [
+    ("", "help.tree.e0"),
+    ("<session_id>", "help.tree.e1"),
+    ("--depth 3", "help.tree.e2"),
+]
 
 
 def register(subparsers) -> None:
-    p = subparsers.add_parser("tree", help=_("help.cmd.tree"))
+    p = subparsers.add_parser(
+        "tree",
+        help=_("help.cmd.tree"),
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=build_help_epilog("tree", _TREE_EXAMPLES),
+    )
     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")

{opencode_db-0.5.0 → opencode_db-0.6.0}/cmd_vacuum.py

@@ -1,15 +1,26 @@
 """Команда vacuum: оптимизация базы данных."""
 
+import argparse
 import os
 from typing import Literal
 
 from config import OPENCODE_DB
 from i18n import _
-from utils import confirm
+from utils import build_help_epilog, confirm
+
+_VACUUM_EXAMPLES = [
+    ("", "help.vacuum.e0"),
+    ("--force", "help.vacuum.e1"),
+]
 
 
 def register(subparsers) -> None:
-    p = subparsers.add_parser("vacuum", help=_("help.cmd.vacuum"))
+    p = subparsers.add_parser(
+        "vacuum",
+        help=_("help.cmd.vacuum"),
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=build_help_epilog("vacuum", _VACUUM_EXAMPLES),
+    )
     p.add_argument("--force", "-f", action="store_true", help="Skip confirmation")
 
 

{opencode_db-0.5.0 → opencode_db-0.6.0}/i18n.py

@@ -185,6 +185,40 @@ L: dict[str, dict[str, str]] = {
         "ru": "     Сообщений: {msg}, частей: {parts}",
         "en": "     Messages: {msg}, parts: {parts}",
     },
+    "delete.none": {"ru": "  ✅ Нет сессий для удаления.", "en": "  ✅ No sessions to delete."},
+    "delete.filter_required": {
+        "ru": "❌ Укажи ID сессии, фильтр, или --interactive",
+        "en": "❌ Specify session ID, a filter, or --interactive",
+    },
+    "delete.usage": {
+        "ru": "  Использование: opencode-db delete <session_id>",
+        "en": "  Usage: opencode-db delete <session_id>",
+    },
+    "delete.bad_spec": {
+        "ru": "❌ Не могу разобрать: --older-than {spec}",
+        "en": "❌ Cannot parse: --older-than {spec}",
+    },
+    "delete.bad_date": {
+        "ru": "❌ Неверный формат даты: {date}. Используй ГГГГ-ММ-ДД",
+        "en": "❌ Invalid date format: {date}. Use YYYY-MM-DD",
+    },
+    "delete.mass_header": {
+        "ru": "Будет удалено сессий: {n}",
+        "en": "Sessions to delete: {n}",
+    },
+    "delete.cost_total": {
+        "ru": "Стоимость удаляемых: {cost}",
+        "en": "Cost of deleted sessions: {cost}",
+    },
+    "delete.tokens_total": {"ru": "Освободится токенов: ~{n}", "en": "Tokens freed: ~{n}"},
+    "delete.mass_confirm": {"ru": "Удалить {n} сессий?", "en": "Delete {n} sessions?"},
+    "delete.done_mass": {"ru": "  ✅ Удалено {n} сессий.", "en": "  ✅ Deleted {n} sessions."},
+    "delete.interactive_header": {"ru": "Последние сессии:", "en": "Recent sessions:"},
+    "delete.interactive_prompt": {
+        "ru": "  Введи номера (1,3-5) или Enter для отмены: ",
+        "en": "  Enter numbers (1,3-5) or Enter to cancel: ",
+    },
+    "delete.no_sessions": {"ru": "❌ Нет сессий для удаления.", "en": "❌ No sessions to delete."},
     # ==================================================================
     # COSTS
     # ==================================================================
@@ -322,8 +356,8 @@ L: dict[str, dict[str, str]] = {
         "en": "╔══════════════════════════════════════════════════════════╗",
     },
     "help.header_title": {
-        "ru": "║                 opencode-db — справка                   ║",
-        "en": "║                 opencode-db — help                     ║",
+        "ru": "║                 opencode-db — справка                    ║",
+        "en": "║                 opencode-db — help                       ║",
     },
     "help.header_box_bottom": {
         "ru": "╚══════════════════════════════════════════════════════════╝",
@@ -355,13 +389,21 @@ L: dict[str, dict[str, str]] = {
     },
     "help.unknown": {"ru": "❌ Неизвестная команда: {cmd}", "en": "❌ Unknown command: {cmd}"},
     "help.available": {"ru": "   Доступные: {cmds}", "en": "   Available: {cmds}"},
+    "help.usage_header": {
+        "ru": "Примеры использования команды {cmd}:",
+        "en": "Usage examples for {cmd}:",
+    },
+    "help.flags_header": {
+        "ru": "Все доступные флаги для {cmd}:",
+        "en": "Available flags for {cmd}:",
+    },
     # ==================================================================
     # HELP — команды (краткие описания в справке)
     # ==================================================================
     "help.cmd.list": {"ru": "Список сессий", "en": "List sessions"},
     "help.cmd.info": {"ru": "Детальная информация о сессии", "en": "Session details"},
     "help.cmd.export": {"ru": "Экспорт диалога в Markdown", "en": "Export dialog to Markdown"},
-    "help.cmd.delete": {"ru": "Удаление сессии", "en": "Delete a session"},
+    "help.cmd.delete": {"ru": "Удаление сессий", "en": "Delete sessions"},
     "help.cmd.costs": {"ru": "Анализ расходов на токены", "en": "Token cost analysis"},
     "help.cmd.prune": {"ru": "Массовая очистка сессий", "en": "Bulk session cleanup"},
     "help.cmd.search": {"ru": "Поиск по сообщениям", "en": "Search messages"},
@@ -372,8 +414,12 @@ L: dict[str, dict[str, str]] = {
     "help.cmd.vacuum": {"ru": "Оптимизация БД", "en": "Database optimization"},
     "help.cmd.help": {"ru": "Подробная справка", "en": "Detailed help"},
     # ==================================================================
-    # HELP — примеры
+    # HELP — примеры (epilog для argparse --help)
     # ==================================================================
+    "help.cmd.list.examples": {
+        "ru": "\nПримеры:\n  opencode-db list                              # Сессии за последнее время\n  opencode-db list --limit 10                # Показать 10 последних\n  opencode-db list --sort cost               # Сортировка по стоимости\n  opencode-db list --project proj_xxx        # Фильтр по проекту\n  opencode-db list --json                    # Вывод в JSON\n",
+        "en": "\nExamples:\n  opencode-db list                              # Recent sessions\n  opencode-db list --limit 10                # Show last 10\n  opencode-db list --sort cost               # Sort by cost\n  opencode-db list --project proj_xxx        # Filter by project\n  opencode-db list --json                    # JSON output\n",
+    },
     "help.list.e0": {"ru": "Сессии за последнее время", "en": "Recent sessions"},
     "help.list.e1": {"ru": "Показать 10 последних", "en": "Show last 10"},
     "help.list.e2": {"ru": "Сортировка по стоимости", "en": "Sort by cost"},
@@ -396,6 +442,22 @@ L: dict[str, dict[str, str]] = {
     "help.delete.e0": {"ru": "Удалить с подтверждением", "en": "Delete with confirmation"},
     "help.delete.e1": {"ru": "Показать что будет удалено", "en": "Preview what will be deleted"},
     "help.delete.e2": {"ru": "Без подтверждения", "en": "Skip confirmation"},
+    "help.delete.e3": {
+        "ru": "Удалить сессии старше 90 дней",
+        "en": "Delete sessions older than 90 days",
+    },
+    "help.delete.e4": {
+        "ru": "Оставить 30 последних, остальное удалить",
+        "en": "Keep 30 most recent, delete the rest",
+    },
+    "help.delete.e5": {
+        "ru": "Удалить сессии до указанной даты",
+        "en": "Delete sessions before a date",
+    },
+    "help.delete.e6": {
+        "ru": "Интерактивный выбор из списка",
+        "en": "Choose sessions from a list",
+    },
     "help.costs.e0": {"ru": "Топ сессий по расходам", "en": "Top sessions by cost"},
     "help.costs.e1": {"ru": "Детально по сессии", "en": "Single session breakdown"},
     "help.costs.e2": {"ru": "Сумма по всей БД", "en": "Total across all sessions"},
@@ -427,6 +489,14 @@ L: dict[str, dict[str, str]] = {
         "en": "VACUUM + REINDEX + ANALYZE with confirmation",
     },
     "help.vacuum.e1": {"ru": "Без подтверждения", "en": "Skip confirmation"},
+    "help.help.e0": {
+        "ru": "Общая справка по всем командам",
+        "en": "General help for all commands",
+    },
+    "help.help.e1": {
+        "ru": "Справка по конкретной команде",
+        "en": "Help for a specific command",
+    },
     # ==================================================================
     # MARKDOWN EXPORT (formatters.py, config.py)
     # ==================================================================

{opencode_db-0.5.0 → opencode_db-0.6.0/opencode_db.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opencode-db
-Version: 0.5.0
+Version: 0.6.0
 Summary: OpenCode database CLI manager — browse, export, analyze, clean up sessions
 Project-URL: Homepage, https://github.com/VasilevNStas/opencode-db
 Project-URL: Source, https://github.com/VasilevNStas/opencode-db

{opencode_db-0.5.0 → opencode_db-0.6.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "opencode-db"
-version = "0.5.0"
+version = "0.6.0"
 description = "OpenCode database CLI manager — browse, export, analyze, clean up sessions"
 readme = "README_PYPI.md"
 requires-python = ">=3.12"

{opencode_db-0.5.0 → opencode_db-0.6.0}/tests/test_commands.py

@@ -477,7 +477,7 @@ class TestPruneCommand:
         from cmd_prune import run
 
         args = _ns(older_than="30d", keep_last=None, project=None, dry_run=False, force=False)
-        with patch("cmd_prune.confirm", return_value=False):
+        with patch("cmd_delete.confirm", return_value=False):
             assert run(args, db) == 0
         assert _count_sessions(db) == 4
 

{opencode_db-0.5.0 → opencode_db-0.6.0}/utils.py

@@ -37,6 +37,19 @@ def summarize_val(v, max_len=120) -> str:
     return s
 
 
+def parse_date(date_str: str) -> datetime | None:
+    """Парсит дату в формате ГГГГ-ММ-ДД."""
+    if not date_str or not isinstance(date_str, str):
+        return None
+    try:
+        parts = date_str.strip().split("-")
+        if len(parts) != 3:
+            return None
+        return datetime(int(parts[0]), int(parts[1]), int(parts[2]), tzinfo=UTC)
+    except (ValueError, IndexError):
+        return None
+
+
 def parse_time_spec(spec) -> None | datetime:
     """Парсит спецификацию времени ('30d', '6m', '1y') в timedelta."""
     if not spec or not isinstance(spec, str):
@@ -91,6 +104,27 @@ def confirm(prompt=None, default=False) -> bool:
             return False
 
 
+def build_help_epilog(cmd_name: str, examples: list[tuple[str, str]]) -> str:
+    """Формирует epilog для argparse из списка примеров.
+
+    Args:
+        cmd_name: имя команды (для заголовка)
+        examples: список (флаги, ключ в i18n с описанием)
+
+    Returns:
+        str — готовый текст для epilog
+    """
+    header = _("help.usage_header", cmd=cmd_name)
+    lines = [f"\n{header}"]
+    for flags, desc_key in examples:
+        desc = _(desc_key)
+        if flags:
+            lines.append(f"  opencode-db {cmd_name} {flags:33s}  # {desc}")
+        else:
+            lines.append(f"  opencode-db {cmd_name:36s}  # {desc}")
+    return "\n".join(lines)
+
+
 def format_cost(cost_value) -> str:
     """Форматирует стоимость в долларах."""
     if cost_value is None:

opencode_db-0.5.0/cmd_delete.py

@@ -1,61 +0,0 @@
-"""Команда delete: удаление сессии."""
-
-from db import (
-    SessionError,
-    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) -> int:
-    try:
-        info = get_session_info(db, args.session_id)
-    except SessionError as e:
-        print(e.message)
-        return 1
-    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

opencode_db-0.5.0/cmd_prune.py

@@ -1,127 +0,0 @@
-"""Команда 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