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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opencode-db
-Version: 0.8.0
+Version: 0.8.2
 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
@@ -32,6 +32,7 @@ uv tool install opencode-db
 
 ```bash
 opencode-db list         # recent sessions
+opencode-db directories  # launch directories, including missing ones
 opencode-db view         # interactive session viewer (colored, scrollable)
 opencode-db stats        # database summary
 opencode-db schema       # detect v1/v2 schema
@@ -44,6 +45,7 @@ opencode-db help         # full reference
 
 - **`view`** — просмотр сессии в терминале с ANSI-цветами, Markdown-рендерингом и прокруткой через `less`
 - **`list`** / **`info`** / **`search`** / **`tree`** — навигация и поиск по сессиям
+- **`directories`** (`dirs`) — все директории запусков, включая отсутствующие; `list --directory` добавляет путь к сессии
 - **`export`** — экспорт диалога в Markdown (с поддержкой Obsidian)
 - **`delete`** / **`prune`** — удаление и массовая очистка с фильтрами
 - **`costs`** / **`stats`** — аналитика токенов и расходов
@@ -63,4 +65,6 @@ pip install opencode-db         # zero external dependencies
 - [OpenCode](https://opencode.ai) (must have been run at least once)
 - macOS / Linux
 
+**Directory support:** `global` is a synthetic project for non-Git directories; `directories` shows the real `session.directory` and marks it as `Global (no project root)`. Missing paths are detected with `os.path.isdir()` at command runtime and can be filtered with `--missing`.
+
 **Schema support:** OpenCode 1.19.x (v1) — read and write; OpenCode 2.x preview (v2) — read-only. Run `opencode-db schema` to check the detected schema. On v2, `delete`, `prune`, and `vacuum` are refused until write support is implemented.

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

@@ -172,6 +172,7 @@ opencode-db list --project proj_xxx      # filter by project
 opencode-db list --agent build           # filter by agent type
 opencode-db list --model deepseek        # filter by model name
 opencode-db list --json                  # JSON output
+opencode-db list --all --directory       # include directory paths
 ```
 
 | Flag | Description | Default |
@@ -184,6 +185,37 @@ opencode-db list --json                  # JSON output
 | `--sort {date,cost,tokens,messages}` | Sort order | date |
 | `--json` | Output as JSON | — |
 | `--all` | Show all (overrides --limit) | — |
+| `--directory` | Add a session directory column | — |
+
+---
+
+### `directories` — launch directories
+
+Lists every directory where OpenCode has run, including paths that no longer exist. Combines session directories with project roots and project-directory mappings.
+
+```bash
+opencode-db directories                  # grouped by path
+opencode-db directories --missing        # only missing/inaccessible paths
+opencode-db directories --existing       # only existing paths
+opencode-db directories --project global # Global sessions by real directory
+opencode-db directories --json           # full paths, counts, tokens, cost
+```
+
+`global` is a synthetic project for non-Git directories. The command never shows
+`/` as a real directory; it shows the actual `session.directory` and marks the
+project as `Global (no project root)`.
+
+| Flag | Description | Default |
+|---|---|---|
+| `--missing` | Only paths not found on disk | — |
+| `--existing` | Only paths that exist | — |
+| `--project ID` | Filter by project | — |
+| `--sort {date,sessions,cost,path}` | Sort order | date |
+| `--limit N` | Max entries | 50 |
+| `--no-check` | Skip filesystem check (`exists: null`) | — |
+| `--json` | Output as JSON | — |
+
+> `os.path.isdir()` is a point-in-time check. An offline volume or permission error can look like a missing directory.
 
 ---
 
@@ -390,13 +422,17 @@ Example output:
 Shows all projects in the database with session counts, tokens, and costs.
 
 ```bash
-opencode-db projects                      # project table
+opencode-db projects                      # project table with paths
 opencode-db projects --json               # JSON output
+opencode-db projects --missing            # projects whose path is gone
+opencode-db projects --no-global          # hide the synthetic Global project
 ```
 
 | Flag | Description |
 |---|---|
 | `--json` | JSON output |
+| `--missing` | Only projects with a missing path |
+| `--no-global` | Hide the synthetic Global project |
 
 ---
 
@@ -540,7 +576,7 @@ opencode-db/
 │   ├── config.py                         ← constants and paths
 │   ├── db.py                             ← SQLite queries
 │   ├── formatters.py                     ← tables, JSON, Markdown, snapshots
-│   ├── i18n.py                           ← localization (EN/RU, 296 keys)
+│   ├── i18n.py                           ← localization (EN/RU, 324 keys)
 │   ├── markdown_to_ansi.py               ← Markdown → ANSI renderer for `view`
 │   ├── runtime.py                        ← Python 3.12+ version guard
 │   ├── utils.py                          ← date/token formatting, validation
@@ -689,7 +725,7 @@ opencode-db --lang en help        # English help text
 opencode-db --lang en stats       # English statistics
 ```
 
-The `--lang` flag applies to any command. All 296 UI strings are translated. Data content (session titles, project names, etc.) remains in its original language.
+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 language can also be set via environment variable `OPENCODE_DB_LANG=en`.
 
@@ -774,7 +810,7 @@ source .venv/bin/activate
 uv pip install -e ".[rich]"
 uv pip install pytest ruff==0.17.1
 
-make check          # check-python + ruff + 205 tests
+make check          # check-python + ruff + 214 tests
 ```
 
 `make check` fails fast with a clear message if the active interpreter is older than 3.12.

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

