opencode-db 0.8.2__tar.gz → 0.9.0__tar.gz

{opencode_db-0.8.2/opencode_db.egg-info → opencode_db-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opencode-db
-Version: 0.8.2
+Version: 0.9.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
@@ -31,6 +31,7 @@ uv tool install opencode-db
 ## Quick start
 
 ```bash
+opencode-db --version    # installed version
 opencode-db list         # recent sessions
 opencode-db directories  # launch directories, including missing ones
 opencode-db view         # interactive session viewer (colored, scrollable)
@@ -47,7 +48,7 @@ opencode-db help         # full reference
 - **`list`** / **`info`** / **`search`** / **`tree`** — навигация и поиск по сессиям
 - **`directories`** (`dirs`) — все директории запусков, включая отсутствующие; `list --directory` добавляет путь к сессии
 - **`export`** — экспорт диалога в Markdown (с поддержкой Obsidian)
-- **`delete`** / **`prune`** — удаление и массовая очистка с фильтрами
+- **`delete`** / **`prune`** — удаление и массовая очистка с фильтрами; `prune --missing-directories` — защищённая очистка сессий из отсутствующих путей
 - **`costs`** / **`stats`** — аналитика токенов и расходов
 - **`schema`** — определяет v1/v2-схему OpenCode, миграции и доступные операции
 - **`--db-path`** / **`OPENCODE_DB`** — кастомный путь к БД

{opencode_db-0.8.2 → opencode_db-0.9.0}/README.md

@@ -13,6 +13,7 @@
 > **Published on PyPI:** [opencode-db](https://pypi.org/project/opencode-db/) — install the ready-made package with `uv tool install opencode-db` or `pip install opencode-db`.
 
 ```
+opencode-db --version     # installed version
 opencode-db help        # full reference with examples
 opencode-db list        # list recent sessions
 opencode-db stats       # database summary
@@ -312,6 +313,7 @@ opencode-db delete --after 2026-01-01                    # sessions after a spec
 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
+opencode-db prune --missing-directories                  # preview sessions from missing paths
 ```
 
 | Flag | Description |
@@ -325,6 +327,10 @@ opencode-db delete --interactive                         # choose from a list in
 | `--dry-run` | Only show what would be deleted |
 | `--force`, `-f` | Skip confirmation prompt |
 | `--interactive` | Pick sessions from a list |
+| `--missing-directories` | Sessions whose directory no longer exists (preview by default) |
+| `--execute` | Execute missing-directory cleanup |
+| `--backup` | Create a DB backup before deletion |
+| `--no-backup` | Explicitly skip the DB backup |
 
 ---
 
@@ -364,6 +370,144 @@ opencode-db prune --keep-last 20           # same as opencode-db delete --keep-l
 
 Time spec formats: `30d` (days), `6m` (months), `1y` (years).
 
+### Missing-directory cleanup
+
+OpenCode stores the launch directory of every session in `session.directory`.
+The TUI only shows sessions for the current project, so sessions created in a
+deleted, renamed or unmounted directory can be hard to find. This mode finds
+those sessions and deletes them only after several independent confirmations.
+
+#### 1. Inspect candidates first (read-only)
+
+```bash
+opencode-db directories --missing
+opencode-db directories --missing --json
+opencode-db prune --missing-directories
+opencode-db prune --missing-directories --project global
+```
+
+`directories --missing` is the safest first step: it does not touch the
+database and shows the same paths, counts and costs.
+
+Example preview:
+
+```text
+============================================================
+  DELETE SESSIONS FROM MISSING DIRECTORIES
+============================================================
+  Database: ~/.local/share/opencode/opencode.db
+  Sessions: 51, directories: 10, cost: $3.85
+  2026-05-06 08:19:14 — 2026-09-12 16:45:41
+    /Users/me/old-project — 15 sessions
+    /Users/me/Documents/old-notes — 7 sessions
+...
+This is a preview. Add --execute to delete.
+```
+
+How “missing” is detected:
+
+- the tool reads `session.directory` (or `session_v2.directory`);
+- it calls `os.path.isdir()` on each path at command runtime;
+- `False` means **not found or inaccessible** — it may be deleted, renamed,
+  on an unmounted disk, on an offline network volume, or blocked by permissions;
+- symlinks are followed; results are only true at the moment the command runs;
+- `--no-check` on `directories` skips this check and reports `exists: null`.
+
+Review this list carefully. A temporarily unavailable external disk can look
+exactly like a deleted directory.
+
+#### 2. Execute with the safety gates
+
+```bash
+# recommended: create a consistent SQLite backup first
+opencode-db prune --missing-directories --execute --backup
+
+# only if you already have an external backup
+opencode-db prune --missing-directories --execute --no-backup
+```
+
+`delete --missing-directories ...` works the same way as `prune`.
+
+Before anything is deleted, all of these gates must pass:
+
+1. `--missing-directories` selects only sessions whose path is not found.
+2. `--execute` is required; without it the command always stops after preview.
+3. `--backup` or `--no-backup` must be chosen explicitly.
+4. The command prints every path, session count, cost and date range.
+5. You must type the exact phrase `DELETE <N> SESSIONS`.
+6. You must answer a final `y/N` confirmation.
+7. The candidate list is recomputed; if it changed, deletion is aborted.
+8. All deletes run in one transaction; on error the transaction is rolled back.
+
+`--force` does **not** bypass any of these gates. It is ignored in this mode.
+
+#### What exactly is deleted
+
+For each selected session:
+
+- the `session` row;
+- `message`, `part`, `todo`;
+- `session_message`, `session_input`, `session_context_epoch`, `session_share`;
+- `event` and `event_sequence` rows for that session.
+
+Projects and the synthetic `global` project are **never** deleted. The tool
+does not touch directories on disk — it only removes database rows.
+
+After a successful cleanup you can reclaim disk space:
+
+```bash
+opencode-db vacuum
+```
+
+`VACUUM` can take time and temporarily needs free disk space roughly equal to
+the database size.
+
+#### Backup and recovery
+
+With `--backup`, the tool creates a consistent SQLite copy next to the database:
+
+```text
+opencode.db.bak.20261020-111530
+```
+
+The exact path is printed before deletion. If you delete something by mistake:
+
+1. stop OpenCode;
+2. restore the backup over `opencode.db`;
+3. remove stale `opencode.db-wal` / `opencode.db-shm` files if present;
+4. start OpenCode again.
+
+Without a backup, deleted sessions and their events cannot be recovered.
+
+#### Recommended workflow
+
+```bash
+# 1. Close OpenCode to avoid concurrent writes.
+opencode-db directories --missing
+
+# 2. Preview the exact deletion.
+opencode-db prune --missing-directories
+
+# 3. Optional: only one project.
+opencode-db prune --missing-directories --project global
+
+# 4. Execute with a backup.
+opencode-db prune --missing-directories --execute --backup
+
+# 5. Reclaim disk space.
+opencode-db vacuum
+```
+
+#### Limitations
+
+- This mode is available for the v1 schema; v2 is refused until v2 writes are
+  implemented.
+- It cannot tell a deleted directory from an offline volume or permission error.
+- It does not remove `project` rows or directories from disk.
+- It cannot be combined with `--older-than`, `--before`, `--after`,
+  `--keep-last`, `--interactive` or a session ID.
+- There is no automatic or background cleanup.
+
 ---
 
 ### `search` — search across messages
@@ -576,7 +720,7 @@ opencode-db/
 │   ├── config.py                         ← constants and paths
 │   ├── db.py                             ← SQLite queries
 │   ├── formatters.py                     ← tables, JSON, Markdown, snapshots
-│   ├── i18n.py                           ← localization (EN/RU, 324 keys)
+│   ├── i18n.py                           ← localization (EN/RU, 348 keys)
 │   ├── markdown_to_ansi.py               ← Markdown → ANSI renderer for `view`
 │   ├── runtime.py                        ← Python 3.12+ version guard
 │   ├── utils.py                          ← date/token formatting, validation
@@ -725,7 +869,7 @@ opencode-db --lang en help        # English help text
 opencode-db --lang en stats       # English statistics
 ```
 
-The `--lang` flag applies to any command. All 324 UI strings are translated. Data content (session titles, project names, etc.) remains in its original language.
+The `--lang` flag applies to any command. All 348 UI strings are translated. Data content (session titles, project names, etc.) remains in its original language.
 
 The language can also be set via environment variable `OPENCODE_DB_LANG=en`.
 
@@ -810,7 +954,7 @@ source .venv/bin/activate
 uv pip install -e ".[rich]"
 uv pip install pytest ruff==0.17.1
 
-make check          # check-python + ruff + 214 tests
+make check          # check-python + ruff + 224 tests
 ```
 
 `make check` fails fast with a clear message if the active interpreter is older than 3.12.

{opencode_db-0.8.2 → opencode_db-0.9.0}/docs/README_PYPI.md

@@ -15,6 +15,7 @@ uv tool install opencode-db
 ## Quick start
 
 ```bash
+opencode-db --version    # installed version
 opencode-db list         # recent sessions
 opencode-db directories  # launch directories, including missing ones
 opencode-db view         # interactive session viewer (colored, scrollable)
@@ -31,7 +32,7 @@ opencode-db help         # full reference
 - **`list`** / **`info`** / **`search`** / **`tree`** — навигация и поиск по сессиям
 - **`directories`** (`dirs`) — все директории запусков, включая отсутствующие; `list --directory` добавляет путь к сессии
 - **`export`** — экспорт диалога в Markdown (с поддержкой Obsidian)
-- **`delete`** / **`prune`** — удаление и массовая очистка с фильтрами
+- **`delete`** / **`prune`** — удаление и массовая очистка с фильтрами; `prune --missing-directories` — защищённая очистка сессий из отсутствующих путей
 - **`costs`** / **`stats`** — аналитика токенов и расходов
 - **`schema`** — определяет v1/v2-схему OpenCode, миграции и доступные операции
 - **`--db-path`** / **`OPENCODE_DB`** — кастомный путь к БД

{opencode_db-0.8.2 → opencode_db-0.9.0}/opencode_db/cli.py

@@ -21,6 +21,7 @@ require_python()
 from . import commands  # noqa: E402
 from .db import get_db  # noqa: E402
 from .i18n import _, set_lang  # noqa: E402
+from .version import get_version  # noqa: E402
 
 
 def build_parser() -> argparse.ArgumentParser:
@@ -41,6 +42,11 @@ def build_parser() -> argparse.ArgumentParser:
         default=None,
         help="Path to opencode.db (default: ~/.local/share/opencode/opencode.db)",
     )
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=f"%(prog)s {get_version()}",
+    )
 
     subparsers = parser.add_subparsers(dest="command", required=True)
     seen: set[str] = set()

