sessionwiki 2.0.0__py3-none-any.whl

sessionwiki/adapters/contrib/copilot_cli.py

@@ -0,0 +1,115 @@
+"""GitHub Copilot CLI adapter.
+
+Reads session event logs from the Copilot CLI's local state directory.
+
+Copilot CLI stores per-session event logs under:
+    ~/.copilot/session-state/<session-id>/events.jsonl
+
+The COPILOT_HOME environment variable, when set, overrides the default
+~/.copilot base directory.
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Any
+
+from sessionwiki.adapters import register
+from sessionwiki.adapters.base import BaseAdapter
+
+
+def _build_default_roots() -> list[Path]:
+    """Build DEFAULT_ROOTS, incorporating COPILOT_HOME if set."""
+    home = Path.home()
+    roots: list[Path] = [
+        home / ".copilot" / "session-state",
+    ]
+    copilot_home = os.environ.get("COPILOT_HOME")
+    if copilot_home:
+        roots.append(Path(copilot_home).expanduser() / "session-state")
+    return roots
+
+
+@register("copilot_cli", aliases=["copilot-cli"])
+class CopilotCliAdapter(BaseAdapter):
+    """GitHub Copilot CLI — reads ~/.copilot/session-state/*/events.jsonl.
+
+    #arch-l5 (#626): canonical name is ``copilot_cli`` (snake_case,
+    matching every other adapter). The kebab-case ``copilot-cli`` is
+    kept as a REGISTRY alias and still recognised in
+    ``sessions_config.json`` so existing user configs don't break.
+    """
+
+    # #arch-m9 (#621): SUPPORTED_SCHEMA_VERSIONS = ["v1"] is the
+    # BaseAdapter default — declaration removed here.
+
+    DEFAULT_ROOTS: list[Path] = _build_default_roots()
+
+    def __init__(self, config: dict[str, Any] | None = None):
+        super().__init__(config)
+        adapters_cfg = (config or {}).get("adapters", {}) or {}
+        # #626: read snake_case config first; fall back to legacy
+        # kebab-case so existing sessions_config.json keeps working.
+        ad_cfg = adapters_cfg.get("copilot_cli") or adapters_cfg.get("copilot-cli") or {}
+        paths = ad_cfg.get("roots") or []
+        self.roots: list[Path] = (
+            [Path(p).expanduser() for p in paths] if paths else self.DEFAULT_ROOTS
+        )
+
+    @property
+    def session_store_path(self):  # type: ignore[override]
+        return self.roots
+
+    # #496: kept as an explicit override because it has special
+    # COPILOT_HOME env-var handling that BaseAdapter.is_available()
+    # (which only checks self.session_store_path) doesn't cover. The
+    # base impl is still reachable via super().is_available() if the
+    # env-var check fails.
+    @classmethod
+    def is_available(cls) -> bool:
+        for p in cls.DEFAULT_ROOTS:
+            if Path(p).expanduser().exists():
+                return True
+        # Also check COPILOT_HOME at call time (may be set after import)
+        copilot_home = os.environ.get("COPILOT_HOME")
+        if copilot_home:
+            p = Path(copilot_home).expanduser() / "session-state"
+            if p.exists():
+                return True
+        return False
+
+    def discover_sessions(self) -> list[Path]:
+        """Find events.jsonl files under each session-id directory."""
+        out: list[Path] = []
+        for root in self.roots:
+            root = Path(root).expanduser()
+            if not root.exists():
+                continue
+            # Walk <root>/<session-id>/events.jsonl
+            out.extend(sorted(root.glob("*/events.jsonl")))
+        # De-dupe while preserving order
+        seen: set[Path] = set()
+        unique: list[Path] = []
+        for p in out:
+            if p not in seen:
+                seen.add(p)
+                unique.append(p)
+        return unique
+
+    def derive_project_slug(self, path: Path) -> str:
+        """Use the session-id directory name as the project slug.
+
+        Layout: <root>/<session-id>/events.jsonl
+        The session-id directory is the immediate parent of events.jsonl.
+        """
+        for root in self.roots:
+            root = Path(root).expanduser()
+            try:
+                rel = path.relative_to(root)
+                if rel.parts:
+                    return rel.parts[0]
+            except ValueError:
+                continue
+        # Fallback: use the parent directory name
+        return path.parent.name

