claude-self-reflect 2.7.2 → 2.7.4

package/docker-compose.yaml

@@ -42,6 +42,7 @@ services:
     environment:
       - QDRANT_URL=http://qdrant:6333
       - STATE_FILE=/config/imported-files.json
+      - LOGS_DIR=/logs
       - OPENAI_API_KEY=${OPENAI_API_KEY:-}
       - VOYAGE_API_KEY=${VOYAGE_API_KEY:-}
       - VOYAGE_KEY=${VOYAGE_KEY:-}

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.4",
   "description": "Give Claude perfect memory of all your conversations - Installation wizard for Python MCP server",
   "keywords": [
     "claude",

package/scripts/delta-metadata-update-safe.py

@@ -24,7 +24,8 @@ from qdrant_client.models import Filter, FieldCondition, MatchValue
 # Configuration
 QDRANT_URL = os.getenv("QDRANT_URL", "http://localhost:6333")
 LOGS_DIR = os.getenv("LOGS_DIR", os.path.expanduser("~/.claude/projects"))
-STATE_FILE = os.getenv("STATE_FILE", "./config/delta-update-state.json")
+# Use /config path if running in Docker, otherwise use ./config
+STATE_FILE = os.getenv("STATE_FILE", "/config/delta-update-state.json" if os.path.exists("/config") else "./config/delta-update-state.json")
 PREFER_LOCAL_EMBEDDINGS = os.getenv("PREFER_LOCAL_EMBEDDINGS", "true").lower() == "true"
 DRY_RUN = os.getenv("DRY_RUN", "false").lower() == "true"
 DAYS_TO_UPDATE = int(os.getenv("DAYS_TO_UPDATE", "7"))
@@ -432,7 +433,7 @@ async def main_async():
     logger.info("=== Delta Update Complete ===")
     logger.info(f"Successfully updated: {success_count} conversations")
     logger.info(f"Failed: {failed_count} conversations")
-    logger.info(f"Total conversations in state: {len(state['updated_conversations'])}")
+    logger.info(f"Total conversations in state: {len(state.get('updated_conversations', {}))}")
 
 def main():
     """Entry point."""

package/scripts/import-conversations-unified.py

@@ -57,7 +57,9 @@ else:
 
 def normalize_project_name(project_name: str) -> str:
     """Normalize project name for consistency."""
-    return project_name.replace("-Users-ramakrishnanannaswamy-projects-", "").replace("-", "_").lower()
+    # For compatibility with delta-metadata-update, just use the project name as-is
+    # This ensures collection names match between import and delta update scripts
+    return project_name
 
 def get_collection_name(project_path: Path) -> str:
     """Generate collection name from project path."""

package/scripts/import-old-format.py

@@ -0,0 +1,171 @@
+#!/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()