session-trail 0.2.0__py3-none-any.whl

agent_trail/adapters/kimi_code.py

@@ -0,0 +1,112 @@
+from __future__ import annotations
+
+import json
+from datetime import datetime
+from pathlib import Path
+
+from ..models import ActivitySession, AdapterStatus, ResumePlan, ScanResult
+from .base import BaseAdapter
+from .jsonl_utils import fingerprint_paths, read_jsonl_metadata, to_utc_iso
+
+
+class KimiCodeAdapter(BaseAdapter):
+    source = "kimi-code"
+    adapter_version = 1
+
+    @property
+    def root(self) -> Path:
+        return self.home / ".kimi-code"
+
+    @property
+    def index_path(self) -> Path:
+        return self.root / "session_index.jsonl"
+
+    def watch_roots(self) -> list[tuple[Path, bool]]:
+        return [(self.root, True)]
+
+    def discover(self) -> AdapterStatus:
+        return AdapterStatus(
+            source=self.source,
+            kind="ok" if self.index_path.is_file() else "unavailable",
+        )
+
+    def scan(self, previous_fingerprint: str | None, now: datetime) -> ScanResult:
+        discovery = self.discover()
+        if discovery.kind == "unavailable":
+            return ScanResult(discovery, None, [], True)
+        index = read_jsonl_metadata(
+            self.index_path, {"sessionId", "sessionDir", "workDir"}
+        )
+        entries = [item for item in index.records if item.get("sessionId")]
+        state_paths = [self._state_path(item) for item in entries]
+        fingerprint = fingerprint_paths([self.index_path, *state_paths], self.adapter_version)
+        if fingerprint == previous_fingerprint:
+            return ScanResult(
+                AdapterStatus(
+                    source=self.source,
+                    kind="ok",
+                    record_count=len(entries),
+                    error_count=index.error_count,
+                ),
+                fingerprint,
+                [],
+                False,
+            )
+        sessions: list[ActivitySession] = []
+        error_count = index.error_count
+        for entry in entries:
+            state_path = self._state_path(entry)
+            try:
+                raw = json.loads(state_path.read_text(encoding="utf-8"))
+                state = {key: raw[key] for key in ("id", "cwd", "title", "createdAt", "updatedAt", "archived") if key in raw}
+                session_id = str(entry["sessionId"])
+                workdir = str(state.get("cwd") or entry.get("workDir") or "")
+                if not workdir:
+                    error_count += 1
+                    continue
+                title = state.get("title")
+                updated = state.get("updatedAt") or state_path.stat().st_mtime
+                created = state.get("createdAt")
+                sessions.append(
+                    ActivitySession(
+                        source=self.source,
+                        session_id=session_id,
+                        workdir=workdir,
+                        title=str(title) if title else None,
+                        title_source="native" if title else "fallback",
+                        created_at=to_utc_iso(created) if created is not None else None,
+                        updated_at=to_utc_iso(updated),
+                        source_locator=str(state_path),
+                        resume_kind="cli",
+                        resume_ref=session_id,
+                        archived=bool(state.get("archived", False)),
+                        adapter_version=self.adapter_version,
+                        source_fingerprint=fingerprint,
+                        last_scanned_at=now.isoformat(),
+                    )
+                )
+            except (OSError, json.JSONDecodeError, TypeError, ValueError):
+                error_count += 1
+        status = AdapterStatus(
+            source=self.source,
+            kind="ok",
+            record_count=len(sessions),
+            error_count=error_count,
+        )
+        return ScanResult(status, fingerprint, sessions, True)
+
+    def _state_path(self, entry: dict) -> Path:
+        session_dir = Path(str(entry.get("sessionDir", "")))
+        if not session_dir.is_absolute():
+            session_dir = self.root / session_dir
+        return session_dir / "state.json"
+
+    def resume_plan(self, session: ActivitySession) -> ResumePlan:
+        if session.source_missing or session.resume_kind != "cli" or not session.resume_ref:
+            return ResumePlan(kind="none", workdir=session.workdir, reason="source unavailable")
+        return ResumePlan(
+            kind="cli",
+            executable="kimi",
+            args=("--session", session.resume_ref),
+            workdir=session.workdir,
+        )