sessionwiki/adapters/contrib/cursor.py

@@ -0,0 +1,100 @@
+"""Cursor adapter.
+
+Reads conversation history from Cursor IDE's local state.
+
+Status: v0.2 initial implementation. Cursor stores chat history in an SQLite
+database under ~/Library/Application Support/Cursor/User/workspaceStorage/
+(macOS) or %APPDATA%\\Cursor\\User\\workspaceStorage\\ (Windows).
+
+v0.2 scope:
+- Detects Cursor install by checking the known paths
+- Discovers workspace-level conversation stores
+- Marks itself available if the paths exist
+- Does NOT yet parse the SQLite records (v0.3 work once we have a real Cursor
+  install to test against)
+
+The adapter registers cleanly and is listed as "available: yes" if Cursor is
+installed, so users know the scaffold is present. Full record parsing is
+tracked in the v0.3 milestone.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from sessionwiki.adapters import register
+from sessionwiki.adapters.base import BaseAdapter
+
+
+@register("cursor")
+class CursorAdapter(BaseAdapter):
+    """Cursor IDE — reads chat history from ~/Library/Application Support/Cursor/"""
+
+    SUPPORTED_SCHEMA_VERSIONS = ["v1"]  # to be pinned against a real Cursor install
+
+    # Cursor stores per-workspace data under these roots
+    DEFAULT_ROOTS = [
+        # macOS
+        Path.home() / "Library" / "Application Support" / "Cursor" / "User" / "workspaceStorage",
+        # Linux
+        Path.home() / ".config" / "Cursor" / "User" / "workspaceStorage",
+        # Windows (via %APPDATA%) — Python expands %APPDATA% only via os.environ
+        Path.home() / "AppData" / "Roaming" / "Cursor" / "User" / "workspaceStorage",
+    ]
+
+    # Known file patterns to match. Cursor stores conversation data in
+    # SQLite (state.vscdb) per-workspace; v0.3 will add the SQLite parser.
+    SESSION_FILE_PATTERNS = ["*.jsonl", "state.vscdb"]
+
+    def __init__(self, config: dict[str, Any] | None = None):
+        super().__init__(config)
+        ad_cfg = (config or {}).get("adapters", {}).get("cursor", {})
+        paths = ad_cfg.get("roots") or []
+        self.roots: list[Path] = (
+            [Path(p).expanduser() for p in paths] if paths else self.DEFAULT_ROOTS
+        )
+
+    @property
+    def session_store_path(self):  # type: ignore[override]
+        return self.roots
+
+    # #496: is_available() inherited from BaseAdapter — temp
+    # instance reads self.session_store_path through the @property.
+
+    def discover_sessions(self) -> list[Path]:
+        """Find every conversation file under every configured root.
+
+        v0.2 returns .jsonl files (if any exist — some Cursor builds export
+        chat history as .jsonl). v0.3 will add SQLite state.vscdb parsing.
+        """
+        out: list[Path] = []
+        for root in self.roots:
+            root = Path(root).expanduser()
+            if not root.exists():
+                continue
+            for pattern in self.SESSION_FILE_PATTERNS:
+                out.extend(sorted(root.rglob(pattern)))
+        # De-dupe while preserving order
+        seen: set[Path] = set()
+        unique: list[Path] = []
+        for p in out:
+            if p not in seen:
+                seen.add(p)
+                unique.append(p)
+        return unique
+
+    def derive_project_slug(self, path: Path) -> str:
+        """Cursor workspace directories are hashed; fall back to the hash as the
+        slug. v0.3 will read workspace.json to get the friendly project name.
+        """
+        # Walk up to find the workspaceStorage/<hash>/ parent
+        for root in self.roots:
+            root = Path(root).expanduser()
+            try:
+                rel = path.relative_to(root)
+                if rel.parts:
+                    return f"cursor-{rel.parts[0][:12]}"
+            except ValueError:
+                continue
+        return path.parent.name

sessionwiki/adapters/contrib/gemini_cli.py

@@ -0,0 +1,74 @@
+"""Gemini CLI adapter.
+
+Reads conversation history from Google's Gemini CLI.
+
+Status: v0.3 initial implementation. Gemini CLI stores sessions under
+~/.gemini/ (exact layout TBC against a real install). The adapter detects
+the directory and discovers .jsonl / .json files inside.
+
+Registers as "available" if any of the known Gemini CLI paths exist.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from sessionwiki.adapters import register
+from sessionwiki.adapters.base import BaseAdapter
+
+
+@register("gemini_cli")
+class GeminiCliAdapter(BaseAdapter):
+    """Gemini CLI — reads ~/.gemini/ session history"""
+
+    SUPPORTED_SCHEMA_VERSIONS = ["v1"]
+
+    DEFAULT_ROOTS = [
+        # macOS / Linux / Windows (dot-dir works everywhere)
+        Path.home() / ".gemini",
+        # Linux (XDG)
+        Path.home() / ".config" / "gemini",
+        Path.home() / ".local" / "share" / "gemini",
+        # Windows (%APPDATA%)
+        Path.home() / "AppData" / "Roaming" / "gemini",
+    ]
+
+    def __init__(self, config: dict[str, Any] | None = None):
+        super().__init__(config)
+        ad_cfg = (config or {}).get("adapters", {}).get("gemini_cli", {})
+        paths = ad_cfg.get("roots") or []
+        self.roots: list[Path] = (
+            [Path(p).expanduser() for p in paths] if paths else self.DEFAULT_ROOTS
+        )
+
+    @property
+    def session_store_path(self):  # type: ignore[override]
+        return self.roots
+
+    # #496: is_available() inherited from BaseAdapter — temp
+    # instance reads self.session_store_path through the @property.
+
+    def discover_sessions(self) -> list[Path]:
+        out: list[Path] = []
+        for root in self.roots:
+            root = Path(root).expanduser()
+            if not root.exists():
+                continue
+            # Look for both .jsonl and .json (Gemini CLI format TBC)
+            out.extend(sorted(root.rglob("*.jsonl")))
+            out.extend(sorted(root.rglob("chat-*.json")))
+            out.extend(sorted(root.rglob("session-*.json")))
+        return out
+
+    def derive_project_slug(self, path: Path) -> str:
+        # Gemini CLI doesn't have an obvious project encoding yet; use the
+        # parent directory name
+        for root in self.roots:
+            root = Path(root).expanduser()
+            try:
+                rel = path.relative_to(root)
+                return f"gemini-{rel.parts[0].lower()}" if rel.parts else "gemini-root"
+            except ValueError:
+                continue
+        return f"gemini-{path.parent.name.lower()}"

