copilot-session-tools 0.1.1__py3-none-any.whl

copilot_session_tools/scanner/discovery.py

@@ -0,0 +1,365 @@
+"""Session file discovery, scanning, and parsing dispatch."""
+
+import os
+import platform
+from collections.abc import Iterator
+from pathlib import Path
+from urllib.parse import unquote
+
+import orjson
+
+from .cli import _parse_cli_jsonl_file
+from .models import ChatSession, SessionFileInfo
+from .vscode import _parse_chat_session_file, _parse_vscdb_file, _parse_vscode_jsonl_file
+
+
+def get_vscode_storage_paths() -> list[tuple[str, str]]:
+    """Get the paths to VS Code workspace storage directories.
+
+    Returns a list of tuples: (path, edition) where edition is 'stable' or 'insider'.
+    """
+    system = platform.system()
+
+    paths = []
+
+    if system == "Windows":
+        appdata = os.environ.get("APPDATA", "")
+        if appdata:
+            # VS Code Stable
+            stable_path = Path(appdata) / "Code" / "User" / "workspaceStorage"
+            paths.append((str(stable_path), "stable"))
+            # VS Code Insiders
+            insider_path = Path(appdata) / "Code - Insiders" / "User" / "workspaceStorage"
+            paths.append((str(insider_path), "insider"))
+    elif system == "Darwin":  # macOS
+        home = Path.home()
+        # VS Code Stable
+        stable_path = home / "Library" / "Application Support" / "Code" / "User" / "workspaceStorage"
+        paths.append((str(stable_path), "stable"))
+        # VS Code Insiders
+        insider_path = home / "Library" / "Application Support" / "Code - Insiders" / "User" / "workspaceStorage"
+        paths.append((str(insider_path), "insider"))
+    else:  # Linux and others
+        home = Path.home()
+        # VS Code Stable
+        stable_path = home / ".config" / "Code" / "User" / "workspaceStorage"
+        paths.append((str(stable_path), "stable"))
+        # VS Code Insiders
+        insider_path = home / ".config" / "Code - Insiders" / "User" / "workspaceStorage"
+        paths.append((str(insider_path), "insider"))
+
+    return paths
+
+
+def find_copilot_chat_dirs(
+    storage_paths: list[tuple[str, str]] | None = None,
+) -> Iterator[tuple[Path, str, str]]:
+    """Find directories containing Copilot chat sessions.
+
+    Args:
+        storage_paths: Optional list of (path, edition) tuples to search.
+                       If None, uses default VS Code storage paths.
+
+    Yields:
+        Tuples of (chat_dir_path, workspace_id, edition)
+    """
+    if storage_paths is None:
+        storage_paths = get_vscode_storage_paths()
+
+    for storage_path, edition in storage_paths:
+        storage_dir = Path(storage_path)
+        if not storage_dir.exists():
+            continue
+
+        # Each subdirectory is a workspace
+        for workspace_dir in storage_dir.iterdir():
+            if not workspace_dir.is_dir():
+                continue
+
+            workspace_id = workspace_dir.name
+
+            # Look for Copilot chat sessions - they may be in different locations
+            # depending on the VS Code and Copilot extension versions
+
+            # Check for github.copilot-chat extension storage
+            copilot_chat_dir = workspace_dir / "state.vscdb.backup"  # Some versions use this
+            if copilot_chat_dir.exists():
+                yield copilot_chat_dir.parent, workspace_id, edition
+
+            # Check for chatSessions directory (newer format)
+            chat_sessions_dir = workspace_dir / "chatSessions"
+            if chat_sessions_dir.exists() and chat_sessions_dir.is_dir():
+                yield chat_sessions_dir, workspace_id, edition
+
+            # Check for workspaceState file
+            workspace_state = workspace_dir / "workspace.json"
+            if workspace_state.exists():
+                yield workspace_dir, workspace_id, edition
+
+
+def _parse_workspace_json(workspace_dir: Path) -> tuple[str | None, str | None]:
+    """Parse workspace.json to get workspace name and path."""
+    workspace_json = workspace_dir / "workspace.json"
+    if workspace_json.exists():
+        try:
+            with workspace_json.open("rb") as f:
+                data = orjson.loads(f.read())
+                folder = data.get("folder", "")
+                # folder is often a URI like file:///path/to/workspace
+                if folder.startswith("file://"):
+                    folder = folder[7:]
+                    if platform.system() == "Windows" and folder.startswith("/"):
+                        # Windows paths like /C:/path
+                        folder = folder[1:]
+                # URL decode the path (e.g., %3A -> :, %20 -> space)
+                folder = unquote(folder) if folder else ""
+                workspace_name = Path(folder).name if folder else None
+                return workspace_name, folder if folder else None
+        except (orjson.JSONDecodeError, OSError):
+            pass
+    return None, None
+
+
+def get_cli_storage_paths() -> list[Path]:
+    """Get the paths to GitHub Copilot CLI session storage directories.
+
+    Returns a list of Path objects for CLI session directories.
+    """
+    home = Path.home()
+    copilot_dir = home / ".copilot"
+
+    paths = []
+
+    # Current format (v0.0.342+)
+    session_state_dir = copilot_dir / "session-state"
+    if session_state_dir.exists():
+        paths.append(session_state_dir)
+
+    # Legacy format (pre-v0.0.342)
+    history_state_dir = copilot_dir / "history-session-state"
+    if history_state_dir.exists():
+        paths.append(history_state_dir)
+
+    return paths
+
+
+def scan_chat_sessions(
+    storage_paths: list[tuple[str, str]] | None = None,
+    include_cli: bool = True,
+) -> Iterator[ChatSession]:
+    """Scan for and parse all Copilot chat sessions.
+
+    Args:
+        storage_paths: Optional list of (path, edition) tuples to search for VS Code sessions.
+        include_cli: Whether to also scan for CLI sessions (default: True).
+
+    Yields:
+        ChatSession objects for each found session.
+    """
+    # Scan VS Code chat sessions
+    for chat_dir, _workspace_id, edition in find_copilot_chat_dirs(storage_paths):
+        # Get workspace info
+        workspace_name, workspace_path = _parse_workspace_json(chat_dir.parent)
+
+        # Process JSON files in the directory
+        for item in chat_dir.iterdir():
+            if item.is_file():
+                if item.suffix == ".json":
+                    session = _parse_chat_session_file(item, workspace_name, workspace_path, edition)
+                    if session:
+                        yield session
+                elif item.suffix == ".jsonl":
+                    session = _parse_vscode_jsonl_file(item, workspace_name, workspace_path, edition)
+                    if session:
+                        yield session
+                elif item.suffix == ".vscdb":
+                    # Parse SQLite database files
+                    sessions = _parse_vscdb_file(item, workspace_name, workspace_path, edition)
+                    for session in sessions:
+                        yield session
+
+        # Also check for state.vscdb in parent directory
+        state_db = chat_dir.parent / "state.vscdb"
+        if state_db.exists():
+            sessions = _parse_vscdb_file(state_db, workspace_name, workspace_path, edition)
+            for session in sessions:
+                yield session
+
+    # Scan CLI chat sessions
+    if include_cli:
+        for cli_dir in get_cli_storage_paths():
+            if not cli_dir.exists() or not cli_dir.is_dir():
+                continue
+
+            # Process CLI storage directory - supports two formats:
+            # 1. Old format: {session-id}.jsonl files directly in the directory
+            # 2. New format: {session-id}/events.jsonl subdirectories
+            for item in cli_dir.iterdir():
+                if item.is_file() and item.suffix == ".jsonl":
+                    # Old format: flat JSONL files
+                    session = _parse_cli_jsonl_file(item)
+                    if session:
+                        yield session
+                elif item.is_dir():
+                    # New format: subdirectory with events.jsonl
+                    events_file = item / "events.jsonl"
+                    if events_file.exists():
+                        session = _parse_cli_jsonl_file(events_file)
+                        if session:
+                            yield session
+
+
+def scan_session_files(
+    storage_paths: list[tuple[str, str]] | None = None,
+    include_cli: bool = True,
+) -> Iterator[SessionFileInfo]:
+    """Scan for session files and yield metadata without parsing content.
+
+    This allows callers to check mtime/size before expensive parsing.
+    Use parse_session_file() to parse a specific file.
+
+    Args:
+        storage_paths: Optional list of (path, edition) tuples to search for VS Code sessions.
+        include_cli: Whether to also scan for CLI sessions (default: True).
+
+    Yields:
+        SessionFileInfo objects with file metadata.
+    """
+    # Scan VS Code chat session files
+    for chat_dir, _workspace_id, edition in find_copilot_chat_dirs(storage_paths):
+        workspace_name, workspace_path = _parse_workspace_json(chat_dir.parent)
+
+        # Process files in the chat directory
+        for item in chat_dir.iterdir():
+            if item.is_file():
+                try:
+                    stat = item.stat()
+                    if item.suffix == ".json":
+                        yield SessionFileInfo(
+                            file_path=item,
+                            file_type="json",
+                            session_type="vscode",
+                            vscode_edition=edition,
+                            mtime=stat.st_mtime,
+                            size=stat.st_size,
+                            workspace_name=workspace_name,
+                            workspace_path=workspace_path,
+                        )
+                    elif item.suffix == ".jsonl":
+                        yield SessionFileInfo(
+                            file_path=item,
+                            file_type="jsonl",
+                            session_type="vscode",
+                            vscode_edition=edition,
+                            mtime=stat.st_mtime,
+                            size=stat.st_size,
+                            workspace_name=workspace_name,
+                            workspace_path=workspace_path,
+                        )
+                    elif item.suffix == ".vscdb":
+                        yield SessionFileInfo(
+                            file_path=item,
+                            file_type="vscdb",
+                            session_type="vscode",
+                            vscode_edition=edition,
+                            mtime=stat.st_mtime,
+                            size=stat.st_size,
+                            workspace_name=workspace_name,
+                            workspace_path=workspace_path,
+                        )
+                except OSError:
+                    continue
+
+        # Check for state.vscdb in parent directory
+        state_db = chat_dir.parent / "state.vscdb"
+        if state_db.exists():
+            try:
+                stat = state_db.stat()
+                yield SessionFileInfo(
+                    file_path=state_db,
+                    file_type="vscdb",
+                    session_type="vscode",
+                    vscode_edition=edition,
+                    mtime=stat.st_mtime,
+                    size=stat.st_size,
+                    workspace_name=workspace_name,
+                    workspace_path=workspace_path,
+                )
+            except OSError:
+                pass
+
+    # Scan CLI session files
+    if include_cli:
+        for cli_dir in get_cli_storage_paths():
+            if not cli_dir.exists() or not cli_dir.is_dir():
+                continue
+
+            for item in cli_dir.iterdir():
+                try:
+                    if item.is_file() and item.suffix == ".jsonl":
+                        stat = item.stat()
+                        yield SessionFileInfo(
+                            file_path=item,
+                            file_type="jsonl",
+                            session_type="cli",
+                            vscode_edition="cli",
+                            mtime=stat.st_mtime,
+                            size=stat.st_size,
+                        )
+                    elif item.is_dir():
+                        events_file = item / "events.jsonl"
+                        if events_file.exists():
+                            stat = events_file.stat()
+                            yield SessionFileInfo(
+                                file_path=events_file,
+                                file_type="jsonl",
+                                session_type="cli",
+                                vscode_edition="cli",
+                                mtime=stat.st_mtime,
+                                size=stat.st_size,
+                            )
+                except OSError:
+                    continue
+
+
+def parse_session_file(file_info: SessionFileInfo) -> list[ChatSession]:
+    """Parse a session file and return ChatSession objects.
+
+    Args:
+        file_info: SessionFileInfo from scan_session_files().
+
+    Returns:
+        List of ChatSession objects (may be multiple for vscdb files).
+    """
+    if file_info.file_type == "json":
+        session = _parse_chat_session_file(
+            file_info.file_path,
+            file_info.workspace_name,
+            file_info.workspace_path,
+            file_info.vscode_edition,
+        )
+        return [session] if session else []
+
+    elif file_info.file_type == "vscdb":
+        return list(
+            _parse_vscdb_file(
+                file_info.file_path,
+                file_info.workspace_name,
+                file_info.workspace_path,
+                file_info.vscode_edition,
+            )
+        )
+
+    elif file_info.file_type == "jsonl":
+        if file_info.session_type == "vscode":
+            session = _parse_vscode_jsonl_file(
+                file_info.file_path,
+                file_info.workspace_name,
+                file_info.workspace_path,
+                file_info.vscode_edition,
+            )
+        else:
+            session = _parse_cli_jsonl_file(file_info.file_path)
+        return [session] if session else []
+
+    return []

