thread-archive 0.0.2__py3-none-any.whl

thread_archive/_thread_import/exporters/__init__.py

@@ -0,0 +1,9 @@
+"""
+Exporters for extracting chat data from various IDE/tool storage formats.
+"""
+
+from .cursor import CursorExporter
+
+__all__ = [
+    "CursorExporter",
+]

thread_archive/_thread_import/exporters/_cursor_kv_mixin.py

@@ -0,0 +1,166 @@
+"""SQLite / cursorDiskKV reading methods for ``CursorExporter``.
+
+A mixin of the database-reading and KV→conversation-building methods, lifted out
+of ``CursorExporter`` so the class file stays focused. ``_read_sqlite_db`` and
+``_read_cursor_disk_kv`` open a SQLite file passed in by path; the rest transform
+the resulting composer/bubble dicts into conversation structures, delegating the
+per-message shape work to ``cursor_parse``. None read ``self.storage_path``.
+
+The methods stay methods (not free functions) so callers that access them as
+class/instance attributes — including tests that build a bare exporter with
+``__new__`` and the ``export_all`` orchestrator that stubs ``_read_cursor_disk_kv``
+and ``_build_conversations_from_kv`` on the instance — keep resolving to the same
+objects via the assembled class's MRO. Moved byte-for-byte from ``cursor.py``.
+"""
+
+import json
+import logging
+import sqlite3
+from pathlib import Path
+from typing import Any, Dict, List, Tuple
+
+from . import cursor_parse
+
+logger = logging.getLogger(__name__)
+
+
+class CursorKVMixin:
+    """SQLite key-value reading + KV→conversation building methods."""
+
+    def _read_sqlite_db(self, db_path: Path) -> Dict[str, Any]:
+        """Read key-value pairs from a Cursor SQLite database."""
+        data = {}
+
+        try:
+            conn = sqlite3.connect(str(db_path))
+            cursor = conn.cursor()
+
+            cursor.execute("SELECT name FROM sqlite_master WHERE type='table'")
+            tables = [row[0] for row in cursor.fetchall()]
+
+            if "ItemTable" in tables:
+                cursor.execute("SELECT key, value FROM ItemTable")
+                for key, value in cursor.fetchall():
+                    if value and isinstance(value, str):
+                        try:
+                            if value.strip().startswith(("{", "[")):
+                                data[key] = json.loads(value)
+                            else:
+                                data[key] = value
+                        except json.JSONDecodeError:
+                            data[key] = value
+                    else:
+                        data[key] = value
+
+            conn.close()
+        except sqlite3.Error:
+            pass
+        except Exception:
+            logger.warning("Failed to read SQLite database at %s", db_path, exc_info=True)
+
+        return data
+
+    def _read_cursor_disk_kv(self, db_path: Path) -> Tuple[Dict[str, Any], Dict[str, Any]]:
+        """
+        Read conversation data from Cursor's cursorDiskKV table.
+
+        Returns:
+            Tuple of (composers, bubbles)
+        """
+        composers = {}
+        bubbles = {}
+
+        try:
+            conn = sqlite3.connect(str(db_path))
+            cursor = conn.cursor()
+
+            cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='cursorDiskKV'")
+            if not cursor.fetchone():
+                conn.close()
+                return composers, bubbles
+
+            cursor.execute("SELECT key, value FROM cursorDiskKV WHERE key LIKE 'composerData:%'")
+            for key, value in cursor.fetchall():
+                try:
+                    composer_id = key.replace("composerData:", "")
+                    data = json.loads(value)
+                    composers[composer_id] = data
+                except (json.JSONDecodeError, Exception):
+                    pass
+
+            cursor.execute("SELECT key, value FROM cursorDiskKV WHERE key LIKE 'bubbleId:%'")
+            for key, value in cursor.fetchall():
+                try:
+                    parts = key.split(":")
+                    if len(parts) >= 3:
+                        bubble_id = parts[2]
+                        composer_id = parts[1]
+                        data = json.loads(value)
+                        data["_composerId"] = composer_id
+                        bubbles[f"{composer_id}:{bubble_id}"] = data
+                except (json.JSONDecodeError, Exception):
+                    pass
+
+            conn.close()
+
+        except sqlite3.Error:
+            pass
+        except Exception:
+            logger.warning("Failed to read cursorDiskKV from %s", db_path, exc_info=True)
+
+        return composers, bubbles
+
+    def _build_conversations_from_kv(
+        self,
+        composers: Dict[str, Any],
+        bubbles: Dict[str, Any]
+    ) -> List[Dict[str, Any]]:
+        """Build conversation structures from composer and bubble data."""
+        conversations = []
+
+        for composer_id, composer in composers.items():
+            headers = composer.get("fullConversationHeadersOnly", [])
+            if not headers:
+                continue
+
+            messages = []
+            for idx, header in enumerate(headers):
+                bubble_id = header.get("bubbleId")
+                if not bubble_id:
+                    continue
+
+                bubble = bubbles.get(f"{composer_id}:{bubble_id}", {})
+                messages.append(
+                    self._build_kv_message(bubble_id, bubble, header, idx)
+                )
+
+            conversations.append({
+                "id": composer_id,
+                "title": composer.get("name", "Untitled"),
+                "created_at": composer.get("createdAt"),
+                "updated_at": composer.get("lastUpdatedAt"),
+                "messages": messages,
+                "metadata": self._build_kv_metadata(composer),
+            })
+
+        return conversations
+
+    @staticmethod
+    def _kv_role(bubble: Dict[str, Any], header: Dict[str, Any]) -> str:
+        """Map a Cursor bubble/header ``type`` (1/2) onto a canonical role."""
+        return cursor_parse.kv_role(bubble, header)
+
+    @staticmethod
+    def _build_kv_message(
+        bubble_id: str,
+        bubble: Dict[str, Any],
+        header: Dict[str, Any],
+        idx: int,
+    ) -> Dict[str, Any]:
+        """Build one conversation message from a composer header + its bubble."""
+        return cursor_parse.build_kv_message(bubble_id, bubble, header, idx)
+
+    @staticmethod
+    def _build_kv_metadata(composer: Dict[str, Any]) -> Dict[str, Any]:
+        """Extract the conversation metadata block from a composer record."""
+        return cursor_parse.build_kv_metadata(composer)