sessionwiki/adapters/contrib/obsidian.py

@@ -0,0 +1,121 @@
+"""Obsidian vault adapter.
+
+Reads .md files from an Obsidian vault and treats each as a source document.
+Unlike the Claude Code / Codex CLI adapters which parse .jsonl transcripts,
+this adapter reads plain markdown that the user has already written.
+
+It skips Obsidian's own internal files (`.obsidian/`, trash, templates) and
+the `_templates/` convention seen in some vaults.
+
+Config (in `examples/sessions_config.json`):
+
+    {
+      "adapters": {
+        "obsidian": {
+          "vault_paths": ["~/Documents/Obsidian Vault"],
+          "exclude_folders": [".obsidian", "Templates", "_templates", ".trash"],
+          "min_content_chars": 50
+        }
+      }
+    }
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from sessionwiki.adapters import register
+from sessionwiki.adapters.base import BaseAdapter
+
+
+@register("obsidian")
+class ObsidianAdapter(BaseAdapter):
+    """Obsidian — reads .md files from an Obsidian vault"""
+
+    #: #326: Obsidian is user-authored content, not an AI session store.
+    #: Opt-in only so ``sessionwiki sync`` never silently ingests a user's
+    #: personal vault.
+    is_ai_session = False
+
+    SUPPORTED_SCHEMA_VERSIONS = ["1.x"]
+
+    DEFAULT_VAULT_PATHS = [
+        # macOS / Linux / Windows — common default vault locations
+        Path.home() / "Documents" / "Obsidian Vault",
+        Path.home() / "Obsidian",
+        # Windows (%APPDATA%) — some installs create vaults here
+        Path.home() / "AppData" / "Local" / "Obsidian" / "Vault",
+    ]
+
+    DEFAULT_EXCLUDE_FOLDERS = {
+        ".obsidian",
+        ".trash",
+        "Templates",
+        "_templates",
+        "templates",
+        ".git",
+        "node_modules",
+    }
+
+    def __init__(self, config: dict[str, Any] | None = None):
+        super().__init__(config)
+        ad_cfg = (config or {}).get("adapters", {}).get("obsidian", {})
+        paths = ad_cfg.get("vault_paths") or []
+        self.vault_paths: list[Path] = (
+            [Path(p).expanduser() for p in paths] if paths else self.DEFAULT_VAULT_PATHS
+        )
+        self.exclude_folders: set[str] = set(
+            ad_cfg.get("exclude_folders", self.DEFAULT_EXCLUDE_FOLDERS)
+        )
+        self.min_content_chars: int = int(ad_cfg.get("min_content_chars", 50))
+
+    # Override session_store_path so is_available() works.
+    @property
+    def session_store_path(self):  # type: ignore[override]
+        return self.vault_paths
+
+    # #496: is_available() inherited from BaseAdapter — temp instance
+    # reads self.session_store_path (the @property above returning
+    # self.vault_paths). Was a duplicate scan over DEFAULT_VAULT_PATHS.
+
+    def discover_sessions(self) -> list[Path]:
+        """Walk every configured vault and return all .md files, excluding known
+        internal folders. Returns a sorted list."""
+        out: list[Path] = []
+        for vault in self.vault_paths:
+            vault = Path(vault).expanduser()
+            if not vault.exists():
+                continue
+            for md in vault.rglob("*.md"):
+                rel = md.relative_to(vault)
+                # Skip anything inside excluded folders
+                if any(part in self.exclude_folders for part in rel.parts):
+                    continue
+                # Skip empty or near-empty files
+                try:
+                    size = md.stat().st_size
+                except OSError:
+                    continue
+                if size < self.min_content_chars:
+                    continue
+                out.append(md)
+        return sorted(out)
+
+    def derive_project_slug(self, md_path: Path) -> str:
+        """Use the top-level folder under the vault as the project slug.
+        Files directly in the vault root get slug 'vault-root'."""
+        for vault in self.vault_paths:
+            vault = Path(vault).expanduser()
+            try:
+                rel = md_path.relative_to(vault)
+                if len(rel.parts) > 1:
+                    # Use the first directory as the project slug, lowercased
+                    return str(rel.parts[0]).lower().replace(" ", "-")
+                return "vault-root"
+            except ValueError:
+                continue
+        return md_path.parent.name
+
+    def is_subagent(self, md_path: Path) -> bool:
+        return False  # Obsidian notes are never subagents

sessionwiki/adapters/opencode.py

@@ -0,0 +1,169 @@
+"""OpenCode / OpenClaw adapter.
+
+OpenCode V2 stores sessions in a live SQLite database.  The sessionwiki
+exporter (``sessionwiki opencode export``) writes a Claude-style JSONL corpus
+under ``~/.llmwiki/opencode/<project-slug>/<session-id>.jsonl``; this
+adapter reads that corpus.  Legacy OpenCode/OpenClaw JSONL directories
+are still supported for existing installations.
+
+Session files are `*.jsonl` (one JSON object per line).  Exported records
+already use the Claude-style shape, so the default pass-through
+``normalize_records()`` is correct for them.  Legacy records with a
+top-level ``role`` / ``content`` are normalized on the fly.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from sessionwiki.adapters import register
+from sessionwiki.adapters.base import BaseAdapter
+
+
+@register("opencode")
+class OpenCodeAdapter(BaseAdapter):
+    """OpenCode / OpenClaw — shared adapter (both use identical schema)."""
+
+    SUPPORTED_SCHEMA_VERSIONS = ["v1"]
+
+    DEFAULT_ROOTS = [
+        # Primary: sessionwiki's OpenCode V2 export corpus
+        Path.home() / ".llmwiki" / "opencode",
+        # Legacy OpenCode / OpenClaw JSONL stores
+        # macOS
+        Path.home() / "Library" / "Application Support" / "opencode" / "sessions",
+        Path.home() / "Library" / "Application Support" / "openclaw" / "sessions",
+        # Linux (XDG default)
+        Path.home() / ".config" / "opencode" / "sessions",
+        Path.home() / ".config" / "openclaw" / "sessions",
+        # Windows
+        Path.home() / "AppData" / "Roaming" / "opencode" / "sessions",
+        Path.home() / "AppData" / "Roaming" / "openclaw" / "sessions",
+    ]
+
+    def __init__(self, config: dict[str, Any] | None = None):
+        super().__init__(config)
+        ad_cfg = (config or {}).get("adapters", {}).get("opencode", {})
+        paths = ad_cfg.get("roots") or []
+        self.roots: list[Path] = (
+            [Path(p).expanduser() for p in paths] if paths else self.DEFAULT_ROOTS
+        )
+
+    @property
+    def session_store_path(self):  # type: ignore[override]
+        return self.roots
+
+    @classmethod
+    def is_available(cls) -> bool:
+        """Available when at least one configured root contains a session."""
+        try:
+            instance = cls()
+        except Exception:
+            return False
+        roots = instance.session_store_path
+        if isinstance(roots, Path):
+            roots = [roots]
+        for root in roots:
+            path = Path(root).expanduser()
+            if path.exists() and any(path.rglob("*.jsonl")):
+                return True
+        return False
+
+    def discover_sessions(self) -> list[Path]:
+        """Return every .jsonl session file under every configured root."""
+        out: list[Path] = []
+        for root in self.roots:
+            root = Path(root).expanduser()
+            if not root.exists():
+                continue
+            out.extend(sorted(root.rglob("*.jsonl")))
+        return out
+
+    def derive_project_slug(self, jsonl_path: Path) -> str:
+        """OpenCode files are typically ``<project>-<session-id>.jsonl`` or
+        nested under ``<project>/<session-id>.jsonl``. Use parent dir if
+        nested, else split on first dash of filename."""
+        for root in self.roots:
+            root = Path(root).expanduser()
+            try:
+                rel = jsonl_path.relative_to(root)
+                # If nested: <project>/<session>.jsonl → project
+                if len(rel.parts) > 1:
+                    return rel.parts[0]
+                # Flat: <project>-<session>.jsonl → left-of-first-dash
+                stem = rel.stem
+                if "-" in stem:
+                    return stem.split("-", 1)[0]
+                return stem[:16]
+            except ValueError:
+                continue
+        return jsonl_path.parent.name
+
+    def is_subagent(self, jsonl_path: Path) -> bool:
+        """OpenCode marks subagent sessions with 'subagent' in the filename.
+
+        #arch-m1 (#614): match the segment, not the substring. The
+        previous `"subagent" in name` form would mis-classify a session
+        whose user-supplied slug happens to contain the literal text
+        "subagent" anywhere — same regression #406 fixed for the main
+        adapter contract.
+        """
+        # Hyphen-bounded match — accepts the subagent identifier whether
+        # it appears as a leading, trailing, or interior segment of a
+        # `-`-delimited filename.
+        import re
+        return bool(re.search(r"(?:^|[-/])subagent(?:[-.]|$)", jsonl_path.name))
+
+    def normalize_records(
+        self, records: list[dict[str, Any]]
+    ) -> list[dict[str, Any]]:
+        """Translate OpenCode/OpenClaw records into the shared Claude-style
+        shape that ``sessionwiki.convert.render_session_markdown`` expects.
+
+        OpenCode shape (approximate, based on public docs)::
+
+            {"role": "user",      "content": "string", "timestamp": "..."}
+            {"role": "assistant", "content": "string or [{type, text|tool_use}]"}
+            {"role": "tool",      "content": "tool result", "tool_call_id": "..."}
+
+        Claude Code shape::
+
+            {"type": "user",      "message": {"role": "user",      "content": "..."}}
+            {"type": "assistant", "message": {"role": "assistant", "content": [...]}}
+
+        Records already in Claude shape (have top-level ``type``) are
+        passed through unchanged.
+        """
+        out: list[dict[str, Any]] = []
+        for rec in records:
+            if not isinstance(rec, dict):
+                continue
+
+            # Pass-through if already Claude-shaped
+            if "type" in rec and "message" in rec:
+                out.append(rec)
+                continue
+
+            role = rec.get("role")
+            content = rec.get("content")
+            if role is None or content is None:
+                # Skip non-message records (metadata, session-init, etc.)
+                out.append(rec)
+                continue
+
+            # Map tool role → user (tool results are user-side in Claude shape)
+            claude_type = "user" if role in ("user", "tool", "system") else "assistant"
+
+            normalized = {
+                "type": claude_type,
+                "message": {"role": role, "content": content},
+            }
+            # Preserve timestamp if present — converter uses it for sorting
+            if "timestamp" in rec:
+                normalized["timestamp"] = rec["timestamp"]
+            if "sessionId" in rec:
+                normalized["sessionId"] = rec["sessionId"]
+
+            out.append(normalized)
+        return out