@@ -16,6 +16,7 @@ uv tool install opencode-db
 
 ```bash
 opencode-db list         # recent sessions
+opencode-db directories  # launch directories, including missing ones
 opencode-db view         # interactive session viewer (colored, scrollable)
 opencode-db stats        # database summary
 opencode-db schema       # detect v1/v2 schema
@@ -28,6 +29,7 @@ opencode-db help         # full reference
 
 - **`view`** — просмотр сессии в терминале с ANSI-цветами, Markdown-рендерингом и прокруткой через `less`
 - **`list`** / **`info`** / **`search`** / **`tree`** — навигация и поиск по сессиям
+- **`directories`** (`dirs`) — все директории запусков, включая отсутствующие; `list --directory` добавляет путь к сессии
 - **`export`** — экспорт диалога в Markdown (с поддержкой Obsidian)
 - **`delete`** / **`prune`** — удаление и массовая очистка с фильтрами
 - **`costs`** / **`stats`** — аналитика токенов и расходов
@@ -47,4 +49,6 @@ pip install opencode-db         # zero external dependencies
 - [OpenCode](https://opencode.ai) (must have been run at least once)
 - macOS / Linux
 
+**Directory support:** `global` is a synthetic project for non-Git directories; `directories` shows the real `session.directory` and marks it as `Global (no project root)`. Missing paths are detected with `os.path.isdir()` at command runtime and can be filtered with `--missing`.
+
 **Schema support:** OpenCode 1.19.x (v1) — read and write; OpenCode 2.x preview (v2) — read-only. Run `opencode-db schema` to check the detected schema. On v2, `delete`, `prune`, and `vacuum` are refused until write support is implemented.

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

@@ -43,7 +43,11 @@ def build_parser() -> argparse.ArgumentParser:
     )
 
     subparsers = parser.add_subparsers(dest="command", required=True)
-    for _name, mod in commands.get_all().items():
+    seen: set[str] = set()
+    for mod in commands.get_all().values():
+        if mod.__name__ in seen:
+            continue
+        seen.add(mod.__name__)
         mod.register(subparsers)
     return parser
 

{opencode_db-0.8.0 → opencode_db-0.8.2}/opencode_db/commands/__init__.py

@@ -13,6 +13,7 @@
 from . import (
     cmd_costs,
     cmd_delete,
+    cmd_directories,
     cmd_export,
     cmd_help,
     cmd_info,
@@ -35,6 +36,8 @@ COMMANDS = {
     "info": cmd_info,
     "export": cmd_export,
     "delete": cmd_delete,
+    "directories": cmd_directories,
+    "dirs": cmd_directories,
     "costs": cmd_costs,
     "prune": cmd_prune,
     "search": cmd_search,

opencode_db-0.8.2/opencode_db/commands/cmd_directories.py

@@ -0,0 +1,135 @@
+"""Команда directories: все директории запусков OpenCode."""
+
+import argparse
+from typing import Literal
+
+from ..formatters import print_json, print_table_simple
+from ..i18n import _
+from ..store import open_store
+from ..utils import build_help_epilog, format_cost, format_ts, shorten_path
+
+_DIRECTORIES_EXAMPLES = [
+    ("", "help.directories.e0"),
+    ("--missing", "help.directories.e1"),
+    ("--json", "help.directories.e2"),
+    ("--no-check", "help.directories.e3"),
+]
+
+
+def register(subparsers) -> None:
+    p = subparsers.add_parser(
+        "directories",
+        aliases=["dirs"],
+        help=_("help.cmd.directories"),
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=build_help_epilog("directories", _DIRECTORIES_EXAMPLES),
+    )
+    p.add_argument("--missing", action="store_true", help="Only missing directories")
+    p.add_argument("--existing", action="store_true", help="Only existing directories")
+    p.add_argument("--project", type=str, help="Filter by project ID")
+    p.add_argument(
+        "--sort",
+        choices=["date", "sessions", "cost", "path"],
+        default="date",
+        help="Sort order (default: date)",
+    )
+    p.add_argument("--limit", type=int, default=50, help="Max results (default 50)")
+    p.add_argument("--no-check", action="store_true", help="Skip filesystem check")
+    p.add_argument("--json", action="store_true", help="JSON output")
+
+
+def run(args, db) -> Literal[1] | Literal[0]:
+    if getattr(args, "missing", False) and getattr(args, "existing", False):
+        print(_("directories.conflict"))
+        return 1
+
+    entries = open_store(db).get_directories(check_exists=not getattr(args, "no_check", False))
+
+    if getattr(args, "project", None):
+        entries = [
+            entry
+            for entry in entries
+            if args.project == entry["project_id"] or args.project in entry["project_ids"]
+        ]
+    if getattr(args, "missing", False):
+        entries = [entry for entry in entries if entry["exists"] is False]
+    elif getattr(args, "existing", False):
+        entries = [entry for entry in entries if entry["exists"] is True]
+
+    sorters = {
+        "date": lambda entry: entry["last_ts"] or 0,
+        "sessions": lambda entry: entry["sessions"],
+        "cost": lambda entry: entry["cost"],
+        "path": lambda entry: entry["path"],
+    }
+    reverse = getattr(args, "sort", "date") != "path"
+    entries.sort(key=sorters[getattr(args, "sort", "date")], reverse=reverse)
+    if getattr(args, "limit", 50):
+        entries = entries[: getattr(args, "limit", 50)]
+
+    if getattr(args, "json", False):
+        data = [
+            {
+                "path": entry["path"],
+                "exists": entry["exists"],
+                "project_id": entry["project_id"],
+                "project_ids": entry["project_ids"],
+                "project": entry["project_label"],
+                "is_global": entry["is_global"],
+                "sessions": entry["sessions"],
+                "first_activity": format_ts(entry["first_ts"]) if entry["first_ts"] else None,
+                "last_activity": format_ts(entry["last_ts"]) if entry["last_ts"] else None,
+                "tokens_input": entry["tokens_input"],
+                "tokens_output": entry["tokens_output"],
+                "tokens_reasoning": entry["tokens_reasoning"],
+                "tokens_cache_read": entry["tokens_cache_read"],
+                "tokens_cache_write": entry["tokens_cache_write"],
+                "cost": entry["cost"],
+                "sources": entry["sources"],
+            }
+            for entry in entries
+        ]
+        print_json(data)
+        return 0
+
+    if not entries:
+        print(_("directories.none"))
+        return 0
+
+    status_icon = {True: "✓", False: "✗", None: "?"}
+    table = []
+    for entry in entries:
+        status = {
+            True: _("directories.exists"),
+            False: _("directories.missing"),
+            None: _("directories.unknown"),
+        }[entry["exists"]]
+        last = format_ts(entry["last_ts"], "%Y-%m-%d") if entry["last_ts"] else "—"
+        table.append(
+            [
+                shorten_path(entry["path"], 52),
+                f"{status_icon[entry['exists']]} {status}",
+                entry["project_label"][:22],
+                str(entry["sessions"]),
+                last,
+                format_cost(entry["cost"]),
+            ]
+        )
+
+    print(f"\n  {_('directories.title')}")
+    print_table_simple(
+        [
+            _("directories.header.path"),
+            _("directories.header.status"),
+            _("directories.header.project"),
+            _("directories.header.sessions"),
+            _("directories.header.last"),
+            _("directories.header.cost"),
+        ],
+        table,
+    )
+
+    missing = sum(1 for entry in entries if entry["exists"] is False)
+    sessions = sum(entry["sessions"] for entry in entries)
+    print(_("directories.summary", total=len(entries), sessions=sessions, missing=missing))
+    return 0

{opencode_db-0.8.0 → opencode_db-0.8.2}/opencode_db/commands/cmd_help.py

@@ -41,6 +41,7 @@ _COMMANDS = [
             ("--sort cost", "help.list.e2"),
             ("--project proj_xxx", "help.list.e3"),
             ("--json", "help.list.e4"),
+            ("--directory", "help.list.e5"),
         ],
     ),
     (
@@ -119,6 +120,16 @@ _COMMANDS = [
             ("--json", "help.projects.e1"),
         ],
     ),
+    (
+        "directories",
+        "help.cmd.directories",
+        [
+            ("", "help.directories.e0"),
+            ("--missing", "help.directories.e1"),
+            ("--json", "help.directories.e2"),
+            ("--no-check", "help.directories.e3"),
+        ],
+    ),
     (
         "schema",
         "help.cmd.schema",

{opencode_db-0.8.0 → opencode_db-0.8.2}/opencode_db/commands/cmd_list.py

@@ -7,7 +7,7 @@ from ..db import get_session_title, parse_model
 from ..formatters import print_json, print_table_simple
 from ..i18n import _
 from ..store import open_store
-from ..utils import build_help_epilog, format_ts
+from ..utils import build_help_epilog, format_ts, shorten_path
 
 _LIST_EXAMPLES = [
     ("", "help.list.e0"),
@@ -15,6 +15,7 @@ _LIST_EXAMPLES = [
     ("--sort cost", "help.list.e2"),
     ("--project proj_xxx", "help.list.e3"),
     ("--json", "help.list.e4"),
+    ("--directory", "help.list.e5"),
 ]
 
 
@@ -38,6 +39,7 @@ def register(subparsers) -> None:
     )
     p.add_argument("--json", action="store_true", help="JSON output")
     p.add_argument("--all", action="store_true", help="Show all (no limit)")
+    p.add_argument("--directory", action="store_true", help="Show session directory")
 
 
 def run(args, db) -> Literal[0]:
@@ -60,6 +62,7 @@ def run(args, db) -> Literal[0]:
                     "id": r["id"],
                     "title": get_session_title(r),
                     "project_id": r["project_id"],
+                    "directory": r["directory"],
                     "model": parse_model(r),
                     "agent": r["agent"],
                     "cost": r["cost"],
@@ -78,29 +81,38 @@ def run(args, db) -> Literal[0]:
         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(
+        row = [
+            r["id"][:24],
+            get_session_title(r)[:32],
+            project_name[:16],
+        ]
+        if getattr(args, "directory", False):
+            row.append(shorten_path(r["directory"] or "—", 44))
+        row.extend(
             [
-                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 "—",
             ]
         )
+        table_rows.append(row)
 
-    print_table_simple(
+    headers = [
+        _("list.header.id"),
+        _("list.header.title"),
+        _("list.header.project"),
+    ]
+    if getattr(args, "directory", False):
+        headers.append(_("list.header.directory"))
+    headers.extend(
         [
-            _("list.header.id"),
-            _("list.header.title"),
-            _("list.header.project"),
             _("list.header.model"),
             _("list.header.activity"),
             _("list.header.messages"),
             _("list.header.cost"),
-        ],
-        table_rows,
+        ]
     )
+    print_table_simple(headers, table_rows)
 
     return 0

opencode_db-0.8.2/opencode_db/commands/cmd_projects.py

@@ -0,0 +1,130 @@
+"""Команда projects: список проектов со статистикой."""
+
+import argparse
+import os
+from typing import Literal
+
+from ..i18n import _
+from ..store import open_store
+from ..utils import build_help_epilog, format_cost, format_tokens, format_ts, shorten_path
+
+_PROJECTS_EXAMPLES = [
+    ("", "help.projects.e0"),
+    ("--json", "help.projects.e1"),
+    ("--no-global", "help.projects.e2"),
+    ("--missing", "help.projects.e3"),
+]
+
+
+def register(subparsers) -> None:
+    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")
+    p.add_argument("--no-global", action="store_true", help="Hide the Global project")
+    p.add_argument("--missing", action="store_true", help="Only projects with a missing path")
+
+
+def _project_view(r) -> dict:
+    worktree = r["worktree"]
+    is_global = r["id"] == "global"
+    path = None if is_global else worktree
+    exists = None if is_global else (os.path.isdir(path) if path else False)
+    name = r["name"]
+    if not name and path and not is_global:
+        name = os.path.basename(str(path).rstrip("/")) or None
+    return {
+        "id": r["id"],
+        "name": name,
+        "worktree": worktree,
+        "path": path,
+        "exists": exists,
+        "is_global": is_global,
+        "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"],
+    }
+
+
+def run(args, db) -> Literal[0]:
+    rows = open_store(db).get_projects()
+    views = [_project_view(r) for r in rows]
+    if getattr(args, "no_global", False):
+        views = [v for v in views if not v["is_global"]]
+    if getattr(args, "missing", False):
+        views = [v for v in views if v["exists"] is False]
+
+    if args.json:
+        from ..formatters import print_json
+
+        data = []
+        for v in views:
+            data.append(
+                {
+                    "id": v["id"],
+                    "name": v["name"],
+                    "worktree": v["worktree"],
+                    "path": v["path"],
+                    "exists": v["exists"],
+                    "is_global": v["is_global"],
+                    "time_created": v["time_created"],
+                    "time_updated": v["time_updated"],
+                    "sessions": v["sessions"],
+                    "cost": v["cost"],
+                    "tokens_input": v["tokens_input"],
+                    "tokens_output": v["tokens_output"],
+                    "tokens_reasoning": v["tokens_reasoning"],
+                    "tokens_total": v["tokens_total"],
+                }
+            )
+        print_json(data)
+        return 0
+
+    from ..formatters import print_table_simple
+
+    if not views:
+        print(_("projects.none"))
+        return 0
+
+    table = []
+    for v in views:
+        name = _("projects.global") if v["is_global"] else (v["name"] or "—")
+        path = "—" if v["is_global"] else shorten_path(v["path"], 40)
+        if v["exists"] is False:
+            path = f"{path} ({_('projects.missing')})"
+        updated = v["time_updated"][:10] if v["time_updated"] else "—"
+
+        table.append(
+            [
+                v["id"][:12],
+                name[:20],
+                path,
+                updated,
+                str(v["sessions"]),
+                format_tokens(v["tokens_total"]),
+                format_cost(v["cost"]),
+            ]
+        )
+
+    print_table_simple(
+        [
+            _("projects.header.id"),
+            _("projects.header.name"),
+            _("projects.header.path"),
+            _("projects.header.activity"),
+            _("projects.header.sessions"),
+            _("projects.header.tokens"),
+            _("projects.header.cost"),
+        ],
+        table,
+    )
+
+    return 0

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

@@ -93,6 +93,7 @@ L: dict[str, dict[str, str]] = {
     "list.header.id": {"ru": "ID", "en": "ID"},
     "list.header.title": {"ru": "Название", "en": "Title"},
     "list.header.project": {"ru": "Проект", "en": "Project"},
+    "list.header.directory": {"ru": "Директория", "en": "Directory"},
     "list.header.model": {"ru": "Модель", "en": "Model"},
     "list.header.activity": {"ru": "Активность", "en": "Activity"},
     "list.header.messages": {"ru": "Сообщ.", "en": "Msgs"},
@@ -303,10 +304,14 @@ L: dict[str, dict[str, str]] = {
     # ==================================================================
     "projects.header.id": {"ru": "ID", "en": "ID"},
     "projects.header.name": {"ru": "Название", "en": "Name"},
+    "projects.header.path": {"ru": "Путь", "en": "Path"},
     "projects.header.activity": {"ru": "Активность", "en": "Activity"},
     "projects.header.sessions": {"ru": "Сессии", "en": "Sessions"},
     "projects.header.tokens": {"ru": "Токены", "en": "Tokens"},
     "projects.header.cost": {"ru": "Стоимость", "en": "Cost"},
+    "projects.global": {"ru": "Global (без корня)", "en": "Global (no project root)"},
+    "projects.missing": {"ru": "не найдена", "en": "not found"},
+    "projects.none": {"ru": "Проекты не найдены.", "en": "No projects found."},
     # ==================================================================
     # STATS
     # ==================================================================
@@ -468,6 +473,27 @@ L: dict[str, dict[str, str]] = {
     "help.cmd.search": {"ru": "Поиск по сообщениям", "en": "Search messages"},
     "help.cmd.tree": {"ru": "Дерево ветвления сессий", "en": "Session branching tree"},
     "help.cmd.projects": {"ru": "Список проектов", "en": "Project list"},
+    "help.cmd.directories": {"ru": "Директории запусков", "en": "Launch directories"},
+    "help.directories.e0": {"ru": "Все директории с сессиями", "en": "All directories with sessions"},
+    "help.directories.e1": {"ru": "Только отсутствующие директории", "en": "Only missing directories"},
+    "help.directories.e2": {"ru": "Вывод в JSON", "en": "JSON output"},
+    "help.directories.e3": {"ru": "Не проверять файловую систему", "en": "Skip filesystem check"},
+    "directories.title": {"ru": "Директории запусков OpenCode", "en": "OpenCode launch directories"},
+    "directories.header.path": {"ru": "Путь", "en": "Path"},
+    "directories.header.status": {"ru": "Статус", "en": "Status"},
+    "directories.header.project": {"ru": "Проект", "en": "Project"},
+    "directories.header.sessions": {"ru": "Сессии", "en": "Sessions"},
+    "directories.header.last": {"ru": "Последняя", "en": "Last"},
+    "directories.header.cost": {"ru": "Стоимость", "en": "Cost"},
+    "directories.exists": {"ru": "да", "en": "yes"},
+    "directories.missing": {"ru": "не найдена", "en": "not found"},
+    "directories.unknown": {"ru": "?", "en": "?"},
+    "directories.global": {"ru": "Global (без корня)", "en": "Global (no project root)"},
+    "directories.none": {"ru": "Директории не найдены.", "en": "No directories found."},
+    "directories.total": {"ru": "Всего директорий: {n}", "en": "Directories: {n}"},
+    "directories.summary": {"ru": "Директорий: {total}, сессий: {sessions}, отсутствует: {missing}", "en": "Directories: {total}, sessions: {sessions}, missing: {missing}"},
+    "directories.conflict": {"ru": "Нельзя одновременно использовать --missing и --existing.", "en": "Cannot use --missing and --existing together."},
+
     "help.cmd.stats": {"ru": "Статистика БД", "en": "Database statistics"},
     "help.cmd.todos": {"ru": "Задачи из сессий", "en": "Tasks from sessions"},
     "help.cmd.vacuum": {"ru": "Оптимизация БД", "en": "Database optimization"},
@@ -494,6 +520,7 @@ L: dict[str, dict[str, str]] = {
     "help.list.e2": {"ru": "Сортировка по стоимости", "en": "Sort by cost"},
     "help.list.e3": {"ru": "Фильтр по проекту", "en": "Filter by project"},
     "help.list.e4": {"ru": "Вывод в JSON", "en": "JSON output"},
+    "help.list.e5": {"ru": "Показать директории сессий", "en": "Show session directories"},
     "help.info.e0": {
         "ru": "Все метаданные, токены, todo, ветвление",
         "en": "Metadata, tokens, todos, branching",
@@ -544,6 +571,8 @@ L: dict[str, dict[str, str]] = {
     "help.tree.e2": {"ru": "Глубина 3 уровня", "en": "Max depth of 3"},
     "help.projects.e0": {"ru": "Проекты со статистикой", "en": "Projects with statistics"},
     "help.projects.e1": {"ru": "Вывод в JSON", "en": "JSON output"},
+    "help.projects.e2": {"ru": "Скрыть Global-проект", "en": "Hide the Global project"},
+    "help.projects.e3": {"ru": "Только проекты с отсутствующим путём", "en": "Only projects with a missing path"},
     "help.stats.e0": {
         "ru": "Сессии, сообщения, токены, стоимость, топ моделей",
         "en": "Sessions, messages, tokens, costs, top models",

{opencode_db-0.8.0 → opencode_db-0.8.2}/opencode_db/store/base.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import os
 import sqlite3
 from typing import Any
 
@@ -210,6 +211,129 @@ class BaseStore:
         ).fetchall()
         return [dict(row) for row in rows]
 
+    def get_directories(self, check_exists: bool = True) -> list[dict[str, Any]]:
+        """Aggregate directories from sessions, projects and project mappings."""
+        entries: dict[str, dict[str, Any]] = {}
+
+        def ensure(path: str, project_id: str | None, source: str) -> dict[str, Any]:
+            normalized = os.path.normpath(path)
+            entry = entries.setdefault(
+                normalized,
+                {
+                    "path": normalized,
+                    "sessions": 0,
+                    "first_ts": None,
+                    "last_ts": None,
+                    "tokens_input": 0,
+                    "tokens_output": 0,
+                    "tokens_reasoning": 0,
+                    "tokens_cache_read": 0,
+                    "tokens_cache_write": 0,
+                    "cost": 0.0,
+                    "project_ids": set(),
+                    "session_projects": {},
+                    "project_sources": set(),
+                    "sources": set(),
+                },
+            )
+            entry["sources"].add(source)
+            if project_id:
+                entry["project_ids"].add(project_id)
+                if source == "sessions":
+                    entry["session_projects"][project_id] = (
+                        entry["session_projects"].get(project_id, 0)
+                    )
+                else:
+                    entry["project_sources"].add(project_id)
+            return entry
+
+        session_rows = self.conn.execute(
+            f"""
+            SELECT directory, project_id,
+                   COUNT(*) AS sessions,
+                   MIN(time_created) AS first_ts,
+                   MAX(time_created) AS last_ts,
+                   COALESCE(SUM(tokens_input), 0) AS tokens_input,
+                   COALESCE(SUM(tokens_output), 0) AS tokens_output,
+                   COALESCE(SUM(tokens_reasoning), 0) AS tokens_reasoning,
+                   COALESCE(SUM(tokens_cache_read), 0) AS tokens_cache_read,
+                   COALESCE(SUM(tokens_cache_write), 0) AS tokens_cache_write,
+                   COALESCE(SUM(cost), 0) AS cost
+            FROM {self.session_table}
+            WHERE directory IS NOT NULL AND directory != ''
+            GROUP BY directory, project_id
+            """
+        ).fetchall()
+        for row in session_rows:
+            entry = ensure(row["directory"], row["project_id"], "sessions")
+            entry["sessions"] += int(row["sessions"])
+            entry["session_projects"][row["project_id"]] = int(row["sessions"])
+            for key in ("tokens_input", "tokens_output", "tokens_reasoning",
+                        "tokens_cache_read", "tokens_cache_write"):
+                entry[key] += int(row[key] or 0)
+            entry["cost"] += float(row["cost"] or 0)
+            first_ts = row["first_ts"]
+            last_ts = row["last_ts"]
+            if first_ts is not None:
+                entry["first_ts"] = first_ts if entry["first_ts"] is None else min(entry["first_ts"], first_ts)
+            if last_ts is not None:
+                entry["last_ts"] = last_ts if entry["last_ts"] is None else max(entry["last_ts"], last_ts)
+
+        project_rows = self.conn.execute(
+            "SELECT id, name, worktree FROM project WHERE worktree IS NOT NULL AND worktree != ''"
+        ).fetchall()
+        project_meta = {row["id"]: dict(row) for row in project_rows}
+        for row in project_rows:
+            if row["id"] == "global" and os.path.normpath(row["worktree"]) == "/":
+                continue
+            ensure(row["worktree"], row["id"], "project")
+
+        if "project_directory" in self.schema.tables:
+            directory_rows = self.conn.execute(
+                """
+                SELECT project_id, directory
+                FROM project_directory
+                WHERE directory IS NOT NULL AND directory != ''
+                """
+            ).fetchall()
+            for row in directory_rows:
+                ensure(row["directory"], row["project_id"], "project_directory")
+
+        for entry in entries.values():
+            candidates = [
+                project_id
+                for project_id in entry["project_ids"]
+                if entry["session_projects"].get(project_id, 0) > 0
+            ]
+            if not candidates:
+                candidates = list(entry["project_ids"])
+            non_global = [project_id for project_id in candidates if project_id != "global"]
+            pool = non_global or candidates
+            chosen = max(
+                pool,
+                key=lambda project_id: entry["session_projects"].get(project_id, 0),
+            ) if pool else None
+
+            entry["project_id"] = chosen
+            entry["project_ids"] = sorted(entry["project_ids"])
+            entry["is_global"] = chosen == "global"
+            entry["sources"] = sorted(entry["sources"])
+            if chosen == "global":
+                entry["project_label"] = _("directories.global")
+            elif chosen:
+                meta = project_meta.get(chosen, {})
+                label = meta.get("name")
+                if not label:
+                    worktree = meta.get("worktree") or ""
+                    label = os.path.basename(str(worktree).rstrip("/")) or chosen[:12]
+                entry["project_label"] = str(label)
+            else:
+                entry["project_label"] = "—"
+
+            entry["exists"] = os.path.isdir(entry["path"]) if check_exists else None
+
+        return list(entries.values())
+
     def get_cost_total(self, project_id: str | None = None) -> dict[str, Any]:
         where = "WHERE s.project_id = ?" if project_id else ""
         params: list[Any] = [project_id] if project_id else []

{opencode_db-0.8.0 → opencode_db-0.8.2}/opencode_db/store/v1.py

@@ -136,7 +136,7 @@ class V1Store(BaseStore):
         order = sort_map.get(sort, sort_map["date"])
         rows = self.conn.execute(
             f"""
-            SELECT s.id, s.title, s.model, s.project_id, s.agent,
+            SELECT s.id, s.title, s.model, s.project_id, s.agent, s.directory,
                    s.cost, s.tokens_input, s.tokens_output,
                    MAX(m.time_created) AS last_time,
                    COUNT(DISTINCT m.id) AS msg_count

{opencode_db-0.8.0 → opencode_db-0.8.2}/opencode_db/store/v2.py

@@ -329,7 +329,7 @@ class V2Store(BaseStore):
         order = sort_map.get(sort, sort_map["date"])
         rows = self.conn.execute(
             f"""
-            SELECT s.id, s.title, s.model, s.project_id, s.agent,
+            SELECT s.id, s.title, s.model, s.project_id, s.agent, s.directory,
                    s.cost, s.tokens_input, s.tokens_output,
                    MAX(m.time_created) AS last_time,
                    COUNT(DISTINCT m.id) AS msg_count

{opencode_db-0.8.0 → opencode_db-0.8.2}/opencode_db/utils.py

@@ -37,6 +37,14 @@ def summarize_val(v, max_len=120) -> str:
     return s
 
 
+def shorten_path(path, max_len=48) -> str:
+    """Обрезает длинный путь слева, сохраняя конечные сегменты."""
+    s = str(path)
+    if len(s) <= max_len:
+        return s
+    return "…" + s[-(max_len - 1) :]
+
+
 def parse_date(date_str: str) -> datetime | None:
     """Парсит дату в формате ГГГГ-ММ-ДД."""
     if not date_str or not isinstance(date_str, str):

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opencode-db
-Version: 0.8.0
+Version: 0.8.2
 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
@@ -32,6 +32,7 @@ uv tool install opencode-db
 
 ```bash
 opencode-db list         # recent sessions
