fast-resume 1.12.8__py3-none-any.whl

fast_resume/adapters/copilot_vscode.py

@@ -0,0 +1,326 @@
+"""VS Code Copilot (copilot-vscode) session adapter."""
+
+import orjson
+import sys
+from datetime import datetime
+from pathlib import Path
+from urllib.parse import unquote, urlparse
+
+from ..config import AGENTS
+from ..logging_config import log_parse_error
+from .base import ErrorCallback, ParseError, RawAdapterStats, Session, truncate_title
+
+# VS Code storage paths vary by platform
+if sys.platform == "darwin":
+    VSCODE_STORAGE = Path.home() / "Library" / "Application Support" / "Code"
+elif sys.platform == "win32":
+    VSCODE_STORAGE = Path.home() / "AppData" / "Roaming" / "Code"
+else:  # Linux
+    VSCODE_STORAGE = Path.home() / ".config" / "Code"
+
+CHAT_SESSIONS_DIR = (
+    VSCODE_STORAGE / "User" / "globalStorage" / "emptyWindowChatSessions"
+)
+WORKSPACE_STORAGE_DIR = VSCODE_STORAGE / "User" / "workspaceStorage"
+
+
+class CopilotVSCodeAdapter:
+    """Adapter for VS Code Copilot Chat sessions."""
+
+    name = "copilot-vscode"
+    color = AGENTS["copilot-vscode"]["color"]
+    badge = AGENTS["copilot-vscode"]["badge"]
+
+    def __init__(
+        self,
+        chat_sessions_dir: Path | None = None,
+        workspace_storage_dir: Path | None = None,
+    ) -> None:
+        self._chat_sessions_dir = (
+            chat_sessions_dir if chat_sessions_dir is not None else CHAT_SESSIONS_DIR
+        )
+        self._workspace_storage_dir = (
+            workspace_storage_dir
+            if workspace_storage_dir is not None
+            else WORKSPACE_STORAGE_DIR
+        )
+
+    def is_available(self) -> bool:
+        """Check if VS Code Copilot Chat data exists."""
+        # Check empty window sessions
+        if self._chat_sessions_dir.exists() and any(
+            self._chat_sessions_dir.glob("*.json")
+        ):
+            return True
+        # Check workspace sessions
+        if self._workspace_storage_dir.exists():
+            for ws_dir in self._workspace_storage_dir.iterdir():
+                chat_dir = ws_dir / "chatSessions"
+                if chat_dir.exists() and any(chat_dir.glob("*.json")):
+                    return True
+        return False
+
+    def _get_session_id_from_file(self, session_file: Path) -> str | None:
+        """Extract session ID from session file, returns None on error."""
+        try:
+            with open(session_file, "rb") as f:
+                data = orjson.loads(f.read())
+            return data.get("sessionId", session_file.stem)
+        except Exception:
+            return None
+
+    def _get_workspace_directory(self, workspace_dir: Path) -> str:
+        """Get the workspace folder path from workspace.json."""
+        workspace_json = workspace_dir / "workspace.json"
+        if workspace_json.exists():
+            try:
+                with open(workspace_json, "rb") as f:
+                    data = orjson.loads(f.read())
+                folder = data.get("folder", "")
+                if folder.startswith("file://"):
+                    # Parse and decode the file URI
+                    parsed = urlparse(folder)
+                    return unquote(parsed.path)
+            except Exception:
+                pass
+        return ""
+
+    def _get_all_session_files(self) -> list[tuple[Path, str]]:
+        """Get all session files with their associated workspace directories.
+
+        Returns list of (session_file_path, workspace_directory).
+        """
+        session_files: list[tuple[Path, str]] = []
+
+        # Empty window sessions (no workspace directory)
+        if self._chat_sessions_dir.exists():
+            for session_file in self._chat_sessions_dir.glob("*.json"):
+                session_files.append((session_file, ""))
+
+        # Workspace-specific sessions
+        if self._workspace_storage_dir.exists():
+            for ws_dir in self._workspace_storage_dir.iterdir():
+                if not ws_dir.is_dir():
+                    continue
+                chat_dir = ws_dir / "chatSessions"
+                if chat_dir.exists():
+                    ws_directory = self._get_workspace_directory(ws_dir)
+                    for session_file in chat_dir.glob("*.json"):
+                        session_files.append((session_file, ws_directory))
+
+        return session_files
+
+    def find_sessions(self) -> list[Session]:
+        """Find all VS Code Copilot Chat sessions."""
+        if not self.is_available():
+            return []
+
+        sessions = []
+        for session_file, ws_directory in self._get_all_session_files():
+            session = self._parse_session(session_file, ws_directory)
+            if session:
+                sessions.append(session)
+
+        return sessions
+
+    def _parse_session(
+        self,
+        session_file: Path,
+        workspace_directory: str = "",
+        on_error: ErrorCallback = None,
+    ) -> Session | None:
+        """Parse a VS Code Copilot Chat session file."""
+        try:
+            with open(session_file, "rb") as f:
+                data = orjson.loads(f.read())
+
+            session_id = data.get("sessionId", session_file.stem)
+            title = data.get("customTitle", "")
+            requests = data.get("requests", [])
+
+            if not requests:
+                return None
+
+            # Extract messages
+            messages: list[str] = []
+            directory = workspace_directory  # Use workspace directory as default
+            turn_count = 0
+
+            for req in requests:
+                # User message
+                msg = req.get("message", {})
+                user_text = msg.get("text", "")
+                if user_text:
+                    messages.append(f"» {user_text}")
+                    turn_count += 1
+
+                # Try to extract directory from content references if not already set
+                if not directory:
+                    for ref in req.get("contentReferences", []):
+                        ref_data = ref.get("reference", {})
+                        uri = ref_data.get("uri", {})
+                        fs_path = uri.get("fsPath", "")
+                        if fs_path:
+                            # Get parent directory
+                            directory = str(Path(fs_path).parent)
+                            break
+
+                # Assistant response
+                response = req.get("response", [])
+                has_response = False
+                for resp_part in response:
+                    if isinstance(resp_part, dict):
+                        value = resp_part.get("value", "")
+                        if value:
+                            messages.append(f"  {value}")
+                            has_response = True
+                if has_response:
+                    turn_count += 1
+
+            if not messages:
+                return None
+
+            # Use first user message as title if no custom title
+            if not title and messages:
+                first_msg = messages[0].lstrip("» ").strip()
+                title = truncate_title(first_msg)
+
+            # Get timestamp from file or data
+            creation_date = data.get("creationDate")
+            last_message_date = data.get("lastMessageDate")
+            if last_message_date:
+                timestamp = datetime.fromtimestamp(last_message_date / 1000)
+            elif creation_date:
+                timestamp = datetime.fromtimestamp(creation_date / 1000)
+            else:
+                timestamp = datetime.fromtimestamp(session_file.stat().st_mtime)
+
+            full_content = "\n\n".join(messages)
+
+            return Session(
+                id=session_id,
+                agent=self.name,
+                title=title,
+                directory=directory,
+                timestamp=timestamp,
+                content=full_content,
+                message_count=turn_count,
+                mtime=session_file.stat().st_mtime,
+            )
+        except OSError as e:
+            error = ParseError(
+                agent=self.name,
+                file_path=str(session_file),
+                error_type="OSError",
+                message=str(e),
+            )
+            log_parse_error(
+                error.agent, error.file_path, error.error_type, error.message
+            )
+            if on_error:
+                on_error(error)
+            return None
+        except orjson.JSONDecodeError as e:
+            error = ParseError(
+                agent=self.name,
+                file_path=str(session_file),
+                error_type="JSONDecodeError",
+                message=str(e),
+            )
+            log_parse_error(
+                error.agent, error.file_path, error.error_type, error.message
+            )
+            if on_error:
+                on_error(error)
+            return None
+        except (KeyError, TypeError, AttributeError) as e:
+            error = ParseError(
+                agent=self.name,
+                file_path=str(session_file),
+                error_type=type(e).__name__,
+                message=str(e),
+            )
+            log_parse_error(
+                error.agent, error.file_path, error.error_type, error.message
+            )
+            if on_error:
+                on_error(error)
+            return None
+
+    def find_sessions_incremental(
+        self,
+        known: dict[str, tuple[float, str]],
+        on_error: ErrorCallback = None,
+    ) -> tuple[list[Session], list[str]]:
+        """Find sessions incrementally, comparing against known sessions."""
+        if not self.is_available():
+            deleted_ids = [
+                sid for sid, (_, agent) in known.items() if agent == self.name
+            ]
+            return [], deleted_ids
+
+        # Scan all session files and build current state
+        current_files: dict[str, tuple[Path, float, str]] = {}
+
+        for session_file, ws_directory in self._get_all_session_files():
+            session_id = self._get_session_id_from_file(session_file)
+            if session_id is None:
+                continue
+            mtime = session_file.stat().st_mtime
+            current_files[session_id] = (session_file, mtime, ws_directory)
+
+        # Find new and modified sessions
+        new_or_modified = []
+        for session_id, (path, mtime, ws_directory) in current_files.items():
+            known_entry = known.get(session_id)
+            if known_entry is None or mtime > known_entry[0] + 0.001:
+                session = self._parse_session(path, ws_directory, on_error=on_error)
+                if session:
+                    new_or_modified.append(session)
+
+        # Find deleted sessions
+        current_ids = set(current_files.keys())
+        deleted_ids = [
+            sid
+            for sid, (_, agent) in known.items()
+            if agent == self.name and sid not in current_ids
+        ]
+
+        return new_or_modified, deleted_ids
+
+    def get_resume_command(self, session: Session, yolo: bool = False) -> list[str]:
+        """Get command to open VS Code.
+
+        Note: VS Code Copilot Chat doesn't support resuming specific sessions
+        via command line. We open VS Code in the session's directory instead.
+        """
+        if session.directory:
+            return ["code", session.directory]
+        return ["code"]
+
+    def get_raw_stats(self) -> RawAdapterStats:
+        """Get raw statistics from VS Code Copilot data folders."""
+        if not self.is_available():
+            return RawAdapterStats(
+                agent=self.name,
+                data_dir=str(self._chat_sessions_dir),
+                available=False,
+                file_count=0,
+                total_bytes=0,
+            )
+
+        session_files = self._get_all_session_files()
+        total_bytes = 0
+        for path, _ in session_files:
+            try:
+                total_bytes += path.stat().st_size
+            except OSError:
+                pass
+
+        return RawAdapterStats(
+            agent=self.name,
+            data_dir=str(self._chat_sessions_dir),
+            available=True,
+            file_count=len(session_files),
+            total_bytes=total_bytes,
+        )