agent_trail/adapters/minimax_code.py

@@ -0,0 +1,152 @@
+from __future__ import annotations
+
+import json
+import sqlite3
+from contextlib import closing
+from datetime import datetime
+from pathlib import Path
+
+from ..models import ActivitySession, AdapterStatus, ResumePlan, ScanResult
+from .base import BaseAdapter
+from .jsonl_utils import fingerprint_paths, to_utc_iso
+from .sqlite_utils import connect_readonly
+
+
+class MiniMaxCodeAdapter(BaseAdapter):
+    source = "minimax-code"
+    adapter_version = 1
+
+    @property
+    def database_path(self) -> Path:
+        return self.home / ".minimax" / "v2" / "sqlite" / "runtime-state.sqlite"
+
+    def watch_roots(self) -> list[tuple[Path, bool]]:
+        return [(self.database_path.parent, False)]
+
+    def discover(self) -> AdapterStatus:
+        return AdapterStatus(
+            source=self.source,
+            kind="ok" if self.database_path.is_file() else "unavailable",
+        )
+
+    def scan(self, previous_fingerprint: str | None, now: datetime) -> ScanResult:
+        discovery = self.discover()
+        if discovery.kind == "unavailable":
+            return ScanResult(discovery, None, [], True)
+        wal_path = Path(f"{self.database_path}-wal")
+        paths = [self.database_path, *( [wal_path] if wal_path.is_file() else [] )]
+        fingerprint = fingerprint_paths(paths, self.adapter_version)
+        if fingerprint == previous_fingerprint:
+            return ScanResult(
+                AdapterStatus(source=self.source, kind="ok"), fingerprint, [], False
+            )
+        try:
+            with closing(connect_readonly(self.database_path)) as connection:
+                rows = connection.execute(
+                    "SELECT session_id, workspace_dir, project_workspace_dir, title, "
+                    "created_at_ms, updated_at_ms, archived, project_id, parent_session_id "
+                    "FROM local_runtime_sessions"
+                ).fetchall()
+                project_paths = dict(
+                    connection.execute(
+                        "SELECT project_id, workspace_dir FROM local_runtime_projects"
+                    ).fetchall()
+                )
+                statistics = self._statistics(connection)
+        except sqlite3.Error as error:
+            return ScanResult(self._error_status(error), None, [], True)
+        sessions: list[ActivitySession] = []
+        error_count = 0
+        for row in rows:
+            try:
+                session_id, workdir, project_workdir, title, created, updated, archived, project_id, parent_session_id = row
+                workdir = workdir or project_workdir or project_paths.get(project_id)
+                if not session_id or not workdir:
+                    error_count += 1
+                    continue
+                stats = statistics.get(str(session_id), {})
+                sessions.append(
+                    ActivitySession(
+                        source=self.source,
+                        session_id=str(session_id),
+                        workdir=str(workdir),
+                        title=str(title) if title else None,
+                        title_source="native" if title else "fallback",
+                        created_at=to_utc_iso(created) if created is not None else None,
+                        updated_at=to_utc_iso(updated),
+                        additions=stats.get("additions"),
+                        deletions=stats.get("deletions"),
+                        files_changed=stats.get("files_changed"),
+                        source_locator=str(self.database_path),
+                        resume_kind="none" if parent_session_id else "cli",
+                        resume_ref=None if parent_session_id else str(session_id),
+                        archived=bool(archived),
+                        adapter_version=self.adapter_version,
+                        source_fingerprint=fingerprint,
+                        last_scanned_at=now.isoformat(),
+                    )
+                )
+            except (TypeError, ValueError, OverflowError, OSError):
+                error_count += 1
+        return ScanResult(
+            AdapterStatus(
+                source=self.source,
+                kind="ok",
+                record_count=len(sessions),
+                error_count=error_count,
+            ),
+            fingerprint,
+            sessions,
+            True,
+        )
+
+    @staticmethod
+    def _statistics(connection: sqlite3.Connection) -> dict[str, dict[str, int]]:
+        exists = connection.execute(
+            "SELECT 1 FROM sqlite_master WHERE type='table' AND name='local_runtime_turn_diffs'"
+        ).fetchone()
+        if not exists:
+            return {}
+        statistics: dict[str, dict[str, int]] = {}
+        rows = connection.execute(
+            "SELECT session_id, file_changes_json FROM local_runtime_turn_diffs"
+        )
+        for session_id, raw in rows:
+            try:
+                changes = json.loads(raw)
+                if not isinstance(changes, list):
+                    continue
+                totals = statistics.setdefault(
+                    str(session_id), {"additions": 0, "deletions": 0, "files_changed": 0}
+                )
+                for change in changes:
+                    if not isinstance(change, dict):
+                        continue
+                    for field in ("additions", "deletions"):
+                        value = change.get(field)
+                        if isinstance(value, (int, float)) and not isinstance(value, bool):
+                            totals[field] += int(value)
+                    totals["files_changed"] += 1
+            except (json.JSONDecodeError, TypeError):
+                continue
+        return statistics
+
+    def _error_status(self, error: sqlite3.Error) -> AdapterStatus:
+        temporary = isinstance(error, sqlite3.OperationalError) and any(
+            word in str(error).lower() for word in ("locked", "busy")
+        )
+        return AdapterStatus(
+            source=self.source,
+            kind="error" if temporary else "incompatible",
+            message="database temporarily unavailable" if temporary else "database schema incompatible",
+        )
+
+    def resume_plan(self, session: ActivitySession) -> ResumePlan:
+        if session.source_missing or session.resume_kind != "cli" or not session.resume_ref:
+            return ResumePlan(kind="none", workdir=session.workdir, reason="source unavailable")
+        return ResumePlan(
+            kind="cli",
+            executable="mcode",
+            args=("--session", session.resume_ref),
+            workdir=session.workdir,
+        )