thread_archive/_thread_import/exporters/_cursor_parse_mixin.py

@@ -0,0 +1,149 @@
+"""Composer/chat-blob parsing methods for ``CursorExporter``.
+
+A mixin of the stateless ``_parse_*`` / ``_normalize_role`` /
+``_content_blocks_from_content`` / ``_extract_chat_data`` methods, lifted out of
+``CursorExporter`` so the class file stays focused. These read no instance state
+(no ``self.storage_path``) — they transform loose composer/chat blobs into
+conversation dicts, delegating the per-message shape work to ``cursor_parse``.
+
+The methods stay methods (not free functions) so callers that access them as
+class/instance attributes — including tests that build a bare exporter with
+``__new__`` and the ``export_all`` orchestrator that stubs them on the instance —
+keep resolving to the same objects via the assembled class's MRO. Moved
+byte-for-byte from ``cursor.py``.
+"""
+
+import re
+from typing import Any, Dict, List, Optional
+
+from . import cursor_parse
+
+
+class CursorParseMixin:
+    """Stateless composer/chat-blob → conversation parsing methods."""
+
+    def _extract_chat_data(self, db_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Extract chat-related data from the database dump."""
+        chat_data = {}
+
+        chat_patterns = [
+            r".*chat.*",
+            r".*composer.*",
+            r".*conversation.*",
+            r".*aiContext.*",
+            r".*ai\..*",
+            r".*cursor\..*",
+            r".*workbench\.panel\.aichat.*",
+            r".*workbench\.panel\.chat.*",
+        ]
+
+        for key, value in db_data.items():
+            key_lower = key.lower()
+            for pattern in chat_patterns:
+                if re.match(pattern, key_lower, re.IGNORECASE):
+                    chat_data[key] = value
+                    break
+
+        return chat_data
+
+    def _parse_composer_data(self, data: Any) -> List[Dict[str, Any]]:
+        """Parse Cursor's composer/chat data into conversations."""
+        if not data:
+            return []
+
+        if isinstance(data, dict):
+            return self._parse_composer_dict(data)
+
+        if isinstance(data, list):
+            return self._parse_conversation_items(data)
+
+        return []
+
+    def _parse_composer_dict(self, data: Dict[str, Any]) -> List[Dict[str, Any]]:
+        """Parse a dict-shaped composer blob: keyed conversation collections,
+        falling back to treating the dict itself as a single conversation."""
+        conversations: List[Dict[str, Any]] = []
+
+        for key in ["tabs", "conversations", "chats", "composerData", "allTabs"]:
+            if key in data:
+                conversations.extend(self._parse_keyed_collection(data[key]))
+
+        if not conversations and ("messages" in data or "bubbles" in data or "conversation" in data):
+            conv = self._parse_single_conversation(data)
+            if conv:
+                conversations.append(conv)
+
+        return conversations
+
+    def _parse_keyed_collection(self, items: Any) -> List[Dict[str, Any]]:
+        """Parse one keyed collection (list of conversations or id->conversation
+        dict) into a list of conversations."""
+        if isinstance(items, list):
+            return self._parse_conversation_items(items)
+        if isinstance(items, dict):
+            conversations: List[Dict[str, Any]] = []
+            for conv_id, item in items.items():
+                conv = self._parse_single_conversation(item, conv_id)
+                if conv:
+                    conversations.append(conv)
+            return conversations
+        return []
+
+    def _parse_conversation_items(self, items: List[Any]) -> List[Dict[str, Any]]:
+        """Parse a plain list of conversation/tab structures, dropping any that
+        don't yield a conversation."""
+        conversations: List[Dict[str, Any]] = []
+        for item in items:
+            conv = self._parse_single_conversation(item)
+            if conv:
+                conversations.append(conv)
+        return conversations
+
+    def _parse_single_conversation(self, data: Any, conv_id: Optional[str] = None) -> Optional[Dict[str, Any]]:
+        """Parse a single conversation/tab structure."""
+        if not isinstance(data, dict):
+            return None
+
+        conversation = {
+            "id": conv_id or data.get("id") or data.get("tabId") or data.get("conversationId"),
+            "title": data.get("title") or data.get("name") or "Untitled",
+            "created_at": data.get("createdAt") or data.get("created_at") or data.get("timestamp"),
+            "updated_at": data.get("updatedAt") or data.get("updated_at"),
+            "messages": [],
+            "raw_data": data,
+        }
+
+        messages = []
+        for msg_key in ["messages", "bubbles", "conversation", "chatMessages", "chat_messages"]:
+            if msg_key in data:
+                msg_data = data[msg_key]
+                if isinstance(msg_data, list):
+                    messages = msg_data
+                    break
+                elif isinstance(msg_data, dict) and "messages" in msg_data:
+                    messages = msg_data["messages"]
+                    break
+
+        for i, msg in enumerate(messages):
+            parsed_msg = self._parse_message(msg, i)
+            if parsed_msg:
+                conversation["messages"].append(parsed_msg)
+
+        if conversation["messages"] or conversation["id"]:
+            return conversation
+
+        return None
+
+    def _parse_message(self, msg: Any, index: int = 0) -> Optional[Dict[str, Any]]:
+        """Parse a single message from Cursor's format."""
+        return cursor_parse.parse_message(msg, index)
+
+    @staticmethod
+    def _normalize_role(msg: Dict[str, Any]) -> Optional[str]:
+        """Map Cursor's role/type/sender aliases onto canonical role names."""
+        return cursor_parse.normalize_role(msg)
+
+    @staticmethod
+    def _content_blocks_from_content(raw_content: Any) -> List[Dict[str, Any]]:
+        """Build text content blocks from a message's raw ``content`` field."""
+        return cursor_parse.content_blocks_from_content(raw_content)