opencode-db 0.3.0__py3-none-any.whl

db.py

@@ -0,0 +1,374 @@
+"""Работа с базой данных opencode.
+
+Предоставляет:
+  - get_db() — открыть соединение с БД
+  - get_session_info() — метаданные сессии
+  - get_messages() — сообщения сессии с разбивкой на части
+  - Вспомогательные функции для запросов
+"""
+
+import json
+import os
+import sqlite3
+import sys
+
+from config import OPENCODE_DB
+from i18n import _
+
+# Ожидаемая схема БД: таблица → список обязательных колонок
+_EXPECTED_SCHEMA = {
+    "session": [
+        "id",
+        "title",
+        "model",
+        "cost",
+        "tokens_input",
+        "tokens_output",
+        "tokens_reasoning",
+        "time_created",
+        "time_updated",
+        "project_id",
+        "parent_id",
+    ],
+    "message": ["id", "session_id", "time_created", "data"],
+    "part": ["id", "message_id", "session_id", "time_created", "data"],
+    "todo": ["session_id", "content", "status", "priority"],
+    "project": ["id", "worktree", "name"],
+}
+
+
+def verify_schema(conn) -> bool:
+    """Проверяет, что БД содержит ожидаемые таблицы и колонки."""
+    tables = conn.execute("SELECT name FROM sqlite_master WHERE type='table'").fetchall()
+    existing_tables = {r["name"] for r in tables}
+
+    ok = True
+
+    for table, expected_cols in _EXPECTED_SCHEMA.items():
+        if table not in existing_tables:
+            print(_("schema.table_missing", table=table))
+            ok = False
+            continue
+
+        columns = conn.execute(f"PRAGMA table_info('{table}')").fetchall()
+        existing_cols = {c["name"] for c in columns}
+
+        missing = [c for c in expected_cols if c not in existing_cols]
+        if missing:
+            print(_("schema.column_missing", table=table, columns=", ".join(missing)))
+            ok = False
+
+    if not ok:
+        print(_("schema.check_upgrade"))
+
+    return ok
+
+
+def get_db() -> sqlite3.Connection:
+    """Открывает соединение с БД opencode."""
+    if not os.path.isfile(OPENCODE_DB):
+        print(_("db.not_found", path=OPENCODE_DB))
+        print(_("db.not_found_hint"))
+        sys.exit(1)
+    conn = sqlite3.connect(OPENCODE_DB)
+    conn.row_factory = sqlite3.Row
+    verify_schema(conn)
+    return conn
+
+
+# ======================================================================
+# ЗАПРОСЫ К ТАБЛИЦЕ session
+# ======================================================================
+
+
+def resolve_session_id(db, session_id):
+    """Разрешает ID сессии: точное совпадение или префикс."""
+    if not session_id:
+        return None
+
+    row = db.execute("SELECT id FROM session WHERE id = ?", (session_id,)).fetchone()
+    if row:
+        return row["id"]
+
+    rows = db.execute(
+        "SELECT id FROM session WHERE id LIKE ? COLLATE NOCASE", (f"{session_id}%",)
+    ).fetchall()
+
+    if not rows:
+        print(_("session.not_found", session_id=session_id))
+        sys.exit(1)
+
+    if len(rows) > 1:
+        print(_("session.multiple_match", session_id=session_id))
+        for r in rows:
+            print(f"    {r['id']}")
+        print(_("session.specify_id"))
+        sys.exit(1)
+
+    return rows[0]["id"]
+
+
+def get_session_info(db, session_id):
+    """Достаёт метаданные сессии."""
+    full_id = resolve_session_id(db, session_id)
+
+    row = db.execute(
+        """
+        SELECT s.id, s.title, s.model, s.agent,
+               s.time_created, s.time_updated,
+               s.cost, s.tokens_input, s.tokens_output, s.tokens_reasoning,
+               s.tokens_cache_read, s.tokens_cache_write,
+               s.project_id, s.parent_id, s.directory, s.version,
+               s.summary_additions, s.summary_deletions, s.summary_files
+        FROM session s
+        WHERE s.id = ?
+    """,
+        (full_id,),
+    ).fetchone()
+
+    if not row:
+        print(_("session.not_found", session_id=session_id))
+        sys.exit(1)
+
+    return row
+
+
+def get_session_title(row):
+    """Извлекает название сессии, подставляя 'Безымянная' если None."""
+    return row["title"] or _("info.unnamed")
+
+
+def parse_model(row):
+    """Парсит JSON модели из строки БД."""
+    model_json = row["model"]
+    if not model_json:
+        return "—"
+    try:
+        return json.loads(model_json).get("id", "—")
+    except (json.JSONDecodeError, TypeError):
+        return str(model_json)[:40]
+
+
+# ======================================================================
+# ЗАПРОСЫ К ТАБЛИЦАМ message + part
+# ======================================================================
+
+
+def get_messages(db, session_id):
+    """Достаёт все сообщения сессии с разбивкой на части.
+
+    Returns:
+      list[dict]: {"id", "role", "agent", "time", "parts": [...]}
+    """
+    rows = db.execute(
+        """
+        SELECT m.id,
+               json_extract(m.data, '$.role') as role,
+               json_extract(m.data, '$.agent') as agent,
+               m.time_created,
+               p.data as part_data
+        FROM message m
+        LEFT JOIN part p ON p.message_id = m.id
+        WHERE m.session_id = ?
+        ORDER BY m.time_created, p.id
+    """,
+        (session_id,),
+    ).fetchall()
+
+    messages = []
+    current = None
+
+    for row in rows:
+        msg_id = row["id"]
+        part_data = row["part_data"]
+
+        if not part_data:
+            continue
+
+        try:
+            data = json.loads(part_data)
+        except json.JSONDecodeError:
+            continue
+
+        part_type = data.get("type", "")
+
+        if current and current["id"] == msg_id:
+            parts = current["parts"]
+        else:
+            if current:
+                messages.append(current)
+            current = {
+                "id": msg_id,
+                "role": row["role"],
+                "agent": row["agent"],
+                "time": row["time_created"],
+                "parts": [],
+            }
+            parts = current["parts"]
+
+        if part_type == "text":
+            text = data.get("text", "")
+            if text.strip():
+                parts.append({"type": "text", "text": text})
+
+        elif part_type in ("reasoning", "thought"):
+            text = data.get("text", "")
+            if text.strip():
+                parts.append({"type": "reasoning", "text": text})
+
+        elif part_type in ("tool", "result"):
+            state = data.get("state", {})
+            parts.append(
+                {
+                    "type": "tool",
+                    "tool": data.get("tool", state.get("tool", "")),
+                    "input": state.get("input", {}),
+                    "output": state.get("output", ""),
+                    "status": state.get("status", ""),
+                }
+            )
+
+        elif part_type == "sound":
+            parts.append({"type": "sound"})
+
+    if current:
+        messages.append(current)
+
+    return messages
+
+
+# ======================================================================
+# ПОДСЧЁТЫ
+# ======================================================================
+
+
+def get_session_count(db, project_id=None):
+    """Количество сессий. Опционально — по проекту."""
+    if project_id:
+        return db.execute(
+            "SELECT COUNT(*) FROM session WHERE project_id = ?", (project_id,)
+        ).fetchone()[0]
+    return db.execute("SELECT COUNT(*) FROM session").fetchone()[0]
+
+
+def get_message_count(db, session_id=None):
+    """Количество сообщений. Опционально — по сессии."""
+    if session_id:
+        return db.execute(
+            "SELECT COUNT(*) FROM message WHERE session_id = ?", (session_id,)
+        ).fetchone()[0]
+    return db.execute("SELECT COUNT(*) FROM message").fetchone()[0]
+
+
+def get_part_count(db, session_id=None):
+    """Количество частей сообщений. Опционально — по сессии."""
+    if session_id:
+        return db.execute(
+            "SELECT COUNT(*) FROM part WHERE session_id = ?", (session_id,)
+        ).fetchone()[0]
+    return db.execute("SELECT COUNT(*) FROM part").fetchone()[0]
+
+
+def get_project_count(db):
+    """Количество проектов в БД."""
+    return db.execute("SELECT COUNT(*) FROM project").fetchone()[0]
+
+
+# ======================================================================
+# СВЯЗАННЫЕ ДАННЫЕ
+# ======================================================================
+
+
+def get_children_sessions(db, session_id):
+    """Дочерние сессии (ответвившиеся от данной)."""
+    return db.execute(
+        """
+        SELECT id, title, time_created
+        FROM session
+        WHERE parent_id = ?
+        ORDER BY time_created
+    """,
+        (session_id,),
+    ).fetchall()
+
+
+def get_parent_session(db, session_id):
+    """Родительская сессия (от которой ответвилась данная)."""
+    row = db.execute(
+        """
+        SELECT s2.id, s2.title, s2.time_created
+        FROM session s1
+        JOIN session s2 ON s2.id = s1.parent_id
+        WHERE s1.id = ?
+    """,
+        (session_id,),
+    ).fetchone()
+    return row
+
+
+def get_session_todos(db, session_id):
+    """Todo-записи для сессии."""
+    return db.execute(
+        """
+        SELECT content, status, priority, position, time_created
+        FROM todo
+        WHERE session_id = ?
+        ORDER BY position
+    """,
+        (session_id,),
+    ).fetchall()
+
+
+def get_project_name(db, project_id):
+    """Возвращает название проекта по ID."""
+    row = db.execute("SELECT name, worktree FROM project WHERE id = ?", (project_id,)).fetchone()
+    if row:
+        return row["name"] or os.path.basename(row["worktree"]) or project_id[:12]
+    return project_id[:12]
+
+
+def get_latest_session(db):
+    """Находит ID самой свежей сессии (по последнему сообщению или времени создания)."""
+    row = db.execute("""
+        SELECT s.id FROM session s
+        LEFT JOIN message m ON m.session_id = s.id
+        GROUP BY s.id
+        ORDER BY COALESCE(MAX(m.time_created), s.time_created) DESC
+        LIMIT 1
+    """).fetchone()
+
+    if not row:
+        print(_("session.no_sessions"))
+        sys.exit(1)
+
+    return row["id"]
+
+
+def get_recent_sessions(db, limit=15, project_id=None):
+    """Возвращает список последних сессий для интерактивного выбора."""
+    if project_id:
+        return db.execute(
+            """
+            SELECT s.id, s.title, s.model, s.time_created, s.cost,
+                   COUNT(DISTINCT m.id) as msg_count
+            FROM session s
+            LEFT JOIN message m ON m.session_id = s.id
+            WHERE s.project_id = ?
+            GROUP BY s.id
+            ORDER BY COALESCE(MAX(m.time_created), s.time_created) DESC
+            LIMIT ?
+        """,
+            (project_id, limit),
+        ).fetchall()
+    return db.execute(
+        """
+        SELECT s.id, s.title, s.model, s.time_created, s.cost,
+               COUNT(DISTINCT m.id) as msg_count
+        FROM session s
+        LEFT JOIN message m ON m.session_id = s.id
+        GROUP BY s.id
+        ORDER BY COALESCE(MAX(m.time_created), s.time_created) DESC
+        LIMIT ?
+    """,
+        (limit,),
+    ).fetchall()