fast_resume/adapters/crush.py

@@ -0,0 +1,341 @@
+"""Crush (charmbracelet) session adapter."""
+
+import orjson
+import sqlite3
+from collections import defaultdict
+from datetime import datetime
+from pathlib import Path
+
+from ..config import AGENTS, CRUSH_PROJECTS_FILE
+from ..logging_config import log_parse_error
+from .base import ErrorCallback, ParseError, RawAdapterStats, Session, truncate_title
+
+
+class CrushAdapter:
+    """Adapter for Crush sessions."""
+
+    name = "crush"
+    color = AGENTS["crush"]["color"]
+    badge = AGENTS["crush"]["badge"]
+
+    def __init__(self, projects_file: Path | None = None) -> None:
+        self._projects_file = (
+            projects_file if projects_file is not None else CRUSH_PROJECTS_FILE
+        )
+
+    def is_available(self) -> bool:
+        """Check if Crush projects file exists."""
+        return self._projects_file.exists()
+
+    def find_sessions(self) -> list[Session]:
+        """Find all Crush sessions across all projects."""
+        if not self.is_available():
+            return []
+
+        sessions = []
+
+        try:
+            with open(self._projects_file, "rb") as f:
+                projects_data = orjson.loads(f.read())
+        except (orjson.JSONDecodeError, OSError):
+            return []
+
+        for project in projects_data.get("projects", []):
+            project_path = project.get("path", "")
+            data_dir = project.get("data_dir", "")
+
+            if not data_dir:
+                continue
+
+            db_path = Path(data_dir) / "crush.db"
+            if not db_path.exists():
+                continue
+
+            project_sessions = self._load_sessions_from_db(db_path, project_path)
+            sessions.extend(project_sessions)
+
+        return sessions
+
+    def _load_sessions_from_db(
+        self, db_path: Path, project_path: str, on_error: ErrorCallback = None
+    ) -> list[Session]:
+        """Load sessions from a Crush SQLite database."""
+        sessions = []
+
+        try:
+            conn = sqlite3.connect(str(db_path), timeout=5)
+            conn.row_factory = sqlite3.Row
+            cursor = conn.cursor()
+
+            cursor.execute("""
+                SELECT
+                    s.id, s.title, s.message_count, s.updated_at, s.created_at,
+                    m.role, m.parts, m.created_at as msg_created_at
+                FROM sessions s
+                LEFT JOIN messages m ON m.session_id = s.id
+                WHERE s.message_count > 0
+                ORDER BY s.updated_at DESC, m.created_at ASC
+            """)
+
+            # Group messages by session
+            session_data: dict[str, dict] = {}
+            session_messages: dict[str, list[tuple[str, str]]] = defaultdict(list)
+
+            for row in cursor.fetchall():
+                session_id = row["id"]
+
+                # Store session metadata (first occurrence)
+                if session_id not in session_data:
+                    session_data[session_id] = {
+                        "title": row["title"] or "",
+                        "updated_at": row["updated_at"],
+                        "created_at": row["created_at"],
+                    }
+
+                # Collect messages
+                if row["role"] is not None:
+                    session_messages[session_id].append((row["role"], row["parts"]))
+
+            conn.close()
+
+            # Build Session objects
+            for session_id, data in session_data.items():
+                session = self._build_session(
+                    session_id,
+                    data,
+                    session_messages[session_id],
+                    project_path,
+                    on_error=on_error,
+                )
+                if session:
+                    sessions.append(session)
+
+        except sqlite3.Error as e:
+            error = ParseError(
+                agent=self.name,
+                file_path=str(db_path),
+                error_type="sqlite3.Error",
+                message=str(e),
+            )
+            log_parse_error(
+                error.agent, error.file_path, error.error_type, error.message
+            )
+            if on_error:
+                on_error(error)
+
+        return sessions
+
+    def _build_session(
+        self,
+        session_id: str,
+        data: dict,
+        messages_raw: list[tuple[str, str]],
+        project_path: str,
+        on_error: ErrorCallback = None,
+    ) -> Session | None:
+        """Build a Session object from pre-fetched data."""
+        try:
+            title = data["title"]
+            updated_at = data["updated_at"]
+            created_at = data["created_at"]
+
+            # Detect if timestamp is in milliseconds (> year 3000 in seconds)
+            if updated_at > 100_000_000_000:
+                updated_at = updated_at / 1000
+            if created_at > 100_000_000_000:
+                created_at = created_at / 1000
+
+            timestamp = datetime.fromtimestamp(updated_at)
+
+            messages: list[str] = []
+            first_user_message = ""
+
+            for role, parts_json in messages_raw:
+                text_content = self._extract_text_from_parts(parts_json)
+                if not text_content:
+                    continue
+
+                role_prefix = "» " if role == "user" else "  "
+                messages.append(f"{role_prefix}{text_content}")
+
+                if role == "user" and not first_user_message and len(text_content) > 5:
+                    first_user_message = text_content
+
+            # Skip sessions with no actual content
+            if not messages or not first_user_message:
+                return None
+
+            # Use first user message as title if none set
+            if not title:
+                title = truncate_title(first_user_message)
+
+            full_content = "\n\n".join(messages)
+
+            return Session(
+                id=session_id,
+                agent=self.name,
+                title=title,
+                directory=project_path,
+                timestamp=timestamp,
+                content=full_content,
+                message_count=len(messages),
+            )
+        except (KeyError, TypeError, AttributeError, ValueError) as e:
+            error = ParseError(
+                agent=self.name,
+                file_path=f"crush_db:{session_id}",
+                error_type=type(e).__name__,
+                message=str(e),
+            )
+            log_parse_error(
+                error.agent, error.file_path, error.error_type, error.message
+            )
+            if on_error:
+                on_error(error)
+            return None
+
+    def _extract_text_from_parts(self, parts_json: str) -> str:
+        """Extract text content from message parts JSON."""
+        try:
+            parts = orjson.loads(parts_json)
+        except orjson.JSONDecodeError:
+            return ""
+
+        text_parts = []
+        for part in parts:
+            if not isinstance(part, dict):
+                continue
+
+            part_type = part.get("type", "")
+            data = part.get("data", {})
+
+            if part_type == "text" and isinstance(data, dict):
+                text = data.get("text", "")
+                if text:
+                    text_parts.append(text)
+            elif part_type == "tool_result" and isinstance(data, dict):
+                # Include tool results for context
+                content = data.get("content", "")
+                if content and len(content) < 500:  # Skip long tool outputs
+                    text_parts.append(f"[{data.get('name', 'tool')}]: {content[:200]}")
+            elif part_type == "tool_call" and isinstance(data, dict):
+                # Include tool calls for context
+                name = data.get("name", "")
+                if name:
+                    text_parts.append(f"[calling {name}]")
+
+        return " ".join(text_parts)
+
+    def find_sessions_incremental(
+        self,
+        known: dict[str, tuple[float, str]],
+        on_error: ErrorCallback = None,
+    ) -> tuple[list[Session], list[str]]:
+        """Find sessions incrementally, comparing against known sessions."""
+        if not self.is_available():
+            deleted_ids = [
+                sid for sid, (_, agent) in known.items() if agent == self.name
+            ]
+            return [], deleted_ids
+
+        try:
+            with open(self._projects_file, "rb") as f:
+                projects_data = orjson.loads(f.read())
+        except (orjson.JSONDecodeError, OSError):
+            deleted_ids = [
+                sid for sid, (_, agent) in known.items() if agent == self.name
+            ]
+            return [], deleted_ids
+
+        # For Crush, we track db file mtimes and session IDs within
+        # When a db changes, we reload all sessions from it and diff
+        new_or_modified = []
+        all_current_ids: set[str] = set()
+
+        for project in projects_data.get("projects", []):
+            project_path = project.get("path", "")
+            data_dir = project.get("data_dir", "")
+
+            if not data_dir:
+                continue
+
+            db_path = Path(data_dir) / "crush.db"
+            if not db_path.exists():
+                continue
+
+            # Load all sessions from this db
+            project_sessions = self._load_sessions_from_db(
+                db_path, project_path, on_error=on_error
+            )
+
+            for session in project_sessions:
+                all_current_ids.add(session.id)
+                known_entry = known.get(session.id)
+                # Use session timestamp for comparison since db doesn't have file mtime
+                # Use 1ms tolerance for comparison due to datetime precision loss
+                session_mtime = session.timestamp.timestamp()
+                if known_entry is None or session_mtime > known_entry[0] + 0.001:
+                    session.mtime = session_mtime
+                    new_or_modified.append(session)
+
+        # Find deleted sessions
+        deleted_ids = [
+            sid
+            for sid, (_, agent) in known.items()
+            if agent == self.name and sid not in all_current_ids
+        ]
+
+        return new_or_modified, deleted_ids
+
+    def get_resume_command(self, session: Session, yolo: bool = False) -> list[str]:
+        """Get command to resume a Crush session."""
+        # Crush is interactive - it shows a session picker when launched in a project directory
+        # fast-resume changes to session.directory before executing this command
+        return ["crush"]
+
+    def get_raw_stats(self) -> RawAdapterStats:
+        """Get raw statistics from Crush database files."""
+        if not self.is_available():
+            return RawAdapterStats(
+                agent=self.name,
+                data_dir=str(self._projects_file.parent),
+                available=False,
+                file_count=0,
+                total_bytes=0,
+            )
+
+        try:
+            with open(self._projects_file, "rb") as f:
+                projects_data = orjson.loads(f.read())
+        except (orjson.JSONDecodeError, OSError):
+            return RawAdapterStats(
+                agent=self.name,
+                data_dir=str(self._projects_file.parent),
+                available=True,
+                file_count=0,
+                total_bytes=0,
+            )
+
+        file_count = 0
+        total_bytes = 0
+
+        for project in projects_data.get("projects", []):
+            data_dir = project.get("data_dir", "")
+            if not data_dir:
+                continue
+
+            db_path = Path(data_dir) / "crush.db"
+            if db_path.exists():
+                try:
+                    file_count += 1
+                    total_bytes += db_path.stat().st_size
+                except OSError:
+                    pass
+
+        return RawAdapterStats(
+            agent=self.name,
+            data_dir=str(self._projects_file.parent),
+            available=True,
+            file_count=file_count,
+            total_bytes=total_bytes,
+        )