agent_trail/adapters/opencode.py

@@ -0,0 +1,169 @@
+from __future__ import annotations
+
+import json
+import sqlite3
+from contextlib import closing
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+from ..models import ActivitySession, AdapterStatus, ResumePlan, ScanResult
+from .base import BaseAdapter
+from .jsonl_utils import fingerprint_paths, to_utc_iso
+from .sqlite_utils import connect_readonly
+
+
+class OpenCodeAdapter(BaseAdapter):
+    source = "opencode"
+    adapter_version = 1
+
+    @property
+    def root(self) -> Path:
+        return self.home / ".local" / "share" / "opencode"
+
+    @property
+    def database_path(self) -> Path:
+        return self.root / "opencode.db"
+
+    @property
+    def storage_path(self) -> Path:
+        return self.root / "storage" / "session"
+
+    def watch_roots(self) -> list[tuple[Path, bool]]:
+        return [(self.database_path.parent, False), (self.storage_path, True)]
+
+    def discover(self) -> AdapterStatus:
+        available = self.database_path.is_file() or self.storage_path.is_dir()
+        return AdapterStatus(source=self.source, kind="ok" if available else "unavailable")
+
+    def scan(self, previous_fingerprint: str | None, now: datetime) -> ScanResult:
+        discovery = self.discover()
+        if discovery.kind == "unavailable":
+            return ScanResult(discovery, None, [], True)
+        legacy_paths = list(self.storage_path.glob("**/*.json")) if self.storage_path.is_dir() else []
+        database_paths = [self.database_path, Path(f"{self.database_path}-wal")]
+        fingerprint = fingerprint_paths(
+            [path for path in database_paths if path.is_file()] + legacy_paths,
+            self.adapter_version,
+        )
+        if fingerprint == previous_fingerprint:
+            return ScanResult(
+                AdapterStatus(source=self.source, kind="ok"), fingerprint, [], False
+            )
+        database_records: dict[str, dict[str, Any]] = {}
+        if self.database_path.is_file():
+            try:
+                with closing(connect_readonly(self.database_path)) as connection:
+                    rows = connection.execute(
+                        "SELECT id, directory, title, time_created, time_updated, "
+                        "summary_additions, summary_deletions, summary_files, time_archived "
+                        "FROM session"
+                    ).fetchall()
+                for row in rows:
+                    database_records[str(row[0])] = {
+                        "workdir": row[1],
+                        "title": row[2],
+                        "created_at": row[3],
+                        "updated_at": row[4],
+                        "additions": row[5],
+                        "deletions": row[6],
+                        "files_changed": row[7],
+                        "archived": row[8] is not None,
+                        "locator": self.database_path,
+                    }
+            except sqlite3.Error as error:
+                return ScanResult(self._error_status(error), None, [], True)
+        sessions: list[ActivitySession] = []
+        error_count = 0
+        for session_id, record in database_records.items():
+            try:
+                sessions.append(self._record(session_id, record, fingerprint, now))
+            except (TypeError, ValueError, OverflowError, OSError):
+                error_count += 1
+        database_ids = set(database_records)
+        for path in legacy_paths:
+            try:
+                raw = json.loads(path.read_text(encoding="utf-8"))
+                session_id = str(raw.get("id") or "")
+                if not session_id or session_id in database_ids:
+                    continue
+                times = raw.get("time", {})
+                summary = raw.get("summary", {})
+                if not isinstance(times, dict) or not isinstance(summary, dict):
+                    error_count += 1
+                    continue
+                record = {
+                    "workdir": raw.get("directory"),
+                    "title": raw.get("title"),
+                    "created_at": times.get("created"),
+                    "updated_at": times.get("updated"),
+                    "additions": summary.get("additions"),
+                    "deletions": summary.get("deletions"),
+                    "files_changed": summary.get("files"),
+                    "archived": bool(raw.get("archived", False)),
+                    "locator": path,
+                }
+                sessions.append(self._record(session_id, record, fingerprint, now))
+            except (OSError, UnicodeError, json.JSONDecodeError, TypeError, ValueError, OverflowError):
+                error_count += 1
+        return ScanResult(
+            AdapterStatus(
+                source=self.source,
+                kind="ok",
+                record_count=len(sessions),
+                error_count=error_count,
+            ),
+            fingerprint,
+            sessions,
+            True,
+        )
+
+    def _record(
+        self,
+        session_id: str,
+        record: dict[str, Any],
+        fingerprint: str,
+        now: datetime,
+    ) -> ActivitySession:
+        if not record.get("workdir") or record.get("updated_at") is None:
+            raise ValueError("missing session metadata")
+        title = record.get("title")
+        return ActivitySession(
+            source=self.source,
+            session_id=session_id,
+            workdir=str(record["workdir"]),
+            title=str(title) if title else None,
+            title_source="native" if title else "fallback",
+            created_at=to_utc_iso(record["created_at"]) if record.get("created_at") is not None else None,
+            updated_at=to_utc_iso(record["updated_at"]),
+            additions=record.get("additions"),
+            deletions=record.get("deletions"),
+            files_changed=record.get("files_changed"),
+            source_locator=str(record["locator"]),
+            resume_kind="cli",
+            resume_ref=session_id,
+            archived=bool(record.get("archived")),
+            adapter_version=self.adapter_version,
+            source_fingerprint=fingerprint,
+            last_scanned_at=now.isoformat(),
+        )
+
+    def _error_status(self, error: sqlite3.Error) -> AdapterStatus:
+        temporary = isinstance(error, sqlite3.OperationalError) and any(
+            word in str(error).lower() for word in ("locked", "busy")
+        )
+        return AdapterStatus(
+            source=self.source,
+            kind="error" if temporary else "incompatible",
+            message="database temporarily unavailable" if temporary else "database schema incompatible",
+        )
+
+    def resume_plan(self, session: ActivitySession) -> ResumePlan:
+        if session.source_missing or session.resume_kind != "cli" or not session.resume_ref:
+            return ResumePlan(kind="none", workdir=session.workdir, reason="source unavailable")
+        return ResumePlan(
+            kind="cli",
+            executable="opencode",
+            args=("--session", session.resume_ref),
+            workdir=session.workdir,
+        )

