claude-self-reflect 2.8.1 → 2.8.2

package/package.json

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

package/scripts/import-latest.py

@@ -1,124 +0,0 @@
-#!/usr/bin/env python3
-"""
-Quick import script for current project's latest conversations.
-Designed for PreCompact hook integration - targets <10 second imports.
-"""
-
-import os
-import sys
-import json
-import subprocess
-from datetime import datetime, timedelta
-from pathlib import Path
-import logging
-
-# Configuration
-LOGS_DIR = os.getenv("LOGS_DIR", os.path.expanduser("~/.claude/projects"))
-STATE_FILE = os.getenv("STATE_FILE", os.path.expanduser("~/.claude-self-reflect-state.json"))
-HOURS_BACK = int(os.getenv("IMPORT_HOURS_BACK", "2"))  # Only import last 2 hours by default
-
-# Set up logging
-logging.basicConfig(
-    level=logging.INFO, 
-    format='%(asctime)s - %(levelname)s - %(message)s'
-)
-logger = logging.getLogger(__name__)
-
-def load_state():
-    """Load import state from file."""
-    if os.path.exists(STATE_FILE):
-        try:
-            with open(STATE_FILE, 'r') as f:
-                return json.load(f)
-        except:
-            return {}
-    return {}
-
-def save_state(state):
-    """Save import state to file."""
-    os.makedirs(os.path.dirname(STATE_FILE), exist_ok=True)
-    with open(STATE_FILE, 'w') as f:
-        json.dump(state, f, indent=2)
-
-def get_project_from_cwd():
-    """Detect project from current working directory."""
-    cwd = os.getcwd()
-    # Convert path to project name format used in logs
-    # Claude logs use format: -Users-username-path-to-project
-    project_name = cwd.replace('/', '-')
-    # Keep the leading dash as that's how Claude stores it
-    if not project_name.startswith('-'):
-        project_name = '-' + project_name
-    return project_name
-
-def get_recent_files(project_path: Path, hours_back: int):
-    """Get JSONL files modified in the last N hours."""
-    cutoff_time = datetime.now() - timedelta(hours=hours_back)
-    recent_files = []
-    
-    for jsonl_file in project_path.glob("*.jsonl"):
-        mtime = datetime.fromtimestamp(jsonl_file.stat().st_mtime)
-        if mtime > cutoff_time:
-            recent_files.append(jsonl_file)
-    
-    return sorted(recent_files, key=lambda f: f.stat().st_mtime, reverse=True)
-
-def main():
-    """Main quick import function."""
-    start_time = datetime.now()
-    
-    # Detect current project
-    project_name = get_project_from_cwd()
-    project_path = Path(LOGS_DIR) / project_name
-    
-    if not project_path.exists():
-        logger.warning(f"Project logs not found: {project_path}")
-        logger.info("Make sure you're in a project directory with Claude conversations.")
-        return
-    
-    logger.info(f"Quick importing latest conversations for: {project_name}")
-    
-    # Get recent files
-    recent_files = get_recent_files(project_path, HOURS_BACK)
-    logger.info(f"Found {len(recent_files)} files modified in last {HOURS_BACK} hours")
-    
-    if not recent_files:
-        logger.info("No recent conversations to import")
-        return
-    
-    # For now, just call the unified importer with the specific project
-    # This is a temporary solution until we implement incremental imports
-    script_dir = os.path.dirname(os.path.abspath(__file__))
-    unified_script = os.path.join(script_dir, "import-conversations-unified.py")
-    
-    # Set environment to only process this project
-    env = os.environ.copy()
-    env['LOGS_DIR'] = str(project_path.parent)
-    env['IMPORT_PROJECT'] = project_name
-    
-    try:
-        # Run the unified importer for just this project
-        result = subprocess.run(
-            [sys.executable, unified_script],
-            env=env,
-            capture_output=True,
-            text=True,
-            timeout=60  # 60 second timeout
-        )
-        
-        if result.returncode == 0:
-            logger.info("Quick import completed successfully")
-        else:
-            logger.error(f"Import failed: {result.stderr}")
-            
-    except subprocess.TimeoutExpired:
-        logger.warning("Import timed out after 60 seconds")
-    except Exception as e:
-        logger.error(f"Error during import: {e}")
-    
-    # Report timing
-    elapsed = (datetime.now() - start_time).total_seconds()
-    logger.info(f"Quick import completed in {elapsed:.1f} seconds")
-
-if __name__ == "__main__":
-    main()

package/scripts/import-old-format.py