{opencode_db-0.8.2 → opencode_db-0.9.0}/opencode_db/commands/cmd_delete.py

@@ -1,7 +1,11 @@
 """Команда delete: удаление сессии или массовая очистка."""
 
 import argparse
+import os
+import sqlite3
+from datetime import datetime
 
+from ..config import resolve_db_path
 from ..db import (
     SessionError,
     get_message_count,
@@ -23,6 +27,8 @@ _DELETE_EXAMPLES = [
     ("--keep-last 30", "help.delete.e4"),
     ("--before 2026-05-20", "help.delete.e5"),
     ("--interactive", "help.delete.e6"),
+    ("--missing-directories", "help.delete.e7"),
+    ("--missing-directories --execute", "help.delete.e8"),
 ]
 
 
@@ -42,6 +48,14 @@ def register(subparsers) -> None:
     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")
+    p.add_argument(
+        "--missing-directories",
+        action="store_true",
+        help="Sessions whose directory no longer exists (preview by default)",
+    )
+    p.add_argument("--execute", action="store_true", help="Execute missing-directory cleanup")
+    p.add_argument("--backup", action="store_true", help="Create a DB backup before deletion")
+    p.add_argument("--no-backup", action="store_true", help="Skip the DB backup")
 
 
 def _delete_single(db, session_id, dry_run, force) -> int:
@@ -317,6 +331,161 @@ def _parse_choices(text: str, max_n: int) -> list[int]:
     return sorted(result)
 
 
+_SESSION_SCOPED_TABLES = (
+    "part",
+    "message",
+    "todo",
+    "session_message",
+    "session_input",
+    "session_context_epoch",
+    "session_share",
+)
+_EVENT_SCOPED_TABLES = ("event", "event_sequence")
+
+
+def _missing_directory_targets(db, project_id=None):
+    where = "WHERE directory IS NOT NULL AND directory != ''"
+    params = []
+    if project_id:
+        where += " AND project_id = ?"
+        params.append(project_id)
+    rows = db.execute(
+        f"SELECT id, title, directory, time_created, cost FROM session {where}",
+        params,
+    ).fetchall()
+    return [dict(row) for row in rows if not os.path.isdir(row["directory"])]
+
+
+def _delete_in_chunks(db, table, column, ids):
+    deleted = 0
+    for start in range(0, len(ids), 500):
+        chunk = ids[start : start + 500]
+        placeholders = ",".join("?" for _ in chunk)
+        cur = db.execute(f"DELETE FROM {table} WHERE {column} IN ({placeholders})", chunk)
+        deleted += max(cur.rowcount, 0)
+    return deleted
+
+
+def _delete_session_rows(db, ids, tables):
+    db.execute("PRAGMA foreign_keys=ON")
+    deleted = 0
+    for table in _EVENT_SCOPED_TABLES:
+        if table in tables:
+            deleted += _delete_in_chunks(db, table, "aggregate_id", ids)
+    for table in _SESSION_SCOPED_TABLES:
+        if table in tables:
+            deleted += _delete_in_chunks(db, table, "session_id", ids)
+    deleted += _delete_in_chunks(db, "session", "id", ids)
+    return deleted
+
+
+def _backup_database(db, db_path):
+    stamp = datetime.now().strftime("%Y%m%d-%H%M%S")
+    target = f"{db_path}.bak.{stamp}"
+    suffix = 1
+    while os.path.exists(target):
+        target = f"{db_path}.bak.{stamp}-{suffix}"
+        suffix += 1
+    dest = sqlite3.connect(target)
+    try:
+        db.backup(dest)
+    finally:
+        dest.close()
+    return target
+
+
+def _delete_missing_dirs(db, args) -> int:
+    incompatible = any(
+        _a(args, name)
+        for name in ("older_than", "before", "after", "keep_last", "interactive", "session_id")
+    )
+    if incompatible:
+        print(_("delete.missing_incompatible"))
+        return 1
+
+    backup = _a(args, "backup", False)
+    no_backup = _a(args, "no_backup", False)
+    if backup and no_backup:
+        print(_("delete.missing_both_backup"))
+        return 1
+
+    project_id = _a(args, "project")
+    targets = _missing_directory_targets(db, project_id)
+    if not targets:
+        print(_("delete.missing_none"))
+        return 0
+
+    db_path = resolve_db_path()[0]
+    groups = {}
+    for target in targets:
+        groups.setdefault(target["directory"], []).append(target)
+    total_cost = sum(target["cost"] or 0 for target in targets)
+    times = [target["time_created"] for target in targets if target["time_created"]]
+    first_ts = min(times) if times else None
+    last_ts = max(times) if times else None
+
+    print(f"\n  {'=' * 60}")
+    print(f"  {_('delete.missing_header')}")
+    print(f"  {'=' * 60}")
+    print(_("delete.missing_db", path=db_path))
+    print(_("delete.missing_summary", sessions=len(targets), dirs=len(groups), cost=format_cost(total_cost)))
+    first_label = format_ts(first_ts) if first_ts else "—"
+    last_label = format_ts(last_ts) if last_ts else "—"
+    print(f"  {first_label} — {last_label}")
+    for path in sorted(groups):
+        print(_("delete.missing_dir_line", path=path, n=len(groups[path])))
+
+    if not _a(args, "execute", False) or _a(args, "dry_run", False):
+        print(f"\n{_('delete.missing_preview')}")
+        return 0
+
+    if not backup and not no_backup:
+        print(_("delete.missing_backup_choice"))
+        return 1
+    if no_backup:
+        print(_("delete.missing_no_backup_warning"))
+
+    phrase = f"DELETE {len(targets)} SESSIONS"
+    try:
+        answer = input(_("delete.missing_phrase_prompt", phrase=phrase))
+    except EOFError:
+        print(_("canceled"))
+        return 0
+    if answer.strip() != phrase:
+        print(_("delete.missing_phrase_mismatch"))
+        return 0
+
+    if not confirm(_("delete.missing_final_confirm", n=len(targets))):
+        print(_("canceled"))
+        return 0
+
+    if backup:
+        try:
+            backup_path = _backup_database(db, db_path)
+        except Exception as exc:
+            print(_("delete.missing_backup_failed", error=exc))
+            return 1
+        print(_("delete.missing_backup_done", path=backup_path))
+
+    fresh = _missing_directory_targets(db, project_id)
+    fresh_ids = {target["id"] for target in fresh}
+    target_ids = {target["id"] for target in targets}
+    if fresh_ids != target_ids:
+        print(_("delete.missing_changed"))
+        return 1
+
+    try:
+        deleted = _delete_session_rows(db, sorted(target_ids), set(open_store(db).schema.tables))
+        db.commit()
+    except Exception as exc:
+        db.rollback()
+        print(_("delete.missing_error", error=exc))
+        return 1
+
+    print(_("delete.missing_done", n=len(target_ids), rows=deleted))
+    return 0
+
+
 def _a(args, name: str, default=None):
     """getattr с дефолтом — для совместимости Namespace из разных парсеров."""
     return getattr(args, name, default)
@@ -327,6 +496,11 @@ def run(args, db) -> int:
     if store.schema.read_only:
         print(_("schema.unsupported_write"))
         return 1
+    if _a(args, "execute", False) and not _a(args, "missing_directories", False):
+        print(_("delete.missing_execute_requires"))
+        return 1
+    if _a(args, "missing_directories", False):
+        return _delete_missing_dirs(db, args)
     if _a(args, "interactive", False):
         return _delete_interactive(db, args)
 

{opencode_db-0.8.2 → opencode_db-0.9.0}/opencode_db/commands/cmd_prune.py

@@ -11,6 +11,8 @@ _PRUNE_EXAMPLES = [
     ("--keep-last 20", "help.prune.e1"),
     ("--dry-run", "help.prune.e2"),
     ("--force", "help.prune.e3"),
+    ("--missing-directories", "help.prune.e4"),
+    ("--missing-directories --execute", "help.prune.e5"),
 ]
 
 
@@ -26,6 +28,14 @@ def register(subparsers) -> None:
     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(
+        "--missing-directories",
+        action="store_true",
+        help="Sessions whose directory no longer exists (preview by default)",
+    )
+    p.add_argument("--execute", action="store_true", help="Execute missing-directory cleanup")
+    p.add_argument("--backup", action="store_true", help="Create a DB backup before deletion")
+    p.add_argument("--no-backup", action="store_true", help="Skip the DB backup")
 
 
 def run(args, db) -> int:

{opencode_db-0.8.2 → opencode_db-0.9.0}/opencode_db/i18n.py

@@ -215,6 +215,26 @@ L: dict[str, dict[str, str]] = {
     "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.missing_header": {"ru": "ОЧИСТКА СЕССИЙ ИЗ ОТСУТСТВУЮЩИХ ДИРЕКТОРИЙ", "en": "DELETE SESSIONS FROM MISSING DIRECTORIES"},
+    "delete.missing_none": {"ru": "  ✅ Сессий из отсутствующих директорий не найдено.", "en": "  ✅ No sessions from missing directories found."},
+    "delete.missing_summary": {"ru": "  Сессий: {sessions}, директорий: {dirs}, стоимость: {cost}", "en": "  Sessions: {sessions}, directories: {dirs}, cost: {cost}"},
+    "delete.missing_dir_line": {"ru": "    {path} — {n} сессий", "en": "    {path} — {n} sessions"},
+    "delete.missing_preview": {"ru": "Это preview. Для удаления добавь --execute.", "en": "This is a preview. Add --execute to delete."},
+    "delete.missing_incompatible": {"ru": "--missing-directories нельзя сочетать с --older-than/--before/--after/--keep-last/--interactive/session_id.", "en": "--missing-directories cannot be combined with --older-than/--before/--after/--keep-last/--interactive/session_id."},
+    "delete.missing_execute_requires": {"ru": "--execute используется только вместе с --missing-directories.", "en": "--execute can only be used with --missing-directories."},
+    "delete.missing_no_backup_warning": {"ru": "  ⚠️ Backup отключён (--no-backup). Удаление необратимо.", "en": "  ⚠️ Backup disabled (--no-backup). Deletion is irreversible."},
+    "delete.missing_backup_choice": {"ru": "Для --execute укажи --backup или --no-backup (осознанный выбор).", "en": "For --execute, choose --backup or --no-backup explicitly."},
+    "delete.missing_both_backup": {"ru": "Нельзя одновременно --backup и --no-backup.", "en": "Cannot use --backup and --no-backup together."},
+    "delete.missing_phrase_prompt": {"ru": "Введи точно «{phrase}» для продолжения: ", "en": "Type exactly \"{phrase}\" to continue: "},
+    "delete.missing_phrase_mismatch": {"ru": "Фраза не совпала. Удаление отменено.", "en": "Phrase did not match. Deletion canceled."},
+    "delete.missing_final_confirm": {"ru": "Последнее подтверждение: удалить {n} сессий? Это необратимо.", "en": "Final confirmation: delete {n} sessions? This is irreversible."},
+    "delete.missing_changed": {"ru": "Список кандидатов изменился. Удаление отменено; повтори preview.", "en": "Candidate list changed. Deletion canceled; rerun the preview."},
+    "delete.missing_backup_done": {"ru": "  Backup: {path}", "en": "  Backup: {path}"},
+    "delete.missing_backup_failed": {"ru": "Не удалось создать backup: {error}. Удаление отменено.", "en": "Failed to create backup: {error}. Deletion canceled."},
+    "delete.missing_done": {"ru": "  ✅ Удалено сессий: {n}; строк: {rows}.", "en": "  ✅ Sessions deleted: {n}; rows: {rows}."},
+    "delete.missing_error": {"ru": "Ошибка удаления: {error}. Транзакция отменена.", "en": "Deletion error: {error}. Transaction rolled back."},
+    "delete.missing_db": {"ru": "  База: {path}", "en": "  Database: {path}"},
+    "delete.missing_dry_run": {"ru": "Это preview; база не изменена.", "en": "This is a preview; the database was not changed."},
     "delete.interactive_prompt": {
         "ru": "  Введи номера (1,3-5) или Enter для отмены: ",
         "en": "  Enter numbers (1,3-5) or Enter to cancel: ",
@@ -550,6 +570,10 @@ L: dict[str, dict[str, str]] = {
         "ru": "Удалить сессии до указанной даты",
         "en": "Delete sessions before a date",
     },
+    "help.delete.e7": {"ru": "Очистить сессии из отсутствующих директорий (preview)", "en": "Preview sessions from missing directories"},
+    "help.delete.e8": {"ru": "Выполнить очистку после подтверждений", "en": "Execute cleanup after confirmations"},
+    "help.prune.e4": {"ru": "Preview очистки отсутствующих директорий", "en": "Preview missing-directory cleanup"},
+    "help.prune.e5": {"ru": "Выполнить очистку отсутствующих директорий", "en": "Execute missing-directory cleanup"},
     "help.delete.e6": {
         "ru": "Интерактивный выбор из списка",
         "en": "Choose sessions from a list",

opencode_db-0.9.0/opencode_db/version.py

@@ -0,0 +1,25 @@
+"""Version lookup for the installed package and source checkouts."""
+
+from __future__ import annotations
+
+import tomllib
+from functools import lru_cache
+from importlib.metadata import PackageNotFoundError
+from importlib.metadata import version as package_version
+from pathlib import Path
+
+
+@lru_cache(maxsize=1)
+def get_version() -> str:
+    """Return the installed package version, with a source-tree fallback."""
+    try:
+        return package_version("opencode-db")
+    except PackageNotFoundError:
+        pass
+
+    pyproject = Path(__file__).resolve().parents[1] / "pyproject.toml"
+    try:
+        data = tomllib.loads(pyproject.read_text(encoding="utf-8"))
+        return str(data["project"]["version"])
+    except (OSError, KeyError, TypeError, tomllib.TOMLDecodeError):
+        return "unknown"

{opencode_db-0.8.2 → opencode_db-0.9.0/opencode_db.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opencode-db
-Version: 0.8.2
+Version: 0.9.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
@@ -31,6 +31,7 @@ uv tool install opencode-db
 ## Quick start
 
 ```bash
+opencode-db --version    # installed version
 opencode-db list         # recent sessions
 opencode-db directories  # launch directories, including missing ones
 opencode-db view         # interactive session viewer (colored, scrollable)
@@ -47,7 +48,7 @@ opencode-db help         # full reference
 - **`list`** / **`info`** / **`search`** / **`tree`** — навигация и поиск по сессиям
 - **`directories`** (`dirs`) — все директории запусков, включая отсутствующие; `list --directory` добавляет путь к сессии
 - **`export`** — экспорт диалога в Markdown (с поддержкой Obsidian)
-- **`delete`** / **`prune`** — удаление и массовая очистка с фильтрами
+- **`delete`** / **`prune`** — удаление и массовая очистка с фильтрами; `prune --missing-directories` — защищённая очистка сессий из отсутствующих путей
 - **`costs`** / **`stats`** — аналитика токенов и расходов
 - **`schema`** — определяет v1/v2-схему OpenCode, миграции и доступные операции
 - **`--db-path`** / **`OPENCODE_DB`** — кастомный путь к БД

{opencode_db-0.8.2 → opencode_db-0.9.0}/opencode_db.egg-info/SOURCES.txt

@@ -14,6 +14,7 @@ opencode_db/runtime.py
 opencode_db/schema.py
 opencode_db/schema_manifest.json
 opencode_db/utils.py
+opencode_db/version.py
 opencode_db.egg-info/PKG-INFO
 opencode_db.egg-info/SOURCES.txt
 opencode_db.egg-info/dependency_links.txt
@@ -48,4 +49,5 @@ tests/test_i18n.py
 tests/test_runtime.py
 tests/test_schema.py
 tests/test_store_v2.py
-tests/test_utils.py
+tests/test_utils.py
+tests/test_version.py

{opencode_db-0.8.2 → opencode_db-0.9.0}/pyproject.toml

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

{opencode_db-0.8.2 → opencode_db-0.9.0}/tests/test_commands.py

@@ -784,3 +784,124 @@ class TestDirectoriesCommand:
         )
         assert run(args, db) == 0
         assert "None" not in capsys.readouterr().out
+
+
+class TestMissingDirectoryCleanup:
+    def _args(self, **overrides):
+        values = dict(
+            session_id=None,
+            older_than=None,
+            before=None,
+            after=None,
+            keep_last=None,
+            project=None,
+            dry_run=False,
+            force=False,
+            interactive=False,
+            missing_directories=True,
+            execute=False,
+            backup=False,
+            no_backup=False,
+        )
+        values.update(overrides)
+        return _ns(**values)
+
+    def test_preview_does_not_delete(self, db, capsys) -> None:
+        from opencode_db.commands.cmd_delete import run
+
+        assert run(self._args(), db) == 0
+        assert db.execute("SELECT COUNT(*) FROM session").fetchone()[0] == 4
+        output = capsys.readouterr().out
+        assert "preview" in output.lower()
+        assert "/home/user/proj1" in output
+
+    def test_execute_requires_backup_choice(self, db) -> None:
+        from opencode_db.commands.cmd_delete import run
+
+        assert run(self._args(execute=True, force=True), db) == 1
+        assert db.execute("SELECT COUNT(*) FROM session").fetchone()[0] == 4
+
+    def test_execute_requires_missing_directories(self, db) -> None:
+        from opencode_db.commands.cmd_delete import run
+
+        args = self._args(missing_directories=False, execute=True)
+        assert run(args, db) == 1
+
+    def test_phrase_mismatch_cancels(self, db) -> None:
+        from opencode_db.commands.cmd_delete import run
+
+        with patch("builtins.input", return_value="no"):
+            assert run(self._args(execute=True, no_backup=True), db) == 0
+        assert db.execute("SELECT COUNT(*) FROM session").fetchone()[0] == 4
+
+    def test_final_confirmation_cancels(self, db) -> None:
+        from opencode_db.commands.cmd_delete import run
+
+        with (
+            patch("builtins.input", return_value="DELETE 2 SESSIONS"),
+            patch("opencode_db.commands.cmd_delete.confirm", return_value=False),
+        ):
+            assert run(self._args(execute=True, no_backup=True), db) == 0
+        assert db.execute("SELECT COUNT(*) FROM session").fetchone()[0] == 4
+
+    def test_successful_delete_preserves_existing_directory(self, db_file, tmp_path) -> None:
+        import sqlite3
+
+        from opencode_db.commands.cmd_delete import run
+
+        present = tmp_path / "present"
+        present.mkdir()
+        conn = sqlite3.connect(db_file)
+        conn.row_factory = sqlite3.Row
+        conn.execute("UPDATE session SET directory = ? WHERE id = 'ses_001'", (str(present),))
+        conn.commit()
+
+        with (
+            patch("builtins.input", return_value="DELETE 1 SESSIONS"),
+            patch("opencode_db.commands.cmd_delete.confirm", return_value=True),
+        ):
+            assert run(
+                self._args(execute=True, no_backup=True),
+                conn,
+            ) == 0
+
+        assert conn.execute("SELECT COUNT(*) FROM session").fetchone()[0] == 3
+        assert conn.execute("SELECT id FROM session WHERE id = 'ses_001'").fetchone() is not None
+        assert conn.execute("SELECT id FROM session WHERE id = 'ses_002'").fetchone() is None
+        conn.close()
+
+    def test_backup_and_event_cleanup(self, db_file, tmp_path) -> None:
+        import sqlite3
+
+        from opencode_db.commands.cmd_delete import run
+
+        present = tmp_path / "present"
+        present.mkdir()
+        conn = sqlite3.connect(db_file)
+        conn.row_factory = sqlite3.Row
+        conn.execute("UPDATE session SET directory = ? WHERE id = 'ses_001'", (str(present),))
+        conn.executescript(
+            """
+            CREATE TABLE event_sequence (aggregate_id TEXT, seq INTEGER, owner_id TEXT);
+            CREATE TABLE event (id TEXT, aggregate_id TEXT, seq INTEGER, type TEXT, data TEXT);
+            """
+        )
+        conn.execute(
+            "INSERT INTO event_sequence VALUES ('ses_002', 1, NULL)"
+        )
+        conn.execute(
+            "INSERT INTO event VALUES ('evt_1', 'ses_002', 1, 'test', '{}')"
+        )
+        conn.commit()
+
+        with (
+            patch("builtins.input", return_value="DELETE 1 SESSIONS"),
+            patch("opencode_db.commands.cmd_delete.confirm", return_value=True),
+            patch("opencode_db.commands.cmd_delete.resolve_db_path", return_value=(db_file, False)),
+        ):
+            assert run(self._args(execute=True, backup=True), conn) == 0
+
+        assert list(tmp_path.glob("test.db.bak.*"))
+        assert conn.execute("SELECT COUNT(*) FROM event").fetchone()[0] == 0
+        assert conn.execute("SELECT COUNT(*) FROM event_sequence").fetchone()[0] == 0
+        conn.close()

{opencode_db-0.8.2 → opencode_db-0.9.0}/tests/test_store_v2.py

@@ -379,3 +379,28 @@ def test_v2_projects_global_and_paths(v2db, capsys) -> None:
     assert by_id["global"]["path"] is None
     assert by_id["proj_v2"]["path"] == "/tmp/v2"
     assert by_id["proj_v2"]["name"] == "V2 Project"
+
+
+def test_v2_missing_directory_cleanup_is_refused(v2db, capsys) -> None:
+    from opencode_db.commands import cmd_delete
+
+    code = cmd_delete.run(
+        _ns(
+            session_id=None,
+            older_than=None,
+            before=None,
+            after=None,
+            keep_last=None,
+            project=None,
+            dry_run=False,
+            force=False,
+            interactive=False,
+            missing_directories=True,
+            execute=True,
+            backup=False,
+            no_backup=True,
+        ),
+        v2db,
+    )
+    assert code == 1
+    assert "v2" in capsys.readouterr().out.lower()

opencode_db-0.9.0/tests/test_version.py

@@ -0,0 +1,22 @@
+import re
+
+import pytest
+
+from opencode_db.version import get_version
+
+
+def test_get_version_returns_a_version() -> None:
+    value = get_version()
+    assert value == "unknown" or re.fullmatch(r"\d+\.\d+\.\d+(?:[.\-+][0-9A-Za-z.\-+]+)?", value)
+
+
+def test_version_flag_prints_version(capsys) -> None:
+    from opencode_db.cli import build_parser
+
+    parser = build_parser()
+    with pytest.raises(SystemExit) as exc:
+        parser.parse_args(["--version"])
+
+    assert exc.value.code == 0
+    output = capsys.readouterr().out.strip()
+    assert output == f"opencode-db {get_version()}"