agent_trail/adapters/pi.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+from datetime import datetime
+from pathlib import Path
+
+from ..models import ActivitySession, AdapterStatus, ResumePlan, ScanResult
+from .base import BaseAdapter
+from .jsonl_utils import fingerprint_paths, read_jsonl_metadata, to_utc_iso
+
+
+class PiAdapter(BaseAdapter):
+    source = "pi"
+    adapter_version = 1
+
+    @property
+    def root(self) -> Path:
+        return self.home / ".pi" / "agent" / "sessions"
+
+    def watch_roots(self) -> list[tuple[Path, bool]]:
+        return [(self.root, True)]
+
+    def discover(self) -> AdapterStatus:
+        return AdapterStatus(
+            source=self.source,
+            kind="ok" if self.root.is_dir() else "unavailable",
+        )
+
+    def scan(self, previous_fingerprint: str | None, now: datetime) -> ScanResult:
+        discovery = self.discover()
+        if discovery.kind == "unavailable":
+            return ScanResult(discovery, None, [], True)
+        paths = list(self.root.glob("**/*.jsonl"))
+        fingerprint = fingerprint_paths(paths, self.adapter_version)
+        if fingerprint == previous_fingerprint:
+            return ScanResult(
+                AdapterStatus(source=self.source, kind="ok", record_count=len(paths)),
+                fingerprint,
+                [],
+                False,
+            )
+        sessions: list[ActivitySession] = []
+        error_count = 0
+        for path in paths:
+            try:
+                result = read_jsonl_metadata(
+                    path, {"id", "timestamp", "cwd", "type", "name", "title"}
+                )
+                error_count += result.error_count
+                header = next(
+                    (
+                        record
+                        for record in result.records
+                        if record.get("type") == "session" and record.get("id")
+                    ),
+                    None,
+                )
+                if header is None or not header.get("cwd"):
+                    error_count += 1
+                    continue
+                timestamps = []
+                for record in result.records:
+                    if record.get("timestamp") is not None:
+                        try:
+                            timestamps.append(to_utc_iso(record["timestamp"]))
+                        except (TypeError, ValueError, OverflowError, OSError):
+                            error_count += 1
+                title = next(
+                    (
+                        str(record.get("name") or record.get("title"))
+                        for record in reversed(result.records)
+                        if record.get("type")
+                        in {"session_name", "session_title", "name", "title"}
+                        and (record.get("name") or record.get("title"))
+                    ),
+                    None,
+                )
+                updated_at = max(timestamps) if timestamps else to_utc_iso(path.stat().st_mtime)
+                sessions.append(
+                    ActivitySession(
+                        source=self.source,
+                        session_id=str(header["id"]),
+                        workdir=str(header["cwd"]),
+                        title=title,
+                        title_source="native" if title else "fallback",
+                        created_at=min(timestamps) if timestamps else None,
+                        updated_at=updated_at,
+                        source_locator=str(path),
+                        resume_kind="none",
+                        resume_ref=None,
+                        adapter_version=self.adapter_version,
+                        source_fingerprint=fingerprint,
+                        last_scanned_at=now.isoformat(),
+                    )
+                )
+            except (OSError, UnicodeError, TypeError, ValueError, OverflowError):
+                error_count += 1
+        return ScanResult(
+            AdapterStatus(
+                source=self.source,
+                kind="ok",
+                record_count=len(sessions),
+                error_count=error_count,
+            ),
+            fingerprint,
+            sessions,
+            True,
+        )
+
+    def resume_plan(self, session: ActivitySession) -> ResumePlan:
+        return ResumePlan(
+            kind="none",
+            workdir=session.workdir,
+            reason="Pi session restoration was not verified",
+        )

agent_trail/adapters/sqlite_utils.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+import sqlite3
+from pathlib import Path
+
+
+def connect_readonly(path: Path) -> sqlite3.Connection:
+    connection = sqlite3.connect(
+        f"{path.as_uri()}?mode=ro",
+        uri=True,
+        timeout=0.25,
+    )
+    connection.execute("PRAGMA busy_timeout=250")
+    connection.execute("PRAGMA query_only=ON")
+    return connection