sessionwiki/adapters/status.py

@@ -0,0 +1,58 @@
+"""Adapter status computation — pulled out of cli.py (#arch-h8 / #611).
+
+Pre-#611 the ``configured``/``will_fire`` label computation lived as a
+private ``_adapter_status`` helper inside ``cli.py``. The CLI's job is
+to parse argv and print things — deciding whether an adapter is on /
+off / auto belongs in the adapters package next to the adapters
+themselves.
+
+The function is re-exported from ``sessionwiki.cli`` so the existing
+``from sessionwiki.cli import _adapter_status`` import path keeps working
+for any downstream caller that reached for it.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def adapter_status(
+    name: str,
+    adapter_cls: Any,
+    config: dict,
+) -> tuple[str, str]:
+    """Return ``(configured, will_fire)`` labels for one adapter (G-01 · #287).
+
+    * ``configured``: ``explicit`` (user set ``enabled: true`` in the
+      config), ``off`` (user set ``enabled: false``), or ``auto``
+      (default — no explicit toggle).
+    * ``will_fire``: ``yes`` when the next ``sync`` will pick this
+      adapter up (available **and** not explicitly off), ``no``
+      otherwise.
+
+    The old labels — ``-`` / ``enabled`` / ``disabled`` — read as
+    "adapter can't see anything" even when the adapter was discovering
+    471 files on the next line. The new labels say exactly what they
+    mean without the user cross-referencing ``sessions_config.json``.
+    """
+    adapter_cfg = config.get(name, {})
+    enabled_in_cfg = None
+    if isinstance(adapter_cfg, dict):
+        enabled_in_cfg = adapter_cfg.get("enabled", None)
+    if enabled_in_cfg is True:
+        configured = "explicit"
+    elif enabled_in_cfg is False:
+        configured = "off"
+    else:
+        configured = "auto"
+    available = adapter_cls.is_available()
+    # #326: non-AI adapters are opt-in only, so ``auto`` on an Obsidian /
+    # Jira / Meeting / PDF adapter means "available but won't fire".
+    is_ai = getattr(adapter_cls, "is_ai_session", True)
+    if configured == "off":
+        will_fire = "no"
+    elif configured == "explicit":
+        will_fire = "yes" if available else "no"
+    else:  # auto
+        will_fire = "yes" if (available and is_ai) else "no"
+    return configured, will_fire

sessionwiki/adapters/zcode.py

@@ -0,0 +1,45 @@
+"""ZCode session-store adapter.
+
+ZCode sessions are exported by ``scripts/zcode_export.py`` into a flat,
+Claude-style JSONL corpus:
+
+    ~/.llmwiki/zcode/<project-slug>/<session-id>.jsonl
+
+The exporter already applies the ZCode-specific filters (subagents,
+model-only messages, reasoning parts, tool collapsing), so this adapter
+only needs discovery, project-slug derivation, and availability checks.
+The default ``normalize_records`` pass-through is correct because the
+exporter writes the shared Claude-style record shape.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from sessionwiki.adapters import register
+from sessionwiki.adapters.base import BaseAdapter
+
+
+@register("zcode")
+class ZcodeAdapter(BaseAdapter):
+    """ZCode — reads ~/.llmwiki/zcode/<project>/*.jsonl"""
+
+    SUPPORTED_SCHEMA_VERSIONS = ["v1"]
+
+    session_store_path = Path.home() / ".llmwiki" / "zcode"
+
+    @classmethod
+    def is_available(cls) -> bool:
+        """Available when the export directory contains at least one session."""
+        try:
+            instance = cls()
+        except Exception:
+            return False
+        paths = instance.session_store_path
+        if isinstance(paths, Path):
+            paths = [paths]
+        for path in paths:
+            root = Path(path).expanduser()
+            if root.exists() and any(root.rglob("*.jsonl")):
+                return True
+        return False