copilot_session_tools/scanner/git.py

@@ -0,0 +1,114 @@
+"""Git repository URL detection and normalization."""
+
+import re
+import subprocess
+from pathlib import Path
+
+# Cache for detect_repository_url to avoid repeated subprocess calls
+_repository_url_cache: dict[str, str | None] = {}
+
+
+def _clear_repository_url_cache() -> None:
+    """Clear the repository URL cache (for testing)."""
+    _repository_url_cache.clear()
+
+
+def detect_repository_url(workspace_path: str | None) -> str | None:
+    """Detect the git repository URL from a workspace path.
+
+    Results are cached to avoid repeated subprocess calls for the same workspace.
+
+    This function looks for a .git directory and reads the remote origin URL.
+    This enables repository-scoped memories that work across multiple worktrees
+    of the same repository.
+
+    Args:
+        workspace_path: Path to the workspace directory.
+
+    Returns:
+        The normalized repository URL (e.g., "github.com/owner/repo"), or None
+        if no git repository is found or no remote is configured.
+    """
+    if not workspace_path:
+        return None
+
+    # Check cache first
+    if workspace_path in _repository_url_cache:
+        return _repository_url_cache[workspace_path]
+
+    workspace = Path(workspace_path)
+    result_url: str | None = None
+
+    # Check if this is a git repository (handles both regular repos and worktrees)
+    try:
+        # Use git rev-parse to find the actual git directory
+        # This works for both regular repos and worktrees
+        result = subprocess.run(
+            ["git", "rev-parse", "--git-dir"],  # noqa: S607 - trusted git command
+            cwd=str(workspace),
+            capture_output=True,
+            text=True,
+            timeout=5,
+            check=False,
+        )
+        if result.returncode == 0:
+            # Get the remote origin URL
+            result = subprocess.run(
+                ["git", "config", "--get", "remote.origin.url"],  # noqa: S607 - trusted git command
+                cwd=str(workspace),
+                capture_output=True,
+                text=True,
+                timeout=5,
+                check=False,
+            )
+            if result.returncode == 0:
+                remote_url = result.stdout.strip()
+                if remote_url:
+                    result_url = _normalize_git_url(remote_url)
+
+    except (subprocess.TimeoutExpired, FileNotFoundError, OSError):
+        pass
+
+    # Cache the result (including None)
+    _repository_url_cache[workspace_path] = result_url
+    return result_url
+
+
+def _normalize_git_url(url: str) -> str:
+    """Normalize a git remote URL to a consistent format.
+
+    Converts various URL formats to a normalized form:
+    - https://github.com/owner/repo.git -> github.com/owner/repo
+    - git@github.com:owner/repo.git -> github.com/owner/repo
+    - ssh://git@github.com/owner/repo.git -> github.com/owner/repo
+
+    Args:
+        url: The raw git remote URL.
+
+    Returns:
+        Normalized URL string in format "host/owner/repo".
+    """
+    # Remove trailing .git
+    url = url.rstrip("/")
+    url = url.removesuffix(".git")
+
+    # Handle SSH format: git@github.com:owner/repo
+    ssh_match = re.match(r"^git@([^:]+):(.+)$", url)
+    if ssh_match:
+        host, path = ssh_match.groups()
+        return f"{host}/{path}"
+
+    # Handle SSH URL format: ssh://git@github.com/owner/repo
+    ssh_url_match = re.match(r"^ssh://(?:git@)?([^/]+)/(.+)$", url)
+    if ssh_url_match:
+        host, path = ssh_url_match.groups()
+        return f"{host}/{path}"
+
+    # Handle HTTPS format: https://github.com/owner/repo
+    https_match = re.match(r"^https?://([^/]+)/(.+)$", url)
+    if https_match:
+        host, path = https_match.groups()
+        return f"{host}/{path}"
+
+    # Return as-is if we can't parse it
+    return url

