claude-self-reflect 2.7.2 → 2.7.3

package/mcp-server/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "claude-self-reflect-mcp"
-version = "2.7.0"
+version = "2.7.3"
 description = "MCP server for Claude self-reflection with memory decay"
 # readme = "README.md"
 requires-python = ">=3.10"

package/mcp-server/src/server.py

@@ -381,13 +381,19 @@ async def reflect_on_past(
                     if c.startswith(f"conv_{project_hash}_")
                 ]
             
+            # Always include reflections collections when searching a specific project
+            reflections_collections = [c for c in all_collections if c.startswith('reflections')]
+            
             if not project_collections:
                 # Fall back to searching all collections but filtering by project metadata
                 await ctx.debug(f"No collections found for project {target_project}, will filter by metadata")
                 collections_to_search = all_collections
             else:
                 await ctx.debug(f"Found {len(project_collections)} collections for project {target_project}")
-                collections_to_search = project_collections
+                # Include both project collections and reflections
+                collections_to_search = project_collections + reflections_collections
+                # Remove duplicates
+                collections_to_search = list(set(collections_to_search))
         else:
             collections_to_search = all_collections
         
@@ -524,12 +530,26 @@ async def reflect_on_past(
                         # Check project filter if we're searching all collections but want specific project
                         point_project = point.payload.get('project', collection_name.replace('conv_', '').replace('_voyage', '').replace('_local', ''))
                         
+                        # Special handling for reflections - they're global by default but can have project context
+                        is_reflection_collection = collection_name.startswith('reflections')
+                        
                         # Handle project matching - check if the target project name appears at the end of the stored project path
-                        if target_project != 'all' and not project_collections:
+                        if target_project != 'all' and not project_collections and not is_reflection_collection:
                             # The stored project name is like "-Users-username-projects-ShopifyMCPMockShop"
                             # We want to match just "ShopifyMCPMockShop"
                             if not point_project.endswith(f"-{target_project}") and point_project != target_project:
                                 continue  # Skip results from other projects
+                        
+                        # For reflections with project context, optionally filter by project
+                        if is_reflection_collection and target_project != 'all' and 'project' in point.payload:
+                            # Only filter if the reflection has project metadata
+                            reflection_project = point.payload.get('project', '')
+                            if reflection_project and not (
+                                reflection_project == target_project or 
+                                reflection_project.endswith(f"/{target_project}") or
+                                reflection_project.endswith(f"-{target_project}")
+                            ):
+                                continue  # Skip reflections from other projects
                             
                         all_results.append(SearchResult(
                             id=str(point.id),
@@ -604,12 +624,26 @@ async def reflect_on_past(
                         # Check project filter if we're searching all collections but want specific project
                         point_project = point.payload.get('project', collection_name.replace('conv_', '').replace('_voyage', '').replace('_local', ''))
                         
+                        # Special handling for reflections - they're global by default but can have project context
+                        is_reflection_collection = collection_name.startswith('reflections')
+                        
                         # Handle project matching - check if the target project name appears at the end of the stored project path
-                        if target_project != 'all' and not project_collections:
+                        if target_project != 'all' and not project_collections and not is_reflection_collection:
                             # The stored project name is like "-Users-username-projects-ShopifyMCPMockShop"
                             # We want to match just "ShopifyMCPMockShop"
                             if not point_project.endswith(f"-{target_project}") and point_project != target_project:
                                 continue  # Skip results from other projects
+                        
+                        # For reflections with project context, optionally filter by project
+                        if is_reflection_collection and target_project != 'all' and 'project' in point.payload:
+                            # Only filter if the reflection has project metadata
+                            reflection_project = point.payload.get('project', '')
+                            if reflection_project and not (
+                                reflection_project == target_project or 
+                                reflection_project.endswith(f"/{target_project}") or
+                                reflection_project.endswith(f"-{target_project}")
+                            ):
+                                continue  # Skip reflections from other projects
                             
                         all_results.append(SearchResult(
                             id=str(point.id),
@@ -641,13 +675,27 @@ async def reflect_on_past(
                         # Check project filter if we're searching all collections but want specific project
                         point_project = point.payload.get('project', collection_name.replace('conv_', '').replace('_voyage', '').replace('_local', ''))
                         
+                        # Special handling for reflections - they're global by default but can have project context
+                        is_reflection_collection = collection_name.startswith('reflections')
+                        
                         # Handle project matching - check if the target project name appears at the end of the stored project path
-                        if target_project != 'all' and not project_collections:
+                        if target_project != 'all' and not project_collections and not is_reflection_collection:
                             # The stored project name is like "-Users-username-projects-ShopifyMCPMockShop"
                             # We want to match just "ShopifyMCPMockShop"
                             if not point_project.endswith(f"-{target_project}") and point_project != target_project:
                                 continue  # Skip results from other projects
                         
+                        # For reflections with project context, optionally filter by project
+                        if is_reflection_collection and target_project != 'all' and 'project' in point.payload:
+                            # Only filter if the reflection has project metadata
+                            reflection_project = point.payload.get('project', '')
+                            if reflection_project and not (
+                                reflection_project == target_project or 
+                                reflection_project.endswith(f"/{target_project}") or
+                                reflection_project.endswith(f"-{target_project}")
+                            ):
+                                continue  # Skip reflections from other projects
+                        
                         # BOOST V2 CHUNKS: Apply score boost for v2 chunks (better quality)
                         original_score = point.score
                         final_score = original_score
@@ -932,6 +980,25 @@ async def store_reflection(
         # Create reflections collection name
         collection_name = f"reflections{get_collection_suffix()}"
         
+        # Get current project context
+        cwd = os.environ.get('MCP_CLIENT_CWD', os.getcwd())
+        project_path = Path(cwd)
+        
+        # Extract project name from path
+        project_name = None
+        path_parts = project_path.parts
+        if 'projects' in path_parts:
+            idx = path_parts.index('projects')
+            if idx + 1 < len(path_parts):
+                # Get all parts after 'projects' to form the project name
+                # This handles cases like projects/Connectiva-App/connectiva-ai
+                project_parts = path_parts[idx + 1:]
+                project_name = '/'.join(project_parts)
+        
+        # If no project detected, use the last directory name
+        if not project_name:
+            project_name = project_path.name
+        
         # Ensure collection exists
         try:
             collection_info = await qdrant_client.get_collection(collection_name)
@@ -949,7 +1016,7 @@ async def store_reflection(
         # Generate embedding for the reflection
         embedding = await generate_embedding(content)
         
-        # Create point with metadata
+        # Create point with metadata including project context
         point_id = datetime.now().timestamp()
         point = PointStruct(
             id=int(point_id),
@@ -959,7 +1026,9 @@ async def store_reflection(
                 "tags": tags,
                 "timestamp": datetime.now().isoformat(),
                 "type": "reflection",
-                "role": "user_reflection"
+                "role": "user_reflection",
+                "project": project_name,  # Add project context
+                "project_path": str(project_path)  # Add full path for reference
             }
         )
         

package/package.json

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

package/scripts/import-conversations-unified.backup.py

@@ -1,374 +0,0 @@
-#!/usr/bin/env python3
-"""
-Streaming importer with true line-by-line processing to prevent OOM.
-Processes JSONL files without loading entire file into memory.
-"""
-
-import json
-import os
-import sys
-import hashlib
-import gc
-from pathlib import Path
-from datetime import datetime
-from typing import List, Dict, Any, Optional
-import logging
-
-# Add the project root to the Python path
-project_root = Path(__file__).parent.parent
-sys.path.insert(0, str(project_root))
-
-from qdrant_client import QdrantClient
-from qdrant_client.models import PointStruct, Distance, VectorParams
-
-# Set up logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(levelname)s - %(message)s'
-)
-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")
-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 embedding provider
-embedding_provider = None
-embedding_dimension = None
-
-if PREFER_LOCAL_EMBEDDINGS or not VOYAGE_API_KEY:
-    logger.info("Using local embeddings (fastembed)")
-    from fastembed import TextEmbedding
-    embedding_provider = TextEmbedding(model_name="sentence-transformers/all-MiniLM-L6-v2")
-    embedding_dimension = 384
-    collection_suffix = "local"
-else:
-    logger.info("Using Voyage AI embeddings")
-    import voyageai
-    embedding_provider = voyageai.Client(api_key=VOYAGE_API_KEY)
-    embedding_dimension = 1024
-    collection_suffix = "voyage"
-
-def normalize_project_name(project_name: str) -> str:
-    """Normalize project name for consistency."""
-    return project_name.replace("-Users-ramakrishnanannaswamy-projects-", "").replace("-", "_").lower()
-
-def get_collection_name(project_path: Path) -> str:
-    """Generate collection name from project path."""
-    normalized = normalize_project_name(project_path.name)
-    name_hash = hashlib.md5(normalized.encode()).hexdigest()[:8]
-    return f"conv_{name_hash}_{collection_suffix}"
-
-def ensure_collection(collection_name: str):
-    """Ensure collection exists with correct configuration."""
-    collections = client.get_collections().collections
-    if not any(c.name == collection_name for c in collections):
-        logger.info(f"Creating collection: {collection_name}")
-        client.create_collection(
-            collection_name=collection_name,
-            vectors_config=VectorParams(size=embedding_dimension, distance=Distance.COSINE)
-        )
-
-def generate_embeddings(texts: List[str]) -> List[List[float]]:
-    """Generate embeddings for texts."""
-    if PREFER_LOCAL_EMBEDDINGS or not VOYAGE_API_KEY:
-        embeddings = list(embedding_provider.passage_embed(texts))
-        return [emb.tolist() if hasattr(emb, 'tolist') else emb for emb in embeddings]
-    else:
-        response = embedding_provider.embed(texts, model="voyage-3")
-        return response.embeddings
-
-def process_and_upload_chunk(messages: List[Dict[str, Any]], chunk_index: int,
-                            conversation_id: str, created_at: str,
-                            metadata: Dict[str, Any], collection_name: str,
-                            project_path: Path) -> int:
-    """Process and immediately upload a single chunk."""
-    if not messages:
-        return 0
-    
-    # Extract text content
-    texts = []
-    for msg in messages:
-        role = msg.get("role", "unknown")
-        content = msg.get("content", "")
-        if content:
-            texts.append(f"{role.upper()}: {content}")
-    
-    if not texts:
-        return 0
-    
-    chunk_text = "\n".join(texts)
-    
-    try:
-        # Generate embedding
-        embeddings = generate_embeddings([chunk_text])
-        
-        # Create point ID
-        point_id = hashlib.md5(
-            f"{conversation_id}_{chunk_index}".encode()
-        ).hexdigest()[:16]
-        
-        # Create payload
-        payload = {
-            "text": chunk_text,
-            "conversation_id": conversation_id,
-            "chunk_index": chunk_index,
-            "timestamp": created_at,
-            "project": normalize_project_name(project_path.name),
-            "start_role": messages[0].get("role", "unknown") if messages else "unknown",
-            "message_count": len(messages)
-        }
-        
-        # Add metadata
-        if metadata:
-            payload.update(metadata)
-        
-        # Create point
-        point = PointStruct(
-            id=int(point_id, 16) % (2**63),
-            vector=embeddings[0],
-            payload=payload
-        )
-        
-        # Upload immediately
-        client.upsert(
-            collection_name=collection_name,
-            points=[point],
-            wait=True
-        )
-        
-        return 1
-        
-    except Exception as e:
-        logger.error(f"Error processing chunk {chunk_index}: {e}")
-        return 0
-
-def extract_metadata_single_pass(file_path: str) -> tuple[Dict[str, Any], str]:
-    """Extract metadata in a single pass, return metadata and first timestamp."""
-    metadata = {
-        "files_analyzed": [],
-        "files_edited": [],
-        "tools_used": [],
-        "concepts": []
-    }
-    
-    first_timestamp = None
-    
-    try:
-        with open(file_path, 'r', encoding='utf-8') as f:
-            for line in f:
-                if not line.strip():
-                    continue
-                    
-                try:
-                    data = json.loads(line)
-                    
-                    # Get timestamp from first valid entry
-                    if first_timestamp is None and 'timestamp' in data:
-                        first_timestamp = data.get('timestamp')
-                    
-                    # Extract tool usage from messages
-                    if 'message' in data and data['message']:
-                        msg = data['message']
-                        if msg.get('content'):
-                            content = msg['content']
-                            if isinstance(content, list):
-                                for item in content:
-                                    if isinstance(item, dict) and item.get('type') == 'tool_use':
-                                        tool_name = item.get('name', '')
-                                        if tool_name and tool_name not in metadata['tools_used']:
-                                            metadata['tools_used'].append(tool_name)
-                                        
-                                        # Extract file references
-                                        if 'input' in item:
-                                            input_data = item['input']
-                                            if isinstance(input_data, dict):
-                                                if 'file_path' in input_data:
-                                                    file_ref = input_data['file_path']
-                                                    if file_ref not in metadata['files_analyzed']:
-                                                        metadata['files_analyzed'].append(file_ref)
-                                                if 'path' in input_data:
-                                                    file_ref = input_data['path']
-                                                    if file_ref not in metadata['files_analyzed']:
-                                                        metadata['files_analyzed'].append(file_ref)
-                                        
-                except json.JSONDecodeError:
-                    continue
-                except Exception:
-                    continue
-                    
-    except Exception as e:
-        logger.warning(f"Error extracting metadata: {e}")
-    
-    return metadata, first_timestamp or datetime.now().isoformat()
-
-def stream_import_file(jsonl_file: Path, collection_name: str, project_path: Path) -> int:
-    """Stream import a single JSONL file without loading it into memory."""
-    logger.info(f"Streaming import of {jsonl_file.name}")
-    
-    # Extract metadata in first pass (lightweight)
-    metadata, created_at = extract_metadata_single_pass(str(jsonl_file))
-    
-    # Stream messages and process in chunks
-    chunk_buffer = []
-    chunk_index = 0
-    total_chunks = 0
-    conversation_id = jsonl_file.stem
-    
-    try:
-        with open(jsonl_file, 'r', encoding='utf-8') as f:
-            for line_num, line in enumerate(f, 1):
-                line = line.strip()
-                if not line:
-                    continue
-                
-                try:
-                    data = json.loads(line)
-                    
-                    # Skip non-message lines
-                    if data.get('type') == 'summary':
-                        continue
-                    
-                    # Extract message if present
-                    if 'message' in data and data['message']:
-                        msg = data['message']
-                        if msg.get('role') and msg.get('content'):
-                            # Extract content
-                            content = msg['content']
-                            if isinstance(content, list):
-                                text_parts = []
-                                for item in content:
-                                    if isinstance(item, dict) and item.get('type') == 'text':
-                                        text_parts.append(item.get('text', ''))
-                                    elif isinstance(item, str):
-                                        text_parts.append(item)
-                                content = '\n'.join(text_parts)
-                            
-                            if content:
-                                chunk_buffer.append({
-                                    'role': msg['role'],
-                                    'content': content
-                                })
-                                
-                                # Process chunk when buffer reaches MAX_CHUNK_SIZE
-                                if len(chunk_buffer) >= MAX_CHUNK_SIZE:
-                                    chunks = process_and_upload_chunk(
-                                        chunk_buffer, chunk_index, conversation_id,
-                                        created_at, metadata, collection_name, project_path
-                                    )
-                                    total_chunks += chunks
-                                    chunk_buffer = []
-                                    chunk_index += 1
-                                    
-                                    # Force garbage collection after each chunk
-                                    gc.collect()
-                                    
-                                    # Log progress
-                                    if chunk_index % 10 == 0:
-                                        logger.info(f"Processed {chunk_index} chunks from {jsonl_file.name}")
-                                    
-                except json.JSONDecodeError:
-                    logger.debug(f"Skipping invalid JSON at line {line_num}")
-                except Exception as e:
-                    logger.debug(f"Error processing line {line_num}: {e}")
-        
-        # Process remaining messages
-        if chunk_buffer:
-            chunks = process_and_upload_chunk(
-                chunk_buffer, chunk_index, conversation_id,
-                created_at, metadata, collection_name, project_path
-            )
-            total_chunks += chunks
-        
-        logger.info(f"Imported {total_chunks} chunks from {jsonl_file.name}")
-        return total_chunks
-        
-    except Exception as e:
-        logger.error(f"Failed to import {jsonl_file}: {e}")
-        return 0
-
-def load_state() -> dict:
-    """Load import state."""
-    if os.path.exists(STATE_FILE):
-        try:
-            with open(STATE_FILE, 'r') as f:
-                return json.load(f)
-        except:
-            pass
-    return {"imported_files": {}}
-
-def save_state(state: dict):
-    """Save import state."""
-    os.makedirs(os.path.dirname(STATE_FILE), exist_ok=True)
-    with open(STATE_FILE, 'w') as f:
-        json.dump(state, f, indent=2)
-
-def should_import_file(file_path: Path, state: dict) -> bool:
-    """Check if file should be imported."""
-    file_str = str(file_path)
-    if file_str in state.get("imported_files", {}):
-        file_info = state["imported_files"][file_str]
-        last_modified = file_path.stat().st_mtime
-        if file_info.get("last_modified") == last_modified:
-            logger.info(f"Skipping unchanged file: {file_path.name}")
-            return False
-    return True
-
-def update_file_state(file_path: Path, state: dict, chunks: int):
-    """Update state for imported file."""
-    file_str = str(file_path)
-    state["imported_files"][file_str] = {
-        "imported_at": datetime.now().isoformat(),
-        "last_modified": file_path.stat().st_mtime,
-        "chunks": chunks
-    }
-
-def main():
-    """Main import function."""
-    # Load state
-    state = load_state()
-    logger.info(f"Loaded state with {len(state.get('imported_files', {}))} previously imported files")
-    
-    # Find all projects
-    logs_dir = Path(os.getenv("LOGS_DIR", "/logs"))
-    project_dirs = [d for d in logs_dir.iterdir() if d.is_dir()]
-    logger.info(f"Found {len(project_dirs)} projects to import")
-    
-    total_imported = 0
-    
-    for project_dir in project_dirs:
-        # Get collection name
-        collection_name = get_collection_name(project_dir)
-        logger.info(f"Importing project: {project_dir.name} -> {collection_name}")
-        
-        # Ensure collection exists
-        ensure_collection(collection_name)
-        
-        # Find JSONL files
-        jsonl_files = sorted(project_dir.glob("*.jsonl"))
-        
-        # Limit files per cycle if specified
-        max_files = int(os.getenv("MAX_FILES_PER_CYCLE", "1000"))
-        jsonl_files = jsonl_files[:max_files]
-        
-        for jsonl_file in jsonl_files:
-            if should_import_file(jsonl_file, state):
-                chunks = stream_import_file(jsonl_file, collection_name, project_dir)
-                if chunks > 0:
-                    update_file_state(jsonl_file, state, chunks)
-                    save_state(state)
-                    total_imported += 1
-                    
-                    # Force GC after each file
-                    gc.collect()
-    
-    logger.info(f"Import complete: processed {total_imported} files")
-
-if __name__ == "__main__":
-    main()

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