+opencode-db directories  # launch directories, including missing ones
 opencode-db view         # interactive session viewer (colored, scrollable)
 opencode-db stats        # database summary
 opencode-db schema       # detect v1/v2 schema
@@ -44,6 +45,7 @@ opencode-db help         # full reference
 
 - **`view`** — просмотр сессии в терминале с ANSI-цветами, Markdown-рендерингом и прокруткой через `less`
 - **`list`** / **`info`** / **`search`** / **`tree`** — навигация и поиск по сессиям
+- **`directories`** (`dirs`) — все директории запусков, включая отсутствующие; `list --directory` добавляет путь к сессии
 - **`export`** — экспорт диалога в Markdown (с поддержкой Obsidian)
 - **`delete`** / **`prune`** — удаление и массовая очистка с фильтрами
 - **`costs`** / **`stats`** — аналитика токенов и расходов
@@ -63,4 +65,6 @@ pip install opencode-db         # zero external dependencies
 - [OpenCode](https://opencode.ai) (must have been run at least once)
 - macOS / Linux
 
+**Directory support:** `global` is a synthetic project for non-Git directories; `directories` shows the real `session.directory` and marks it as `Global (no project root)`. Missing paths are detected with `os.path.isdir()` at command runtime and can be filtered with `--missing`.
+
 **Schema support:** OpenCode 1.19.x (v1) — read and write; OpenCode 2.x preview (v2) — read-only. Run `opencode-db schema` to check the detected schema. On v2, `delete`, `prune`, and `vacuum` are refused until write support is implemented.

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

@@ -23,6 +23,7 @@ opencode_db.egg-info/top_level.txt
 opencode_db/commands/__init__.py
 opencode_db/commands/cmd_costs.py
 opencode_db/commands/cmd_delete.py
+opencode_db/commands/cmd_directories.py
 opencode_db/commands/cmd_export.py
 opencode_db/commands/cmd_help.py
 opencode_db/commands/cmd_info.py

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

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

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

@@ -1,4 +1,5 @@
 import argparse
+import json
 from unittest.mock import patch
 
 
@@ -699,3 +700,87 @@ class TestViewCommand:
         sty = _init_styles(raw=True)
         text = _format_session(db, info, [], sty)
         assert "конец сессии" in text or "end of session" in text
+
+
+class TestDirectoriesCommand:
+    def test_directories_json_includes_project_paths(self, db, capsys) -> None:
+        from opencode_db.commands.cmd_directories import run
+
+        args = _ns(
+            missing=False,
+            existing=False,
+            project=None,
+            sort="path",
+            limit=50,
+            no_check=True,
+            json=True,
+        )
+        assert run(args, db) == 0
+        data = json.loads(capsys.readouterr().out)
+        by_path = {item["path"]: item for item in data}
+        assert by_path["/home/user/proj1"]["sessions"] == 2
+        assert by_path["/home/user/proj1"]["project"] == "My Project"
+        assert by_path["/home/user/proj2"]["sessions"] == 0
+        assert by_path["/home/user/proj2"]["project"] == "proj2"
+
+    def test_directories_missing_and_existing_conflict(self, db) -> None:
+        from opencode_db.commands.cmd_directories import run
+
+        args = _ns(missing=True, existing=True, project=None, sort="date", limit=50, no_check=True, json=True)
+        assert run(args, db) == 1
+
+    def test_list_directory_json(self, db, capsys) -> None:
+        from opencode_db.commands.cmd_list import run
+
+        args = _ns(
+            limit=10,
+            offset=0,
+            project=None,
+            agent=None,
+            model=None,
+            sort="date",
+            json=True,
+            all=False,
+            directory=True,
+        )
+        assert run(args, db) == 0
+        data = json.loads(capsys.readouterr().out)
+        assert data[0]["directory"] == "/home/user/proj1"
+
+    def test_projects_show_paths_and_global(self, db, capsys) -> None:
+        from opencode_db.commands.cmd_projects import run
+
+        args = _ns(json=True, no_global=False, missing=False)
+        assert run(args, db) == 0
+        data = json.loads(capsys.readouterr().out)
+        by_id = {item["id"]: item for item in data}
+        assert by_id["proj_002"]["name"] == "proj2"
+        assert by_id["proj_002"]["path"] == "/home/user/proj2"
+        assert by_id["proj_002"]["exists"] is False
+
+
+    def test_dirs_alias_is_registered(self, db) -> None:
+        from opencode_db.cli import build_parser
+        from opencode_db.commands import get_handler
+
+        parser = build_parser()
+        args = parser.parse_args(["dirs", "--json"])
+        assert args.command == "dirs"
+        assert get_handler("dirs") is get_handler("directories")
+
+    def test_list_directory_table_handles_null(self, db, capsys) -> None:
+        from opencode_db.commands.cmd_list import run
+
+        args = _ns(
+            limit=10,
+            offset=0,
+            project=None,
+            agent=None,
+            model=None,
+            sort="date",
+            json=False,
+            all=False,
+            directory=True,
+        )
+        assert run(args, db) == 0
+        assert "None" not in capsys.readouterr().out

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

@@ -280,3 +280,102 @@ def test_v2_delete_is_refused(v2db, capsys) -> None:
 def test_unknown_message_type_is_ignored(v2db) -> None:
     store = open_store(v2db)
     assert len(store.get_messages("ses_v2")) == 2
+
+
+def test_v2_directories_and_global(v2db, capsys) -> None:
+    from opencode_db.commands import cmd_directories
+
+    v2db.execute(
+        "INSERT INTO project VALUES (?, ?, ?, ?, ?)",
+        ("global", "/", None, TS, TS),
+    )
+    v2db.execute(
+        "INSERT INTO session_v2 (id, directory, project_id, time_created, time_updated) VALUES (?, ?, ?, ?, ?)",
+        ("ses_global", "/tmp/v2-global", "global", TS, TS),
+    )
+
+    cmd_directories.run(
+        _ns(
+            missing=False,
+            existing=False,
+            project=None,
+            sort="path",
+            limit=50,
+            no_check=True,
+            json=True,
+        ),
+        v2db,
+    )
+    data = json.loads(capsys.readouterr().out)
+    by_path = {item["path"]: item for item in data}
+    assert "/" not in by_path
+    assert by_path["/tmp/v2-global"]["is_global"] is True
+    from opencode_db.i18n import _
+
+    assert by_path["/tmp/v2-global"]["project"] == _("directories.global")
+    assert by_path["/tmp/v2"]["project"] == "V2 Project"
+
+
+def test_v2_directories_missing_filter(v2db, tmp_path, capsys) -> None:
+    from opencode_db.commands import cmd_directories
+
+    present = tmp_path / "present"
+    present.mkdir()
+    missing = tmp_path / "gone"
+    v2db.execute(
+        "INSERT INTO session_v2 (id, directory, project_id, time_created, time_updated) VALUES (?, ?, ?, ?, ?)",
+        ("ses_present", str(present), "proj_v2", TS, TS),
+    )
+    v2db.execute(
+        "INSERT INTO session_v2 (id, directory, project_id, time_created, time_updated) VALUES (?, ?, ?, ?, ?)",
+        ("ses_missing", str(missing), "proj_v2", TS, TS),
+    )
+
+    cmd_directories.run(
+        _ns(
+            missing=True,
+            existing=False,
+            project=None,
+            sort="path",
+            limit=50,
+            no_check=False,
+            json=True,
+        ),
+        v2db,
+    )
+    data = json.loads(capsys.readouterr().out)
+    paths = {item["path"] for item in data}
+    assert str(missing) in paths
+    assert str(present) not in paths
+    assert all(item["exists"] is False for item in data)
+
+    cmd_directories.run(
+        _ns(
+            missing=False,
+            existing=True,
+            project=None,
+            sort="path",
+            limit=50,
+            no_check=False,
+            json=True,
+        ),
+        v2db,
+    )
+    data = json.loads(capsys.readouterr().out)
+    assert str(present) in {item["path"] for item in data}
+
+
+def test_v2_projects_global_and_paths(v2db, capsys) -> None:
+    from opencode_db.commands import cmd_projects
+
+    v2db.execute(
+        "INSERT INTO project VALUES (?, ?, ?, ?, ?)",
+        ("global", "/", None, TS, TS),
+    )
+    cmd_projects.run(_ns(json=True, no_global=False, missing=False), v2db)
+    data = json.loads(capsys.readouterr().out)
+    by_id = {item["id"]: item for item in data}
+    assert by_id["global"]["is_global"] is True
+    assert by_id["global"]["path"] is None
+    assert by_id["proj_v2"]["path"] == "/tmp/v2"
+    assert by_id["proj_v2"]["name"] == "V2 Project"

opencode_db-0.8.0/opencode_db/commands/cmd_projects.py

@@ -1,83 +0,0 @@
-"""Команда projects: список проектов со статистикой."""
-
-import argparse
-from typing import Literal
-
-from ..i18n import _
-from ..store import open_store
-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"),
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog=build_help_epilog("projects", _PROJECTS_EXAMPLES),
-    )
-    p.add_argument("--json", action="store_true", help="JSON output")
-
-
-def run(args, db) -> Literal[0]:
-    rows = open_store(db).get_projects()
-
-    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