claude-self-reflect 2.8.5 → 2.8.6

package/README.md

@@ -26,6 +26,21 @@ Give Claude perfect memory of all your conversations. Search past discussions in
 
 **🔒 100% Local by Default** • **⚡ Blazing Fast Search** • **🚀 Zero Configuration** • **🏭 Production Ready**
 
+## 📑 Table of Contents
+
+- [🚀 Quick Install](#-quick-install)
+- [✨ The Magic](#-the-magic)
+- [📊 Before & After](#-before--after)
+- [💬 Real Examples](#-real-examples)
+- [🆕 NEW: Real-time Indexing Status](#-new-real-time-indexing-status-in-your-terminal)
+- [🎯 Key Features](#-key-features)
+- [🏗️ Architecture](#️-architecture)
+- [🛠️ Requirements](#️-requirements)
+- [📖 Documentation](#-documentation)
+- [📦 What's New](#-whats-new)
+- [🔧 Troubleshooting](#-troubleshooting)
+- [👥 Contributors](#-contributors)
+
 ## 🚀 Quick Install
 
 ```bash
@@ -97,7 +112,9 @@ Works with [Claude Code Statusline](https://github.com/sirmalloc/ccstatusline) -
 
 ## 🎯 Key Features
 
-### 📊 Statusline Integration
+<details>
+<summary><b>📊 Statusline Integration</b></summary>
+
 See your indexing progress right in your terminal! Works with [Claude Code Statusline](https://github.com/sirmalloc/ccstatusline):
 - **Progress Bar** - Visual indicator `[████████ ] 91%`
 - **Indexing Lag** - Shows backlog `• 7h behind`
@@ -106,7 +123,11 @@ See your indexing progress right in your terminal! Works with [Claude Code Statu
 
 [Learn more about statusline integration →](docs/statusline-integration.md)
 
-### Project-Scoped Search
+</details>
+
+<details>
+<summary><b>🔍 Project-Scoped Search</b></summary>
+
 Searches are **project-aware by default**. Claude automatically searches within your current project:
 
 ```
@@ -119,21 +140,37 @@ You: "Search all projects for WebSocket implementations"
 Claude: [Searches across ALL your projects]
 ```
 
-### ⏱️ Memory Decay
+</details>
+
+<details>
+<summary><b>⏱️ Memory Decay</b></summary>
+
 Recent conversations matter more. Old ones fade. Like your brain, but reliable.
+- **90-day half-life**: Recent memories stay strong
+- **Graceful aging**: Old information fades naturally
+- **Configurable**: Adjust decay rate to your needs
+
+</details>
+
+<details>
+<summary><b>⚡ Performance at Scale</b></summary>
 
-### ⚡ Performance at Scale
 - **Search**: <3ms average response time
 - **Scale**: 600+ conversations across 24 projects
 - **Reliability**: 100% indexing success rate
 - **Memory**: 96% reduction from v2.5.15
+- **Real-time**: HOT/WARM/COLD intelligent prioritization
+
+</details>
 
 ## 🏗️ Architecture
 
+<details>
+<summary><b>View Architecture Diagram & Details</b></summary>
+
 ![Import Architecture](docs/diagrams/import-architecture.png)
 
-<details>
-<summary>🔥 HOT/WARM/COLD Intelligent Prioritization</summary>
+### 🔥 HOT/WARM/COLD Intelligent Prioritization
 
 - **🔥 HOT** (< 5 minutes): 2-second intervals for near real-time import
 - **🌡️ WARM** (< 24 hours): Normal priority with starvation prevention
@@ -141,13 +178,37 @@ Recent conversations matter more. Old ones fade. Like your brain, but reliable.
 
 Files are categorized by age and processed with priority queuing to ensure newest content gets imported quickly while preventing older files from being starved.
 
+### Components
+- **Vector Database**: Qdrant for semantic search
+- **MCP Server**: Python-based using FastMCP
+- **Embeddings**: Local (FastEmbed) or Cloud (Voyage AI)
+- **Import Pipeline**: Docker-based with automatic monitoring
+
 </details>
 
 ## 🛠️ Requirements
 
+<details>
+<summary><b>System Requirements</b></summary>
+
+### Minimum Requirements
 - **Docker Desktop** (macOS/Windows) or **Docker Engine** (Linux)
 - **Node.js** 16+ (for the setup wizard)
 - **Claude Code** CLI
+- **4GB RAM** available for Docker
+- **2GB disk space** for vector database
+
+### Recommended
+- **8GB RAM** for optimal performance
+- **SSD storage** for faster indexing
+- **Docker Desktop 4.0+** for best compatibility
+
+### Operating Systems
+- ✅ macOS 11+ (Intel & Apple Silicon)
+- ✅ Windows 10/11 with WSL2
+- ✅ Linux (Ubuntu 20.04+, Debian 11+)
+
+</details>
 
 ## 📖 Documentation
 
@@ -254,9 +315,10 @@ docker compose run --rm importer python /app/scripts/delta-metadata-update-safe.
 
 ## 🔧 Troubleshooting
 
-### Common Issues and Solutions
+<details>
+<summary><b>Common Issues and Solutions</b></summary>
 
-#### 1. "No collections created" after import
+### 1. "No collections created" after import
 **Symptom**: Import runs but Qdrant shows no collections  
 **Cause**: Docker can't access Claude projects directory  
 **Solution**:
@@ -272,12 +334,12 @@ cat .env | grep CLAUDE_LOGS_PATH
 # Should show: CLAUDE_LOGS_PATH=/Users/YOUR_NAME/.claude/projects
 ```
 
-#### 2. MCP server shows "ERROR" but it's actually INFO
+### 2. MCP server shows "ERROR" but it's actually INFO
 **Symptom**: `[ERROR] MCP server "claude-self-reflect" Server stderr: INFO Starting MCP server`  
 **Cause**: Claude Code displays all stderr output as errors  
 **Solution**: This is not an actual error - the MCP is working correctly. The INFO message confirms successful startup.
 
-#### 3. "No JSONL files found"
+### 3. "No JSONL files found"
 **Symptom**: Setup can't find any conversation files  
 **Cause**: Claude Code hasn't been used yet or stores files elsewhere  
 **Solution**:
@@ -289,7 +351,7 @@ ls ~/.claude/projects/
 # The watcher will import them automatically
 ```
 
-#### 4. Docker volume mount issues
+### 4. Docker volume mount issues
 **Symptom**: Import fails with permission errors  
 **Cause**: Docker can't access home directory  
 **Solution**:
@@ -303,7 +365,7 @@ docker compose down
 claude-self-reflect setup
 ```
 
-#### 5. Qdrant not accessible
+### 5. Qdrant not accessible
 **Symptom**: Can't connect to localhost:6333  
 **Solution**:
 ```bash
@@ -317,9 +379,12 @@ docker compose ps
 docker compose logs qdrant
 ```
 
-### Diagnostic Tools
+</details>
 
-Run comprehensive diagnostics:
+<details>
+<summary><b>Diagnostic Tools</b></summary>
+
+### Run Comprehensive Diagnostics
 ```bash
 claude-self-reflect doctor
 ```
@@ -331,18 +396,41 @@ This checks:
 - Import status and collections
 - Service health
 
-### Still Having Issues?
+### Check Logs
+```bash
+# View all service logs
+docker compose logs -f
+
+# View specific service
+docker compose logs qdrant
+docker compose logs watcher
+```
+
+### Generate Diagnostic Report
+```bash
+# Create diagnostic file for issue reporting
+claude-self-reflect doctor > diagnostic.txt
+```
 
-1. Check the logs:
-   ```bash
-   docker compose logs -f
-   ```
+</details>
 
-2. Report issues with diagnostic output:
-   ```bash
-   claude-self-reflect doctor > diagnostic.txt
-   ```
-   Then include diagnostic.txt when [reporting issues](https://github.com/ramakay/claude-self-reflect/issues)
+<details>
+<summary><b>Getting Help</b></summary>
+
+1. **Check Documentation**
+   - [Troubleshooting Guide](docs/troubleshooting.md)
+   - [FAQ](docs/faq.md)
+   - [Windows Setup](docs/windows-setup.md)
+
+2. **Community Support**
+   - [GitHub Discussions](https://github.com/ramakay/claude-self-reflect/discussions)
+   - [Discord Community](https://discord.gg/claude-self-reflect)
+
+3. **Report Issues**
+   - [GitHub Issues](https://github.com/ramakay/claude-self-reflect/issues)
+   - Include diagnostic output when reporting
+
+</details>
 
 ## 👥 Contributors
 

package/mcp-server/src/health.py

@@ -0,0 +1,190 @@
+#!/usr/bin/env python3
+"""
+Health check endpoint for Claude Self-Reflect system
+
+Provides a simple way to monitor system health and import status.
+"""
+
+import json
+import os
+import sys
+from pathlib import Path
+from datetime import datetime, timedelta
+from typing import Dict, Any
+
+# No sys.path modification needed - using subprocess for imports
+
+def check_qdrant_health() -> Dict[str, Any]:
+    """Check if Qdrant is accessible and has data"""
+    try:
+        from qdrant_client import QdrantClient
+        from qdrant_client.http.exceptions import ResponseHandlingException
+        
+        # Add timeout for network operations
+        client = QdrantClient(
+            'localhost', 
+            port=6333,
+            timeout=5  # 5 second timeout
+        )
+        
+        collections = client.get_collections().collections
+        
+        return {
+            'status': 'healthy',
+            'collections': len(collections),
+            'accessible': True
+        }
+    except (ResponseHandlingException, ConnectionError, TimeoutError) as e:
+        # Sanitize error messages to avoid information disclosure
+        return {
+            'status': 'unhealthy',
+            'error': 'Connection failed',
+            'accessible': False
+        }
+    except Exception as e:
+        return {
+            'status': 'unhealthy',
+            'error': 'Service unavailable',
+            'accessible': False
+        }
+
+def check_import_status() -> Dict[str, Any]:
+    """Check import status from status.py"""
+    try:
+        # Run status.py and parse output
+        import subprocess
+        import json
+        
+        result = subprocess.run(
+            [sys.executable, str(Path(__file__).parent / "status.py")],
+            capture_output=True,
+            text=True,
+            timeout=10
+        )
+        
+        if result.returncode == 0:
+            status = json.loads(result.stdout)
+            return {
+                'percentage': status['overall']['percentage'],
+                'indexed': status['overall']['indexed'],
+                'total': status['overall']['total'],
+                'backlog': status['overall']['backlog']
+            }
+        else:
+            return {
+                'error': result.stderr,
+                'percentage': 0
+            }
+    except Exception as e:
+        return {
+            'error': str(e),
+            'percentage': 0
+        }
+
+def check_watcher_status() -> Dict[str, Any]:
+    """Check if Docker watcher is running"""
+    try:
+        import subprocess
+        result = subprocess.run(
+            ["docker", "ps", "--filter", "name=claude-reflection-safe-watcher", "--format", "{{.Status}}"],
+            capture_output=True,
+            text=True,
+            timeout=5
+        )
+        
+        if result.stdout and "Up" in result.stdout:
+            return {
+                'status': 'running',
+                'details': result.stdout.strip()
+            }
+        else:
+            return {
+                'status': 'stopped',
+                'details': 'Container not running'
+            }
+    except Exception as e:
+        return {
+            'status': 'unknown',
+            'error': 'Docker check failed'
+        }
+
+def check_recent_imports() -> Dict[str, Any]:
+    """Check for recent import activity"""
+    try:
+        import_file = Path.home() / ".claude-self-reflect" / "config" / "imported-files.json"
+        if import_file.exists():
+            mtime = datetime.fromtimestamp(import_file.stat().st_mtime)
+            age = datetime.now() - mtime
+            
+            return {
+                'last_import': mtime.isoformat(),
+                'hours_ago': round(age.total_seconds() / 3600, 1),
+                'active': age < timedelta(hours=24)
+            }
+        return {
+            'last_import': None,
+            'active': False
+        }
+    except Exception as e:
+        return {
+            'error': 'Import check failed',
+            'active': False
+        }
+
+def get_health_status() -> Dict[str, Any]:
+    """Get comprehensive health status"""
+    
+    # Collect all health checks
+    qdrant = check_qdrant_health()
+    imports = check_import_status()
+    watcher = check_watcher_status()
+    recent = check_recent_imports()
+    
+    # Determine overall health
+    is_healthy = (
+        qdrant.get('accessible', False) and
+        imports.get('percentage', 0) > 95 and
+        watcher.get('status') == 'running'
+    )
+    
+    return {
+        'timestamp': datetime.now().isoformat(),
+        'healthy': is_healthy,
+        'status': 'healthy' if is_healthy else 'degraded',
+        'components': {
+            'qdrant': qdrant,
+            'imports': imports,
+            'watcher': watcher,
+            'recent_activity': recent
+        },
+        'summary': {
+            'import_percentage': imports.get('percentage', 0),
+            'collections': qdrant.get('collections', 0),
+            'watcher_running': watcher.get('status') == 'running',
+            'recent_imports': recent.get('active', False)
+        }
+    }
+
+def main():
+    """Main entry point for CLI usage"""
+    try:
+        health = get_health_status()
+        
+        # Pretty print
+        print(json.dumps(health, indent=2))
+        
+        # Exit code based on health
+        sys.exit(0 if health['healthy'] else 1)
+        
+    except Exception as e:
+        error_response = {
+            'timestamp': datetime.now().isoformat(),
+            'healthy': False,
+            'status': 'error',
+            'error': 'Health check failed'
+        }
+        print(json.dumps(error_response, indent=2))
+        sys.exit(2)
+
+if __name__ == "__main__":
+    main()

package/mcp-server/src/project_resolver.py

@@ -76,31 +76,64 @@ class ProjectResolver:
             return []
         
         # Strategy 1: Direct hash of input (handles full paths)
-        direct_hash = hashlib.sha256(user_project_name.encode()).hexdigest()[:16]
+        # Try both MD5 (used by streaming-watcher) and SHA256 (legacy)
+        direct_hash_md5 = hashlib.md5(user_project_name.encode()).hexdigest()[:8]
+        direct_hash_sha256 = hashlib.sha256(user_project_name.encode()).hexdigest()[:16]
+        
         # Match exact hash segment between underscores, not substring
         direct_matches = [c for c in collection_names 
-                         if f"_{direct_hash}_" in c or c.endswith(f"_{direct_hash}")]
+                         if f"_{direct_hash_md5}_" in c or c.endswith(f"_{direct_hash_md5}") or
+                            f"_{direct_hash_sha256}_" in c or c.endswith(f"_{direct_hash_sha256}")]
         matching_collections.update(direct_matches)
         
         # Strategy 2: Try normalized version
         normalized = self._normalize_project_name(user_project_name)
         if normalized != user_project_name:
-            norm_hash = hashlib.sha256(normalized.encode()).hexdigest()[:16]
+            norm_hash_md5 = hashlib.md5(normalized.encode()).hexdigest()[:8]
+            norm_hash_sha256 = hashlib.sha256(normalized.encode()).hexdigest()[:16]
+            
             # Match exact hash segment between underscores, not substring
             norm_matches = [c for c in collection_names 
-                           if f"_{norm_hash}_" in c or c.endswith(f"_{norm_hash}")]
+                           if f"_{norm_hash_md5}_" in c or c.endswith(f"_{norm_hash_md5}") or
+                              f"_{norm_hash_sha256}_" in c or c.endswith(f"_{norm_hash_sha256}")]
             matching_collections.update(norm_matches)
         
         # Strategy 3: Case-insensitive normalized version
         lower_normalized = normalized.lower()
         if lower_normalized != normalized:
-            lower_hash = hashlib.sha256(lower_normalized.encode()).hexdigest()[:16]
+            lower_hash_md5 = hashlib.md5(lower_normalized.encode()).hexdigest()[:8]
+            lower_hash_sha256 = hashlib.sha256(lower_normalized.encode()).hexdigest()[:16]
+            
             # Match exact hash segment between underscores, not substring
             lower_matches = [c for c in collection_names 
-                            if f"_{lower_hash}_" in c or c.endswith(f"_{lower_hash}")]
+                            if f"_{lower_hash_md5}_" in c or c.endswith(f"_{lower_hash_md5}") or
+                               f"_{lower_hash_sha256}_" in c or c.endswith(f"_{lower_hash_sha256}")]
             matching_collections.update(lower_matches)
         
-        # Strategy 4: Use segment-based discovery for complex paths
+        # Strategy 4: ALWAYS try mapping project name to full directory path in .claude/projects/
+        # This ensures we find all related collections, not just the first match
+        # This handles the case where streaming-watcher uses full path but MCP uses short name
+        if not user_project_name.startswith('-'):
+            # Check if there's a matching directory in .claude/projects/
+            projects_dir = Path.home() / ".claude" / "projects"
+            if projects_dir.exists():
+                for proj_dir in projects_dir.iterdir():
+                    if proj_dir.is_dir():
+                        # Check if the directory name contains the project name
+                        # This handles both "claude-self-reflect" and "-Users-...-projects-claude-self-reflect"
+                        if (proj_dir.name.endswith(f"-{user_project_name}") or 
+                            f"-{user_project_name}" in proj_dir.name or
+                            proj_dir.name == user_project_name):
+                            # Found a matching directory - hash its name
+                            dir_name = proj_dir.name
+                            dir_hash_md5 = hashlib.md5(dir_name.encode()).hexdigest()[:8]
+                            
+                            # Find collections with this hash
+                            dir_matches = [c for c in collection_names 
+                                          if f"_{dir_hash_md5}_" in c or c.endswith(f"_{dir_hash_md5}")]
+                            matching_collections.update(dir_matches)
+        
+        # Strategy 5: Use segment-based discovery for complex paths
         if not matching_collections:
             # Extract segments from the input
             segments = self._extract_project_segments(user_project_name)
@@ -111,10 +144,13 @@ class ProjectResolver:
                 
                 # Try each candidate
                 for candidate in candidates:
-                    candidate_hash = hashlib.sha256(candidate.encode()).hexdigest()[:16]
+                    candidate_hash_md5 = hashlib.md5(candidate.encode()).hexdigest()[:8]
+                    candidate_hash_sha256 = hashlib.sha256(candidate.encode()).hexdigest()[:16]
+                    
                     # Match exact hash segment between underscores, not substring
                     candidate_matches = [c for c in collection_names 
-                                       if f"_{candidate_hash}_" in c or c.endswith(f"_{candidate_hash}")]
+                                       if f"_{candidate_hash_md5}_" in c or c.endswith(f"_{candidate_hash_md5}") or
+                                          f"_{candidate_hash_sha256}_" in c or c.endswith(f"_{candidate_hash_sha256}")]
                     matching_collections.update(candidate_matches)
                     
                     # Stop if we found matches

package/package.json

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

package/scripts/import-conversations-unified.py

@@ -30,13 +30,16 @@ logger = logging.getLogger(__name__)
 
 # Environment variables
 QDRANT_URL = os.getenv("QDRANT_URL", "http://localhost:6333")
-STATE_FILE = os.getenv("STATE_FILE", "/config/imported-files.json")
+STATE_FILE = os.getenv("STATE_FILE", os.path.expanduser("~/.claude-self-reflect/config/imported-files.json"))
 PREFER_LOCAL_EMBEDDINGS = os.getenv("PREFER_LOCAL_EMBEDDINGS", "true").lower() == "true"
 VOYAGE_API_KEY = os.getenv("VOYAGE_KEY")
 MAX_CHUNK_SIZE = int(os.getenv("MAX_CHUNK_SIZE", "50"))  # Messages per chunk
 
-# Initialize Qdrant client
-client = QdrantClient(url=QDRANT_URL)
+# Initialize Qdrant client with timeout
+client = QdrantClient(
+    url=QDRANT_URL,
+    timeout=30  # 30 second timeout for network operations
+)
 
 # Initialize embedding provider
 embedding_provider = None
@@ -138,11 +141,11 @@ def process_and_upload_chunk(messages: List[Dict[str, Any]], chunk_index: int,
             payload=payload
         )
         
-        # Upload immediately
+        # Upload immediately (no wait for better throughput)
         client.upsert(
             collection_name=collection_name,
             points=[point],
-            wait=True
+            wait=False  # Don't wait for indexing to complete
         )
         
         return 1

package/Dockerfile.mcp-server.bak

@@ -1,20 +0,0 @@
-FROM python:3.13-slim
-
-WORKDIR /app
-
-# Update system packages for security
-RUN apt-get update && apt-get upgrade -y && rm -rf /var/lib/apt/lists/*
-
-# Copy the MCP server package files
-COPY mcp-server/pyproject.toml ./
-COPY mcp-server/src ./src
-
-# Install the package in development mode
-RUN pip install --no-cache-dir -e .
-
-# Create a non-root user
-RUN useradd -m -u 1000 mcpuser
-USER mcpuser
-
-# Keep the container running and wait for docker exec commands
-CMD ["tail", "-f", "/dev/null"]

package/Dockerfile.watcher.bak

@@ -1,50 +0,0 @@
-FROM python:3.13-slim
-
-# Update system packages for security and install build dependencies for psutil
-RUN apt-get update && apt-get upgrade -y && apt-get install -y \
-    gcc \
-    python3-dev \
-    && rm -rf /var/lib/apt/lists/*
-
-# Install Python dependencies
-RUN pip install --no-cache-dir \
-    psutil==5.9.5 \
-    qdrant-client>=1.7.0 \
-    openai>=1.0.0 \
-    backoff>=2.2.0 \
-    requests>=2.31.0 \
-    tqdm>=4.66.0 \
-    voyageai>=0.2.0 \
-    fastembed>=0.4.0
-
-# Create non-root user
-RUN useradd -m -u 1000 watcher
-
-# Pre-download FastEmbed model to avoid runtime downloads
-RUN mkdir -p /home/watcher/.cache && \
-    FASTEMBED_CACHE_PATH=/home/watcher/.cache/fastembed python -c "from fastembed import TextEmbedding; import os; os.environ['FASTEMBED_CACHE_PATH']='/home/watcher/.cache/fastembed'; TextEmbedding('sentence-transformers/all-MiniLM-L6-v2')" && \
-    chown -R watcher:watcher /home/watcher/.cache
-
-# Create scripts directory and copy required files
-RUN mkdir -p /scripts
-
-# Copy all necessary scripts
-COPY scripts/import-conversations-unified.py /scripts/
-COPY scripts/import-watcher.py /scripts/
-COPY scripts/streaming-importer.py /scripts/
-COPY scripts/utils.py /scripts/
-COPY scripts/trigger-import.py /scripts/
-
-# Copy MCP server directory for utils
-COPY mcp-server/src/utils.py /mcp-server/src/utils.py
-
-RUN chmod +x /scripts/*.py
-
-# Set working directory
-WORKDIR /app
-
-# Switch to non-root user
-USER watcher
-
-# Default command - use streaming importer for low memory usage
-CMD ["python", "/scripts/streaming-importer.py"]

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()