Agent platform adapters

# src/lerim/adapters/base.py:58-84
class Adapter(Protocol):
    """Platform adapter protocol for discovering and loading sessions."""

    def default_path(self) -> Path | None:
        """Return the default traces directory for this platform."""

    def count_sessions(self, path: Path) -> int:
        """Return total session count under ``path``."""

    def iter_sessions(
        self,
        traces_dir: Path | None = None,
        start: datetime | None = None,
        end: datetime | None = None,
        known_run_hashes: dict[str, str] | None = None,
    ) -> list[SessionRecord]:
        """List normalized session summaries in the selected time window."""

    def find_session_path(
        self, session_id: str, traces_dir: Path | None = None
    ) -> Path | None:
        """Resolve one session file path by ``session_id``."""

    def read_session(
        self, session_path: Path, session_id: str | None = None
    ) -> ViewerSession | None:
        """Read one session file and return a normalized viewer payload."""

# src/lerim/adapters/base.py:38-55
@dataclass(frozen=True)
class SessionRecord:
    """Summary record used for indexing and session listings."""

    run_id: str
    agent_type: str
    session_path: str
    start_time: str | None = None
    repo_path: str | None = None
    repo_name: str | None = None
    status: str = "completed"
    duration_ms: int = 0
    message_count: int = 0
    tool_call_count: int = 0
    error_count: int = 0
    total_tokens: int = 0
    summaries: list[str] = field(default_factory=list)
    content_hash: str | None = None

# src/lerim/adapters/base.py:25-35
@dataclass
class ViewerSession:
    """Normalized session payload returned by platform adapters."""

    session_id: str
    cwd: str | None = None
    git_branch: str | None = None
    messages: list[ViewerMessage] = field(default_factory=list)
    total_input_tokens: int = 0
    total_output_tokens: int = 0
    meta: dict[str, Any] = field(default_factory=dict)

# src/lerim/adapters/claude.py:19-21
def default_path() -> Path | None:
    """Return the default Claude traces directory."""
    return Path("~/.claude/projects/").expanduser()

# src/lerim/adapters/cursor.py:38-46
def default_path() -> Path | None:
    """Return platform-specific default Cursor storage path."""
    if sys.platform == "darwin":
        return Path(
            "~/Library/Application Support/Cursor/User/globalStorage/"
        ).expanduser()
    if sys.platform.startswith("linux"):
        return Path("~/.config/Cursor/User/globalStorage/").expanduser()
    # ... fallback ...

# src/lerim/adapters/cursor.py:240-252
for cid, bubble_list in bubbles.items():
    metadata = composers.get(cid, {})
    started_at = parse_timestamp(metadata.get("createdAt"))
    if not in_window(started_at, start, end):
        continue

    # Export JSONL: metadata first line, then bubbles
    jsonl_path = out_dir / f"{cid}.jsonl"
    with jsonl_path.open("w", encoding="utf-8") as fh:
        fh.write(json.dumps(metadata) + "\n")
        for bubble in bubble_list:
            fh.write(json.dumps(bubble) + "\n")

# Example: Claude adapter iter_sessions
# src/lerim/adapters/claude.py:153-242
def iter_sessions(
    traces_dir: Path | None = None,
    start: datetime | None = None,
    end: datetime | None = None,
    known_run_hashes: dict[str, str] | None = None,
) -> list[SessionRecord]:
    """Enumerate Claude sessions, skipping those whose content hash is unchanged."""
    base = traces_dir or default_path()
    if base is None or not base.exists():
        return []

    records: list[SessionRecord] = []
    for path in base.rglob("*.jsonl"):
        run_id = path.stem
        file_hash = compute_file_hash(path)
        
        # Skip if hash matches known session
        if known_run_hashes and run_id in known_run_hashes:
            if known_run_hashes[run_id] == file_hash:
                continue

        # ... parse session metadata ...
        
        records.append(
            SessionRecord(
                run_id=run_id,
                agent_type="claude",
                session_path=str(path),
                # ... metadata fields ...
                content_hash=file_hash,
            )
        )

    records.sort(key=lambda r: r.start_time or "")
    return records

# Cursor export logic
jsonl_path = out_dir / f"{cid}.jsonl"
with jsonl_path.open("w", encoding="utf-8") as fh:
    fh.write(json.dumps(metadata) + "\n")  # First line: session metadata
    for bubble in bubble_list:
        fh.write(json.dumps(bubble) + "\n")  # Subsequent lines: messages

# src/lerim/adapters/registry.py:12-17
_ADAPTER_MODULES: dict[str, str] = {
    "claude": "lerim.adapters.claude",
    "codex": "lerim.adapters.codex",
    "opencode": "lerim.adapters.opencode",
    "cursor": "lerim.adapters.cursor",
}

# src/lerim/adapters/registry.py:24-29
def get_adapter(name: str):
    """Return adapter module for a known platform name."""
    module_path = _ADAPTER_MODULES.get(name)
    if not module_path:
        return None
    return importlib.import_module(module_path)

# Auto-detect and connect all supported platforms
lerim connect auto

# Connect specific platform
lerim connect cursor

# Custom path override
lerim connect cursor --path ~/my-cursor-data/globalStorage

{
  "platforms": {
    "claude": {
      "path": "/Users/alice/.claude/projects",
      "connected_at": "2026-03-01T14:30:00Z"
    },
    "cursor": {
      "path": "/Users/alice/Library/Application Support/Cursor/User/globalStorage",
      "connected_at": "2026-03-01T14:30:05Z"
    }
  }
}

from pathlib import Path
from datetime import datetime
from lerim.adapters.base import SessionRecord, ViewerSession, ViewerMessage

def default_path() -> Path | None:
    """Return the default session storage path for YourPlatform."""
    return Path("~/.yourplatform/sessions/").expanduser()

def count_sessions(path: Path) -> int:
    """Count sessions under path."""
    return len(list(path.rglob("*.json")))

def iter_sessions(
    traces_dir: Path | None = None,
    start: datetime | None = None,
    end: datetime | None = None,
    known_run_hashes: dict[str, str] | None = None,
) -> list[SessionRecord]:
    """Discover and normalize sessions."""
    # ... implementation ...

def find_session_path(session_id: str, traces_dir: Path | None = None) -> Path | None:
    """Find session file by ID."""
    # ... implementation ...

def read_session(
    session_path: Path, session_id: str | None = None
) -> ViewerSession | None:
    """Read and normalize one session."""
    # ... implementation ...

_ADAPTER_MODULES: dict[str, str] = {
    "claude": "lerim.adapters.claude",
    "codex": "lerim.adapters.codex",
    "opencode": "lerim.adapters.opencode",
    "cursor": "lerim.adapters.cursor",
    "yourplatform": "lerim.adapters.yourplatform",  # Add this
}

lerim connect yourplatform