copilot_session_tools/scanner/models.py

@@ -0,0 +1,122 @@
+"""Data models for Copilot chat session scanning."""
+
+from dataclasses import dataclass, field
+from pathlib import Path
+
+
+@dataclass
+class ToolInvocation:
+    """Represents a tool invocation in a chat response.
+
+    Based on ChatToolInvocation from Arbuzov/copilot-chat-history.
+    """
+
+    name: str
+    input: str | None = None
+    result: str | None = None
+    status: str | None = None
+    start_time: int | None = None
+    end_time: int | None = None
+    source_type: str | None = None  # 'mcp' or 'internal'
+    invocation_message: str | None = None  # Pretty display message (e.g., "Reading file.txt, lines 1 to 100")
+
+
+@dataclass
+class FileChange:
+    """Represents a file change in a chat response.
+
+    Based on ChatFileChange from Arbuzov/copilot-chat-history.
+    """
+
+    path: str
+    diff: str | None = None
+    content: str | None = None
+    explanation: str | None = None
+    language_id: str | None = None
+
+
+@dataclass
+class CommandRun:
+    """Represents a command execution in a chat response.
+
+    Based on ChatCommandRun from Arbuzov/copilot-chat-history.
+    """
+
+    command: str
+    title: str | None = None
+    result: str | None = None
+    status: str | None = None
+    output: str | None = None
+    timestamp: int | None = None
+
+
+@dataclass
+class ContentBlock:
+    """Represents a content block in an assistant response.
+
+    Each block has a kind (e.g., 'text', 'thinking', 'tool') and content.
+    This allows differentiation between thinking/reasoning and regular output.
+    """
+
+    kind: str  # 'text', 'thinking', 'tool', 'promptFile', etc.
+    content: str
+    description: str | None = None  # Optional description (e.g., generatedTitle for thinking blocks)
+
+
+@dataclass
+class ChatMessage:
+    """Represents a single message in a chat session.
+
+    Enhanced based on ChatMessage/ChatResponseItem from Arbuzov/copilot-chat-history.
+    """
+
+    role: str  # 'user' or 'assistant'
+    content: str
+    timestamp: str | None = None
+    tool_invocations: list[ToolInvocation] = field(default_factory=list)
+    file_changes: list[FileChange] = field(default_factory=list)
+    command_runs: list[CommandRun] = field(default_factory=list)
+    content_blocks: list[ContentBlock] = field(default_factory=list)  # Structured content with kind
+    cached_markdown: str | None = None  # Pre-computed markdown for this message
+
+
+@dataclass
+class ChatSession:
+    """Represents a Copilot chat session.
+
+    Based on ChatSession/ChatSessionData from Arbuzov/copilot-chat-history.
+    """
+
+    session_id: str
+    workspace_name: str | None
+    workspace_path: str | None
+    messages: list[ChatMessage]
+    created_at: str | None = None
+    updated_at: str | None = None
+    source_file: str | None = None
+    vscode_edition: str = "stable"  # 'stable' or 'insider'
+    custom_title: str | None = None
+    requester_username: str | None = None
+    responder_username: str | None = None
+    source_file_mtime: float | None = None  # File modification time for incremental refresh
+    source_file_size: int | None = None  # File size in bytes for incremental refresh
+    type: str = "vscode"  # 'vscode' or 'cli'
+    raw_json: bytes | None = None  # Original raw JSON bytes from source file
+    repository_url: str | None = None  # Git remote URL for repository-scoped memories
+
+
+@dataclass
+class SessionFileInfo:
+    """Lightweight metadata about a session file for incremental scanning.
+
+    This allows checking mtime/size before expensive parsing.
+    """
+
+    file_path: Path
+    file_type: str  # 'json', 'vscdb', 'jsonl'
+    session_type: str  # 'vscode' or 'cli'
+    vscode_edition: str  # 'stable', 'insider', or 'cli'
+    mtime: float
+    size: int
+    workspace_name: str | None = None
+    workspace_path: str | None = None