formatters.py

@@ -0,0 +1,208 @@
+"""Форматирование вывода: таблицы, JSON, Markdown."""
+
+import json
+import os
+
+from config import IGNORE_DIRS
+from i18n import _
+
+
+def print_json(data) -> None:
+    """Выводит данные в JSON-формате."""
+    print(json.dumps(data, ensure_ascii=False, indent=2, default=str))
+
+
+def print_table_simple(headers, rows, sep="  ") -> None:
+    """Выводит таблицу с авто-шириной колонок."""
+    if not rows:
+        print(_("empty"))
+        return
+
+    widths = []
+    for ci in range(len(headers)):
+        max_w = len(headers[ci])
+        for row in rows:
+            max_w = max(max_w, len(str(row[ci])))
+        widths.append(min(max_w + 1, 80))
+
+    line = sep.join(h.ljust(widths[i])[: widths[i]] for i, h in enumerate(headers))
+    sep_line = "─" * len(line)
+
+    print()
+    print(line)
+    print(sep_line)
+    for row in rows:
+        line = sep.join(str(row[i]).ljust(widths[i])[: widths[i]] for i in range(len(headers)))
+        print(line)
+    print(_("fmt.rows_count", n=len(rows)))
+
+
+def summarize_val(v, max_len=120) -> str:
+    """Обрезает длинное значение."""
+    s = str(v)
+    if len(s) > max_len:
+        s = s[:max_len] + "..."
+    return s
+
+
+def format_part_to_md(part, full=False):
+    """Преобразует часть сообщения в строку Markdown.
+
+    Args:
+      part: dict из get_messages()
+      full: если True — не обрезать длинные output'ы и input'ы
+
+    Returns:
+      str — Markdown
+    """
+    t = part["type"]
+
+    if t == "text":
+        return part.get("text", "").strip()
+
+    if t == "reasoning":
+        text = part.get("text", "").strip()
+        title = _("md.reasoning")
+        return f"**💭 {title}:**\n{text}" if text else ""
+
+    if t == "sound":
+        return _("*🔊 {msg}*", msg=_("md.sound"))
+
+    if t == "tool":
+        tool_name = part.get("tool", "?")
+        t_input = part.get("input", {})
+        t_output = part.get("output", "")
+        t_status = part.get("status", "")
+
+        icon = {"completed": "✅", "error": "❌", "running": "⏳"}.get(t_status, "🔧")
+
+        if tool_name in ("read", "write", "edit", "glob", "grep"):
+            if tool_name == "read":
+                fp = (
+                    t_input.get("filePath", "")
+                    if full
+                    else summarize_val(t_input.get("filePath", ""))
+                )
+                return f"**{icon} read:** `{fp}`"
+            elif tool_name == "write":
+                fp = (
+                    t_input.get("filePath", "")
+                    if full
+                    else summarize_val(t_input.get("filePath", ""), 80)
+                )
+                return f"**{icon} write:** `{fp}`"
+            elif tool_name == "edit":
+                fp = (
+                    t_input.get("filePath", "")
+                    if full
+                    else summarize_val(t_input.get("filePath", ""), 80)
+                )
+                return f"**{icon} edit:** `{fp}`"
+            elif tool_name == "glob":
+                pat = (
+                    t_input.get("pattern", "")
+                    if full
+                    else summarize_val(t_input.get("pattern", ""), 80)
+                )
+                pth = (
+                    t_input.get("path", "") if full else summarize_val(t_input.get("path", ""), 60)
+                )
+                return f"**{icon} glob:** `{pat}` в `{pth}`"
+            elif tool_name == "grep":
+                pat = (
+                    t_input.get("pattern", "")
+                    if full
+                    else summarize_val(t_input.get("pattern", ""), 80)
+                )
+                return f"**{icon} grep:** `{pat}`"
+
+        lines = [f"**{icon} {tool_name}**"]
+
+        if t_input:
+            for k, v in t_input.items():
+                if full:
+                    s = str(v)
+                    if len(s) > 500:
+                        lines.append(f"  {k}:\n\n```\n{s}\n```")
+                    else:
+                        lines.append(f"  {k}: {s}")
+                else:
+                    lines.append(f"  {k}: {summarize_val(v, 200)}")
+
+        if t_output:
+            out = str(t_output).strip()
+            if not out:
+                pass
+            elif full:
+                if len(out) > 500:
+                    lines.append(f"\n  → {_('md.result')}:\n\n```\n{out}\n```")
+                else:
+                    lines.append(f"  → {out}")
+            else:
+                if len(out) > 300:
+                    lines.append(f"  → {summarize_val(out, 280)}")
+                else:
+                    lines.append(f"  → {out}")
+
+        return "\n".join(lines)
+
+    return ""
+
+
+def collect_snapshot(project_dir):
+    """Собирает статистику по проекту для log.md.
+
+    Returns:
+      dict: {"agents_md": str, "file_count": int, "dir_count": int}
+    """
+    snapshot = {}
+
+    agents_path = os.path.join(project_dir, "AGENTS.md")
+    if os.path.isfile(agents_path):
+        with open(agents_path, encoding="utf-8") as f:
+            content = f.read()
+        lines = content.count("\n") + 1
+        sections = content.count("\n## ")
+        snapshot["agents_md"] = _("md.log_lines", lines=lines, sections=sections)
+    else:
+        snapshot["agents_md"] = _("md.log_not_found")
+
+    all_files = 0
+    all_dirs = 0
+    for root, dirs, files in os.walk(project_dir):
+        dirs[:] = [d for d in dirs if d not in IGNORE_DIRS]
+        if os.path.relpath(root, project_dir) == ".":
+            all_files += len(files)
+        else:
+            all_dirs += 1
+            all_files += len(files)
+
+    snapshot["file_count"] = all_files
+    snapshot["dir_count"] = all_dirs
+    return snapshot
+
+
+def update_log(output_dir, title, note, dialog_filename, snapshot, now_str) -> None:
+    """Создаёт или дополняет log.md в директории проекта."""
+    log_path = os.path.join(output_dir, "log.md")
+    heading = f"{title}: {note}" if note else title
+    dialog_link = os.path.basename(dialog_filename) if dialog_filename else "—"
+
+    agents_line = _("md.log_agents", v=snapshot["agents_md"])
+    files_line = _("md.log_files", files=snapshot["file_count"], dirs=snapshot["dir_count"])
+
+    entry = f"""## [{now_str}] {heading}
+
+- **{_("md.header.title")}:** [[{dialog_link}]]
+- **Snapshot:**
+  - {agents_line}
+  - {files_line}
+
+---
+
+"""
+
+    with open(log_path, "a", encoding="utf-8") as f:
+        f.write(entry)
+
+    print(_("log_updated", path=log_path))