claude-self-reflect 2.3.6 → 2.3.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-self-reflect",
-  "version": "2.3.6",
+  "version": "2.3.7",
   "description": "Give Claude perfect memory of all your conversations - Installation wizard for Python MCP server",
   "keywords": [
     "claude",

package/scripts/import-conversations-isolated.py

@@ -1,311 +0,0 @@
-#!/usr/bin/env python3
-"""
-Import Claude conversation logs with project isolation support.
-Each project gets its own collection for complete isolation.
-"""
-
-import json
-import os
-import glob
-import hashlib
-from datetime import datetime, timedelta
-from typing import List, Dict, Any, Set
-import logging
-from qdrant_client import QdrantClient
-from qdrant_client.models import (
-    VectorParams, Distance, PointStruct,
-    Filter, FieldCondition, MatchValue
-)
-from sentence_transformers import SentenceTransformer
-
-# Configuration
-QDRANT_URL = os.getenv("QDRANT_URL", "http://localhost:6333")
-LOGS_DIR = os.getenv("LOGS_DIR", "/logs")
-STATE_FILE = os.getenv("STATE_FILE", "/config/imported-files.json")
-EMBEDDING_MODEL = os.getenv("EMBEDDING_MODEL", "sentence-transformers/all-MiniLM-L6-v2")
-BATCH_SIZE = int(os.getenv("BATCH_SIZE", "100"))
-ISOLATION_MODE = os.getenv("ISOLATION_MODE", "isolated")  # isolated, shared, hybrid
-
-# Set up logging
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
-logger = logging.getLogger(__name__)
-
-class ProjectAwareImporter:
-    def __init__(self):
-        """Initialize the importer with Qdrant client and embedding model."""
-        self.client = QdrantClient(url=QDRANT_URL)
-        self.encoder = SentenceTransformer(EMBEDDING_MODEL)
-        self.imported_files = self.load_state()
-        self.project_collections: Set[str] = set()
-        
-    def load_state(self) -> Dict[str, Set[str]]:
-        """Load the set of already imported files per project."""
-        if os.path.exists(STATE_FILE):
-            try:
-                with open(STATE_FILE, 'r') as f:
-                    data = json.load(f)
-                    # Convert to per-project tracking
-                    if isinstance(data.get('files'), list):
-                        # Legacy format - convert to new format
-                        return {'_legacy': set(data['files'])}
-                    else:
-                        # New format with per-project tracking
-                        return {k: set(v) for k, v in data.get('projects', {}).items()}
-            except Exception as e:
-                logger.error(f"Failed to load state: {e}")
-        return {}
-    
-    def save_state(self):
-        """Save the set of imported files per project."""
-        os.makedirs(os.path.dirname(STATE_FILE), exist_ok=True)
-        with open(STATE_FILE, 'w') as f:
-            json.dump({
-                'projects': {k: list(v) for k, v in self.imported_files.items()},
-                'last_updated': datetime.now().isoformat(),
-                'mode': ISOLATION_MODE
-            }, f, indent=2)
-    
-    def get_collection_name(self, project_name: str) -> str:
-        """Get collection name based on isolation mode."""
-        if ISOLATION_MODE == "isolated":
-            # Create project-specific collection name
-            project_hash = hashlib.md5(project_name.encode()).hexdigest()[:8]
-            return f"conv_{project_hash}"
-        else:
-            # Shared collection mode
-            return "conversations"
-    
-    def setup_collection(self, project_name: str):
-        """Create or update the Qdrant collection for a project."""
-        collection_name = self.get_collection_name(project_name)
-        
-        # Skip if already set up in this session
-        if collection_name in self.project_collections:
-            return collection_name
-        
-        collections = self.client.get_collections().collections
-        exists = any(c.name == collection_name for c in collections)
-        
-        if not exists:
-            logger.info(f"Creating collection: {collection_name} for project: {project_name}")
-            self.client.create_collection(
-                collection_name=collection_name,
-                vectors_config=VectorParams(
-                    size=384,  # all-MiniLM-L6-v2 dimension
-                    distance=Distance.COSINE
-                )
-            )
-        else:
-            logger.info(f"Collection {collection_name} already exists for project: {project_name}")
-        
-        self.project_collections.add(collection_name)
-        return collection_name
-    
-    def extract_project_name(self, file_path: str) -> str:
-        """Extract project name from file path."""
-        # Expected path: /logs/<project-name>/<conversation-id>.jsonl
-        parts = file_path.split('/')
-        if len(parts) >= 3 and parts[-2] != 'logs':
-            return parts[-2]
-        return 'unknown'
-    
-    def process_jsonl_file(self, file_path: str) -> List[Dict[str, Any]]:
-        """Extract messages from a JSONL file."""
-        messages = []
-        
-        try:
-            with open(file_path, 'r') as f:
-                for line_num, line in enumerate(f, 1):
-                    try:
-                        data = json.loads(line.strip())
-                        
-                        # Extract message if present
-                        if 'message' in data and data['message']:
-                            msg = data['message']
-                            if 'role' in msg and 'content' in msg:
-                                # Handle content that might be an object
-                                content = msg['content']
-                                if isinstance(content, dict):
-                                    content = content.get('text', json.dumps(content))
-                                
-                                # Create message document
-                                messages.append({
-                                    'role': msg['role'],
-                                    'content': content,
-                                    'file_path': file_path,
-                                    'line_number': line_num,
-                                    'timestamp': data.get('timestamp', datetime.now().isoformat())
-                                })
-                    except json.JSONDecodeError:
-                        logger.warning(f"Failed to parse line {line_num} in {file_path}")
-                    except Exception as e:
-                        logger.error(f"Error processing line {line_num} in {file_path}: {e}")
-                        
-        except Exception as e:
-            logger.error(f"Failed to read file {file_path}: {e}")
-        
-        return messages
-    
-    def create_conversation_chunks(self, messages: List[Dict[str, Any]], chunk_size: int = 5) -> List[Dict[str, Any]]:
-        """Group messages into conversation chunks for better context."""
-        chunks = []
-        
-        for i in range(0, len(messages), chunk_size):
-            chunk_messages = messages[i:i + chunk_size]
-            
-            # Create a conversation summary
-            conversation_text = "\n\n".join([
-                f"{msg['role'].upper()}: {msg['content'][:500]}..."
-                if len(msg['content']) > 500 else f"{msg['role'].upper()}: {msg['content']}"
-                for msg in chunk_messages
-            ])
-            
-            # Extract metadata
-            project_id = self.extract_project_name(chunk_messages[0]['file_path'])
-            conversation_id = os.path.basename(chunk_messages[0]['file_path']).replace('.jsonl', '')
-            
-            chunks.append({
-                'id': hashlib.md5(f"{chunk_messages[0]['file_path']}_{i}".encode()).hexdigest(),
-                'text': conversation_text,
-                'metadata': {
-                    'project_id': project_id,
-                    'project_name': project_id,  # Add both for compatibility
-                    'conversation_id': conversation_id,
-                    'chunk_index': i // chunk_size,
-                    'message_count': len(chunk_messages),
-                    'start_role': chunk_messages[0]['role'],
-                    'timestamp': chunk_messages[0]['timestamp'],
-                    'file_path': chunk_messages[0]['file_path']
-                }
-            })
-        
-        return chunks
-    
-    def import_to_qdrant(self, chunks: List[Dict[str, Any]], collection_name: str):
-        """Import conversation chunks to a specific Qdrant collection."""
-        if not chunks:
-            return
-        
-        # Generate embeddings
-        texts = [chunk['text'] for chunk in chunks]
-        embeddings = self.encoder.encode(texts, show_progress_bar=True)
-        
-        # Create points for Qdrant
-        points = []
-        for i, (chunk, embedding) in enumerate(zip(chunks, embeddings)):
-            points.append(
-                PointStruct(
-                    id=chunk['id'],
-                    vector=embedding.tolist(),
-                    payload={
-                        'text': chunk['text'],
-                        **chunk['metadata']
-                    }
-                )
-            )
-        
-        # Upload to Qdrant in batches
-        for i in range(0, len(points), BATCH_SIZE):
-            batch = points[i:i + BATCH_SIZE]
-            self.client.upsert(
-                collection_name=collection_name,
-                points=batch
-            )
-            logger.info(f"Uploaded batch of {len(batch)} points to {collection_name}")
-    
-    def find_recent_files(self, days: int = 30) -> List[str]:
-        """Find JSONL files modified in the last N days."""
-        cutoff_time = datetime.now() - timedelta(days=days)
-        pattern = os.path.join(LOGS_DIR, "**", "*.jsonl")
-        
-        recent_files = []
-        for file_path in glob.glob(pattern, recursive=True):
-            try:
-                mtime = os.path.getmtime(file_path)
-                if datetime.fromtimestamp(mtime) >= cutoff_time:
-                    recent_files.append(file_path)
-            except Exception as e:
-                logger.error(f"Error checking file {file_path}: {e}")
-        
-        return recent_files
-    
-    def run(self):
-        """Main import process with project isolation."""
-        logger.info(f"Starting conversation import to Qdrant (mode: {ISOLATION_MODE})")
-        
-        # Find files to import
-        all_files = self.find_recent_files()
-        logger.info(f"Found {len(all_files)} total files")
-        
-        # Group files by project
-        files_by_project: Dict[str, List[str]] = {}
-        for file_path in all_files:
-            project_name = self.extract_project_name(file_path)
-            if project_name not in files_by_project:
-                files_by_project[project_name] = []
-            files_by_project[project_name].append(file_path)
-        
-        logger.info(f"Found {len(files_by_project)} projects to process")
-        
-        total_chunks = 0
-        for project_name, project_files in files_by_project.items():
-            logger.info(f"\nProcessing project: {project_name}")
-            
-            # Get imported files for this project
-            project_imported = self.imported_files.get(project_name, set())
-            new_files = [f for f in project_files if f not in project_imported]
-            
-            if not new_files:
-                logger.info(f"No new files for project {project_name}")
-                continue
-            
-            logger.info(f"Found {len(new_files)} new files for project {project_name}")
-            
-            # Setup collection for this project
-            collection_name = self.setup_collection(project_name)
-            
-            project_chunks = 0
-            for file_path in new_files:
-                logger.info(f"Processing: {file_path}")
-                
-                # Extract messages
-                messages = self.process_jsonl_file(file_path)
-                if not messages:
-                    logger.warning(f"No messages found in {file_path}")
-                    continue
-                
-                # Create conversation chunks
-                chunks = self.create_conversation_chunks(messages)
-                
-                # Import to project-specific collection
-                self.import_to_qdrant(chunks, collection_name)
-                
-                # Mark file as imported for this project
-                if project_name not in self.imported_files:
-                    self.imported_files[project_name] = set()
-                self.imported_files[project_name].add(file_path)
-                self.save_state()
-                
-                project_chunks += len(chunks)
-                logger.info(f"Imported {len(chunks)} chunks from {file_path}")
-            
-            total_chunks += project_chunks
-            logger.info(f"Project {project_name} complete: {project_chunks} chunks imported")
-        
-        logger.info(f"\nImport complete: {total_chunks} total chunks imported")
-        
-        # Show collection summary
-        logger.info("\nCollection summary:")
-        collections = self.client.get_collections().collections
-        for collection in collections:
-            if collection.name.startswith('conv_') or collection.name == 'conversations':
-                count = self.client.get_collection(collection.name).points_count
-                logger.info(f"  {collection.name}: {count} points")
-
-def main():
-    """Entry point for the importer."""
-    importer = ProjectAwareImporter()
-    importer.run()
-
-if __name__ == "__main__":
-    main()

package/scripts/import-conversations-voyage-streaming.py

@@ -1,368 +0,0 @@
-#!/usr/bin/env python3
-"""
-Streaming import for large Claude conversation logs.
-Processes files in chunks without loading entire file into memory.
-"""
-
-import json
-import os
-import sys
-import time
-import hashlib
-from datetime import datetime
-from typing import List, Dict, Any, Generator
-import logging
-import backoff
-import requests
-from qdrant_client import QdrantClient
-from qdrant_client.models import VectorParams, Distance, PointStruct
-from pathlib import Path
-
-# Set up logging
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
-logger = logging.getLogger(__name__)
-
-# Configuration
-QDRANT_URL = os.getenv("QDRANT_URL", "http://localhost:6333")
-STATE_FILE = os.getenv("STATE_FILE", "./config-isolated/imported-files.json")
-LOGS_DIR = os.getenv("LOGS_DIR", os.path.expanduser("~/.claude/projects"))
-VOYAGE_API_KEY = os.getenv("VOYAGE_KEY_2") or os.getenv("VOYAGE_KEY")
-BATCH_SIZE = int(os.getenv("BATCH_SIZE", "50"))
-CHUNK_SIZE = int(os.getenv("CHUNK_SIZE", "10"))
-STREAMING_BUFFER_SIZE = 100  # Process every 100 messages
-RATE_LIMIT_DELAY = 0.1
-EMBEDDING_MODEL = "voyage-3-large"
-EMBEDDING_DIMENSIONS = 1024
-VOYAGE_API_URL = "https://api.voyageai.com/v1/embeddings"
-
-class StreamingVoyageImporter:
-    def __init__(self):
-        """Initialize the streaming importer."""
-        if not VOYAGE_API_KEY:
-            raise ValueError("VOYAGE_KEY environment variable not set")
-            
-        self.qdrant_client = QdrantClient(url=QDRANT_URL)
-        self.state = self._load_state()
-        self.total_imported = 0
-        self.total_errors = 0
-        
-        logger.info(f"Connected to Qdrant at {QDRANT_URL}")
-        
-    def _load_state(self) -> Dict[str, Any]:
-        """Load import state from file."""
-        default_state = {
-            "projects": {},
-            "last_updated": None,
-            "mode": "isolated",
-            "total_imported": 0
-        }
-        
-        if os.path.exists(STATE_FILE):
-            try:
-                with open(STATE_FILE, 'r') as f:
-                    return json.load(f)
-            except Exception as e:
-                logger.error(f"Failed to load state: {e}")
-        
-        return default_state
-    
-    def _save_state(self):
-        """Save import state to file."""
-        self.state["last_updated"] = datetime.now().isoformat()
-        self.state["total_imported"] = self.total_imported
-        
-        os.makedirs(os.path.dirname(STATE_FILE), exist_ok=True)
-        with open(STATE_FILE, 'w') as f:
-            json.dump(self.state, f, indent=2)
-    
-    @backoff.on_exception(
-        backoff.expo,
-        Exception,
-        max_tries=5,
-        on_backoff=lambda details: logger.warning(f"Backing off {details['wait']}s after {details['tries']} tries")
-    )
-    def _generate_embeddings(self, texts: List[str]) -> List[List[float]]:
-        """Generate embeddings using Voyage AI API with batching."""
-        headers = {
-            "Authorization": f"Bearer {VOYAGE_API_KEY}",
-            "Content-Type": "application/json"
-        }
-        
-        payload = {
-            "input": texts,
-            "model": EMBEDDING_MODEL,
-            "input_type": "document"
-        }
-        
-        try:
-            response = requests.post(VOYAGE_API_URL, headers=headers, json=payload, timeout=30)
-            response.raise_for_status()
-            
-            data = response.json()
-            embeddings = [item["embedding"] for item in data["data"]]
-            
-            # Add small delay to respect rate limits
-            time.sleep(RATE_LIMIT_DELAY)
-            
-            return embeddings
-            
-        except requests.Timeout:
-            logger.error("Voyage API request timed out after 30 seconds")
-            raise
-        except Exception as e:
-            logger.error(f"Voyage API error: {e}")
-            raise
-    
-    def stream_jsonl_messages(self, file_path: str, buffer_size: int = STREAMING_BUFFER_SIZE) -> Generator[List[Dict[str, Any]], None, None]:
-        """Stream messages from JSONL file in buffers without loading entire file."""
-        buffer = []
-        line_count = 0
-        total_lines = 0
-        skipped_lines = 0
-        
-        # Extract expected session ID from filename
-        expected_session_id = os.path.splitext(os.path.basename(file_path))[0]
-        logger.info(f"Starting to stream file: {os.path.basename(file_path)} (expecting session: {expected_session_id})")
-        
-        try:
-            with open(file_path, 'r', encoding='utf-8') as f:
-                for line_num, line in enumerate(f, 1):
-                    total_lines = line_num
-                    line = line.strip()
-                    if not line:
-                        continue
-                    
-                    try:
-                        data = json.loads(line)
-                        
-                        # Check session ID matches expected
-                        session_id = data.get('sessionId', '')
-                        if session_id != expected_session_id:
-                            skipped_lines += 1
-                            logger.debug(f"Skipping line {line_num}: different session ID ({session_id})")
-                            continue
-                        
-                        # Extract message if present
-                        if 'message' in data and data['message']:
-                            msg = data['message']
-                            if msg.get('role') and msg.get('content'):
-                                content = msg['content']
-                                # Handle content array (common in Claude messages)
-                                if isinstance(content, list) and len(content) > 0:
-                                    # Extract text from first content item
-                                    content_item = content[0]
-                                    if isinstance(content_item, dict):
-                                        content = content_item.get('text', str(content_item))
-                                elif isinstance(content, dict):
-                                    content = content.get('text', json.dumps(content))
-                                
-                                buffer.append({
-                                    'role': msg['role'],
-                                    'content': content,
-                                    'file_path': file_path,
-                                    'line_number': line_num,
-                                    'timestamp': data.get('timestamp', datetime.now().isoformat())
-                                })
-                                line_count += 1
-                                
-                                # Yield buffer when it reaches the specified size
-                                if len(buffer) >= buffer_size:
-                                    logger.info(f"Buffer full, yielding {len(buffer)} messages (total so far: {line_count})")
-                                    yield buffer
-                                    buffer = []
-                                    
-                    except json.JSONDecodeError:
-                        logger.debug(f"Skipping invalid JSON at line {line_num}")
-                        skipped_lines += 1
-                    except Exception as e:
-                        logger.error(f"Error processing line {line_num}: {e}")
-                        skipped_lines += 1
-                
-                # Yield any remaining messages
-                if buffer:
-                    logger.info(f"Yielding final buffer with {len(buffer)} messages")
-                    yield buffer
-                
-                logger.info(f"Completed streaming file: processed {total_lines} lines, {line_count} messages, {skipped_lines} skipped")
-                    
-        except Exception as e:
-            logger.error(f"Failed to read file {file_path}: {e}")
-    
-    def process_message_buffer(self, messages: List[Dict[str, Any]], project_name: str, collection_name: str, conversation_id: str):
-        """Process a buffer of messages into chunks and import them."""
-        chunks = []
-        
-        # Create chunks from message buffer
-        for i in range(0, len(messages), CHUNK_SIZE):
-            chunk_messages = messages[i:i + CHUNK_SIZE]
-            
-            # Create conversation text
-            conversation_text = "\n\n".join([
-                f"{msg['role'].upper()}: {msg['content'][:500]}"
-                for msg in chunk_messages
-            ])
-            
-            # Add metadata
-            timestamps = [msg['timestamp'] for msg in chunk_messages]
-            first_timestamp = min(timestamps) if timestamps else datetime.now().isoformat()
-            
-            chunk_id = hashlib.md5(
-                f"{conversation_id}_{first_timestamp}_{len(chunks)}".encode()
-            ).hexdigest()
-            
-            chunks.append({
-                'id': chunk_id,
-                'text': conversation_text,
-                'metadata': {
-                    'project': project_name,
-                    'conversation_id': conversation_id,
-                    'timestamp': first_timestamp,
-                    'chunk_index': len(chunks),
-                    'message_count': len(chunk_messages),
-                    'roles': list(set(msg['role'] for msg in chunk_messages))
-                }
-            })
-        
-        # Import chunks if we have any
-        if chunks:
-            self._import_chunks_to_qdrant(chunks, collection_name)
-    
-    def _import_chunks_to_qdrant(self, chunks: List[Dict[str, Any]], collection_name: str):
-        """Import conversation chunks to Qdrant."""
-        if not chunks:
-            return
-        
-        # Process in batches
-        for i in range(0, len(chunks), BATCH_SIZE):
-            batch = chunks[i:i + BATCH_SIZE]
-            texts = [chunk['text'] for chunk in batch]
-            
-            try:
-                # Generate embeddings
-                embeddings = self._generate_embeddings(texts)
-                
-                # Create points
-                points = []
-                for chunk, embedding in zip(batch, embeddings):
-                    # Include both text and metadata in payload
-                    payload = chunk['metadata'].copy()
-                    payload['text'] = chunk['text']
-                    
-                    points.append(PointStruct(
-                        id=chunk['id'],
-                        vector=embedding,
-                        payload=payload
-                    ))
-                
-                # Upsert to Qdrant
-                self.qdrant_client.upsert(
-                    collection_name=collection_name,
-                    points=points,
-                    wait=True
-                )
-                
-                self.total_imported += len(points)
-                logger.info(f"Imported batch of {len(points)} chunks (total: {self.total_imported})")
-                
-            except Exception as e:
-                logger.error(f"Failed to import batch: {e}")
-                self.total_errors += 1
-    
-    def import_large_file(self, file_path: str, project_name: str):
-        """Import a large JSONL file using streaming."""
-        logger.info(f"🚀 Starting streaming import of {os.path.basename(file_path)}")
-        
-        # Get collection name
-        project_hash = hashlib.md5(project_name.encode()).hexdigest()[:8]
-        collection_name = f"conv_{project_hash}_voyage"
-        
-        # Ensure collection exists
-        collections = [c.name for c in self.qdrant_client.get_collections().collections]
-        if collection_name not in collections:
-            logger.info(f"Creating collection: {collection_name}")
-            self.qdrant_client.create_collection(
-                collection_name=collection_name,
-                vectors_config=VectorParams(size=EMBEDDING_DIMENSIONS, distance=Distance.COSINE)
-            )
-        
-        # Extract conversation ID from filename
-        conversation_id = os.path.splitext(os.path.basename(file_path))[0]
-        
-        # Stream and process the file
-        chunk_count = 0
-        message_count = 0
-        
-        try:
-            logger.info(f"Starting to process chunks from generator")
-            for message_buffer in self.stream_jsonl_messages(file_path):
-                logger.info(f"Received buffer with {len(message_buffer)} messages")
-                self.process_message_buffer(message_buffer, project_name, collection_name, conversation_id)
-                chunk_count += 1
-                message_count += len(message_buffer)
-                logger.info(f"Processed chunk {chunk_count} with {len(message_buffer)} messages (total: {message_count})")
-                
-                # Save state periodically
-                if chunk_count % 10 == 0:
-                    self._save_state()
-            
-            # Log final statistics
-            logger.info(f"Finished processing {chunk_count} chunks with {message_count} total messages")
-            
-            # Mark file as imported
-            if project_name not in self.state["projects"]:
-                self.state["projects"][project_name] = []
-            if file_path not in self.state["projects"][project_name]:
-                self.state["projects"][project_name].append(file_path)
-            
-            self._save_state()
-            logger.info(f"✅ Completed streaming import of {os.path.basename(file_path)} - {chunk_count} chunks, {message_count} messages, {self.total_imported} vectors")
-            
-        except Exception as e:
-            logger.error(f"Error during streaming import: {e}")
-            raise
-
-def main():
-    """Main entry point for streaming import."""
-    import sys
-    import argparse
-    
-    parser = argparse.ArgumentParser(description="Streaming import for large conversation files")
-    parser.add_argument("--project", help="Project directory path")
-    parser.add_argument("--limit", type=int, help="Limit number of files to process")
-    args = parser.parse_args()
-    
-    importer = StreamingVoyageImporter()
-    
-    # If project path is provided via command line
-    if args.project and os.path.exists(args.project):
-        project_name = os.path.basename(args.project)
-        files_processed = 0
-        
-        # Find all JSONL files in the project
-        for file_path in Path(args.project).glob("*.jsonl"):
-            if args.limit and files_processed >= args.limit:
-                break
-                
-            file_size_mb = os.path.getsize(file_path) / (1024 * 1024)
-            logger.info(f"Processing {file_path.name} ({file_size_mb:.1f} MB)")
-            importer.import_large_file(str(file_path), project_name)
-            files_processed += 1
-    else:
-        # No specific project specified - scan for all projects
-        base_path = os.getenv("LOGS_PATH", "/logs")
-        if os.path.exists(base_path):
-            # Scan for all project directories
-            for project_dir in Path(base_path).iterdir():
-                if project_dir.is_dir() and not project_dir.name.startswith('.'):
-                    # Look for JSONL files in this project
-                    jsonl_files = list(project_dir.glob("*.jsonl"))
-                    if jsonl_files:
-                        for jsonl_file in jsonl_files:
-                            file_size_mb = jsonl_file.stat().st_size / (1024 * 1024)
-                            logger.info(f"Processing {jsonl_file.name} ({file_size_mb:.1f} MB) from project {project_dir.name}")
-                            importer.import_large_file(str(jsonl_file), project_dir.name)
-    
-    logger.info(f"Streaming import complete! Total chunks: {importer.total_imported}")
-
-if __name__ == "__main__":
-    main()