@@ -1,171 +0,0 @@
-#!/usr/bin/env python3
-"""
-Import old format JSONL files from Claude conversations.
-These files have a different structure with type/summary fields instead of messages.
-"""
-
-import json
-import sys
-from pathlib import Path
-import hashlib
-import uuid
-from datetime import datetime
-from qdrant_client import QdrantClient
-from qdrant_client.models import Distance, VectorParams, PointStruct
-from fastembed import TextEmbedding
-import logging
-
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
-logger = logging.getLogger(__name__)
-
-def import_old_format_project(project_dir: Path, project_path: str = None):
-    """Import old format JSONL files from a project directory."""
-    
-    # Initialize
-    client = QdrantClient(url='http://localhost:6333')
-    model = TextEmbedding(model_name='sentence-transformers/all-MiniLM-L6-v2', max_length=512)
-    
-    # Determine project path from directory name if not provided
-    if not project_path:
-        # Convert -Users-username-projects-projectname back to path
-        dir_name = project_dir.name
-        project_path = '/' + dir_name.strip('-').replace('-', '/')
-    
-    # Create collection name
-    project_hash = hashlib.md5(project_path.encode()).hexdigest()[:8]
-    collection_name = f'conv_{project_hash}_local'
-    
-    logger.info(f'Project: {project_path}')
-    logger.info(f'Collection: {collection_name}')
-    
-    # Create collection if needed
-    try:
-        client.get_collection(collection_name)
-        logger.info('Collection exists')
-    except:
-        client.create_collection(
-            collection_name=collection_name,
-            vectors_config=VectorParams(size=384, distance=Distance.COSINE)
-        )
-        logger.info('Created collection')
-    
-    # Process all JSONL files
-    jsonl_files = list(project_dir.glob('*.jsonl'))
-    logger.info(f'Found {len(jsonl_files)} files to import')
-    
-    total_points = 0
-    for file_path in jsonl_files:
-        logger.info(f'Processing {file_path.name}...')
-        points_batch = []
-        
-        with open(file_path, 'r', encoding='utf-8') as f:
-            conversation_text = []
-            file_timestamp = file_path.stat().st_mtime
-            
-            for line_num, line in enumerate(f, 1):
-                try:
-                    data = json.loads(line)
-                    msg_type = data.get('type', '')
-                    
-                    # Extract text content based on type
-                    content = None
-                    if msg_type == 'summary' and data.get('summary'):
-                        content = f"[Conversation Summary] {data['summary']}"
-                    elif msg_type == 'user' and data.get('summary'):
-                        content = f"User: {data['summary']}"
-                    elif msg_type == 'assistant' and data.get('summary'):
-                        content = f"Assistant: {data['summary']}"
-                    elif msg_type in ['user', 'assistant']:
-                        # Try to get content from other fields
-                        if 'content' in data:
-                            content = f"{msg_type.title()}: {data['content']}"
-                        elif 'text' in data:
-                            content = f"{msg_type.title()}: {data['text']}"
-                    
-                    if content:
-                        conversation_text.append(content)
-                        
-                        # Create chunks every 5 messages or at end
-                        if len(conversation_text) >= 5:
-                            chunk_text = '\n\n'.join(conversation_text)
-                            if chunk_text.strip():
-                                # Generate embedding
-                                embedding = list(model.embed([chunk_text[:2000]]))[0]  # Limit to 2000 chars
-                                
-                                point = PointStruct(
-                                    id=str(uuid.uuid4()),
-                                    vector=embedding.tolist(),
-                                    payload={
-                                        'content': chunk_text[:1000],  # Store first 1000 chars
-                                        'full_content': chunk_text[:4000],  # Store more for context
-                                        'project_path': project_path,
-                                        'file_path': str(file_path),
-                                        'file_name': file_path.name,
-                                        'conversation_id': file_path.stem,
-                                        'chunk_index': len(points_batch),
-                                        'timestamp': file_timestamp,
-                                        'type': 'conversation_chunk'
-                                    }
-                                )
-                                points_batch.append(point)
-                                conversation_text = []
-                
-                except json.JSONDecodeError:
-                    logger.warning(f'Invalid JSON at line {line_num} in {file_path.name}')
-                except Exception as e:
-                    logger.warning(f'Error processing line {line_num}: {e}')
-            
-            # Handle remaining text
-            if conversation_text:
-                chunk_text = '\n\n'.join(conversation_text)
-                if chunk_text.strip():
-                    embedding = list(model.embed([chunk_text[:2000]]))[0]
-                    
-                    point = PointStruct(
-                        id=str(uuid.uuid4()),
-                        vector=embedding.tolist(),
-                        payload={
-                            'content': chunk_text[:1000],
-                            'full_content': chunk_text[:4000],
-                            'project_path': project_path,
-                            'file_path': str(file_path),
-                            'file_name': file_path.name,
-                            'conversation_id': file_path.stem,
-                            'chunk_index': len(points_batch),
-                            'timestamp': file_timestamp,
-                            'type': 'conversation_chunk'
-                        }
-                    )
-                    points_batch.append(point)
-        
-        # Upload batch
-        if points_batch:
-            client.upsert(collection_name=collection_name, points=points_batch)
-            logger.info(f'  Uploaded {len(points_batch)} chunks from {file_path.name}')
-            total_points += len(points_batch)
-    
-    # Verify
-    info = client.get_collection(collection_name)
-    logger.info(f'\nImport complete!')
-    logger.info(f'Collection {collection_name} now has {info.points_count} points')
-    logger.info(f'Added {total_points} new points in this import')
-    
-    return collection_name, total_points
-
-def main():
-    if len(sys.argv) < 2:
-        print("Usage: python import-old-format.py <project-directory> [project-path]")
-        print("Example: python import-old-format.py ~/.claude/projects/-Users-me-projects-myapp /Users/me/projects/myapp")
-        sys.exit(1)
-    
-    project_dir = Path(sys.argv[1]).expanduser()
-    project_path = sys.argv[2] if len(sys.argv) > 2 else None
-    
-    if not project_dir.exists():
-        print(f"Error: Directory {project_dir} does not exist")
-        sys.exit(1)
-    
-    import_old_format_project(project_dir, project_path)
-
-if __name__ == "__main__":
-    main()