claude-self-reflect 3.2.3 → 3.3.0

package/mcp-server/src/project_resolver.py

@@ -6,11 +6,21 @@ Handles mapping between user-friendly names and internal collection names.
 import hashlib
 import logging
 import re
+import sys
 from pathlib import Path
 from typing import List, Dict, Optional, Set
 from time import time
 from qdrant_client import QdrantClient
 
+# Import from shared module for consistent normalization
+sys.path.insert(0, str(Path(__file__).parent.parent.parent))
+try:
+    from shared.normalization import normalize_project_name
+except ImportError:
+    # Fall back to creating local version if shared module not found
+    logging.warning("Could not import shared normalization module")
+    normalize_project_name = None
+
 logger = logging.getLogger(__name__)
 
 # Project discovery markers - common parent directories that indicate project roots
@@ -59,6 +69,11 @@ class ProjectResolver:
         Returns:
             List of collection names that match the project
         """
+        # Special case: 'all' returns all conversation collections
+        if user_project_name == 'all':
+            collection_names = self._get_collection_names()
+            return collection_names  # Return all conv_ collections
+        
         if user_project_name in self._cache:
             # Check if cache entry is still valid
             if time() - self._cache_ttl.get(user_project_name, 0) < self._cache_duration:
@@ -244,59 +259,31 @@ class ProjectResolver:
     def _normalize_project_name(self, project_path: str) -> str:
         """
         Normalize project name for consistent hashing.
-        Extracts the actual project name from various path formats.
+        Uses the shared normalization module to ensure consistency
+        with import scripts.
         """
+        # Use the shared normalization function if available
+        if normalize_project_name:
+            return normalize_project_name(project_path)
+        
+        # Fallback implementation - EXACT copy of shared module
         if not project_path:
             return ""
         
-        # Remove trailing slashes
-        project_path = project_path.rstrip('/')
+        path = Path(project_path.rstrip('/'))
         
-        # Handle Claude logs format (starts with dash)
-        if project_path.startswith('-'):
-            # Split on dashes but don't convert to path separators
-            # This preserves project names that contain dashes
-            path_str = project_path[1:]  # Remove leading dash
-            path_parts = path_str.split('-')  # Split on dashes, not path separators
-            
-            # Look for common project parent directories
-            project_parents = {'projects', 'code', 'Code', 'repos', 'repositories', 
-                              'dev', 'Development', 'work', 'src', 'github'}
-            
-            # Find the project name after a known parent directory
-            for i, part in enumerate(path_parts):
-                if part.lower() in project_parents and i + 1 < len(path_parts):
-                    # Return everything after the parent directory
-                    remaining = path_parts[i + 1:]
-                    
-                    # Use segment-based approach for complex paths
-                    # Return the most likely project name from remaining segments
-                    if remaining:
-                        # If it's a single segment, return it
-                        if len(remaining) == 1:
-                            return remaining[0]
-                        # For multiple segments, look for project-like patterns
-                        for r in remaining:
-                            r_lower = r.lower()
-                            # Prioritize segments with project indicators
-                            if any(ind in r_lower for ind in ['app', 'service', 'project', 'api', 'client']):
-                                return r
-                    
-                    # Otherwise join remaining parts
-                    return '-'.join(remaining)
-            
-            # Fallback: use the last component
-            return path_parts[-1] if path_parts else project_path
+        # Extract the final directory name
+        final_component = path.name
         
-        # For regular paths or simple names
-        path_obj = Path(project_path)
+        # If it's Claude's dash-separated format, extract project name
+        if final_component.startswith('-') and 'projects' in final_component:
+            # Find the last occurrence of 'projects-' to handle edge cases
+            idx = final_component.rfind('projects-')
+            if idx != -1:
+                return final_component[idx + len('projects-'):]
         
-        # If it's already a simple name, return it
-        if '/' not in project_path and '\\' not in project_path:
-            return project_path
-            
-        # Otherwise extract from path
-        return path_obj.name
+        # For regular paths, just return the directory name
+        return final_component if final_component else path.parent.name
     
     def _project_matches(self, stored_project: str, target_project: str) -> bool:
         """

package/mcp-server/src/reflection_tools.py

@@ -0,0 +1,206 @@
+"""Reflection tools for Claude Self Reflect MCP server."""
+
+import os
+import json
+import hashlib
+import logging
+from typing import Optional, List, Dict, Any
+from datetime import datetime, timezone
+from pathlib import Path
+import uuid
+
+from fastmcp import Context
+from pydantic import Field
+from qdrant_client import AsyncQdrantClient
+from qdrant_client.models import PointStruct, VectorParams, Distance
+
+logger = logging.getLogger(__name__)
+
+
+class ReflectionTools:
+    """Handles reflection storage and conversation retrieval operations."""
+    
+    def __init__(
+        self,
+        qdrant_client: AsyncQdrantClient,
+        qdrant_url: str,
+        get_embedding_manager,
+        normalize_project_name
+    ):
+        """Initialize reflection tools with dependencies."""
+        self.qdrant_client = qdrant_client
+        self.qdrant_url = qdrant_url
+        self.get_embedding_manager = get_embedding_manager
+        self.normalize_project_name = normalize_project_name
+
+    async def store_reflection(
+        self,
+        ctx: Context,
+        content: str,
+        tags: List[str] = []
+    ) -> str:
+        """Store an important insight or reflection for future reference."""
+
+        await ctx.debug(f"Storing reflection with {len(tags)} tags")
+
+        try:
+            # Determine collection name based on embedding type
+            embedding_manager = self.get_embedding_manager()
+            embedding_type = "local" if embedding_manager.prefer_local else "voyage"
+            collection_name = f"reflections_{embedding_type}"
+
+            # Ensure reflections collection exists
+            try:
+                await self.qdrant_client.get_collection(collection_name)
+                await ctx.debug(f"Using existing {collection_name} collection")
+            except Exception:
+                # Collection doesn't exist, create it
+                await ctx.debug(f"Creating {collection_name} collection")
+
+                # Determine embedding dimensions
+                embedding_dim = embedding_manager.get_vector_dimension()
+
+                await self.qdrant_client.create_collection(
+                    collection_name=collection_name,
+                    vectors_config=VectorParams(
+                        size=embedding_dim,
+                        distance=Distance.COSINE
+                    )
+                )
+            
+            # Generate embedding for the reflection
+            embedding_manager = self.get_embedding_manager()
+            embedding = await embedding_manager.generate_embedding(content)
+            
+            # Create unique ID
+            reflection_id = hashlib.md5(f"{content}{datetime.now().isoformat()}".encode()).hexdigest()
+            
+            # Prepare metadata
+            metadata = {
+                "content": content,
+                "tags": tags,
+                "timestamp": datetime.now(timezone.utc).isoformat(),
+                "type": "reflection"
+            }
+            
+            # Store in Qdrant
+            await self.qdrant_client.upsert(
+                collection_name=collection_name,
+                points=[
+                    PointStruct(
+                        id=reflection_id,
+                        vector=embedding,
+                        payload=metadata
+                    )
+                ]
+            )
+            
+            await ctx.debug(f"Stored reflection with ID {reflection_id}")
+            
+            return f"""Reflection stored successfully.
+ID: {reflection_id}
+Tags: {', '.join(tags) if tags else 'none'}
+Timestamp: {metadata['timestamp']}"""
+            
+        except Exception as e:
+            logger.error(f"Failed to store reflection: {e}", exc_info=True)
+            return f"Failed to store reflection: {str(e)}"
+
+    async def get_full_conversation(
+        self,
+        ctx: Context,
+        conversation_id: str,
+        project: Optional[str] = None
+    ) -> str:
+        """Get the full JSONL conversation file path for a conversation ID.
+        This allows agents to read complete conversations instead of truncated excerpts."""
+        
+        await ctx.debug(f"Getting full conversation for ID: {conversation_id}, project: {project}")
+        
+        try:
+            # Base path for conversations
+            base_path = Path.home() / '.claude' / 'projects'
+            
+            # If project is specified, try to find it in that project
+            if project:
+                # Normalize project name for path matching
+                project_normalized = self.normalize_project_name(project)
+                
+                # Look for project directories that match
+                for project_dir in base_path.glob('*'):
+                    if project_normalized in project_dir.name.lower():
+                        # Look for JSONL files in this project
+                        for jsonl_file in project_dir.glob('*.jsonl'):
+                            # Check if filename matches conversation_id (with or without .jsonl)
+                            if conversation_id in jsonl_file.stem or conversation_id == jsonl_file.stem:
+                                await ctx.debug(f"Found conversation by filename in {jsonl_file}")
+                                return f"""<conversation_file>
+<conversation_id>{conversation_id}</conversation_id>
+<file_path>{str(jsonl_file)}</file_path>
+<project>{project_dir.name}</project>
+<message>Use the Read tool with this file path to read the complete conversation.</message>
+</conversation_file>"""
+            
+            # If not found in specific project or no project specified, search all
+            await ctx.debug("Searching all projects for conversation")
+            for project_dir in base_path.glob('*'):
+                for jsonl_file in project_dir.glob('*.jsonl'):
+                    # Check if filename matches conversation_id (with or without .jsonl)
+                    if conversation_id in jsonl_file.stem or conversation_id == jsonl_file.stem:
+                        await ctx.debug(f"Found conversation by filename in {jsonl_file}")
+                        return f"""<conversation_file>
+<conversation_id>{conversation_id}</conversation_id>
+<file_path>{str(jsonl_file)}</file_path>
+<project>{project_dir.name}</project>
+<message>Use the Read tool with this file path to read the complete conversation.</message>
+</conversation_file>"""
+            
+            # Not found
+            return f"""<conversation_file>
+<error>Conversation ID '{conversation_id}' not found in any project.</error>
+<suggestion>The conversation may not have been imported yet, or the ID may be incorrect.</suggestion>
+</conversation_file>"""
+            
+        except Exception as e:
+            logger.error(f"Failed to get conversation file: {e}", exc_info=True)
+            return f"""<conversation_file>
+<error>Failed to locate conversation: {str(e)}</error>
+</conversation_file>"""
+
+
+def register_reflection_tools(
+    mcp,
+    qdrant_client: AsyncQdrantClient,
+    qdrant_url: str,
+    get_embedding_manager,
+    normalize_project_name
+):
+    """Register reflection tools with the MCP server."""
+    
+    tools = ReflectionTools(
+        qdrant_client,
+        qdrant_url,
+        get_embedding_manager,
+        normalize_project_name
+    )
+    
+    @mcp.tool()
+    async def store_reflection(
+        ctx: Context,
+        content: str = Field(description="The insight or reflection to store"),
+        tags: List[str] = Field(default=[], description="Tags to categorize this reflection")
+    ) -> str:
+        """Store an important insight or reflection for future reference."""
+        return await tools.store_reflection(ctx, content, tags)
+    
+    @mcp.tool()
+    async def get_full_conversation(
+        ctx: Context,
+        conversation_id: str = Field(description="The conversation ID from search results (cid)"),
+        project: Optional[str] = Field(default=None, description="Optional project name to help locate the file")
+    ) -> str:
+        """Get the full JSONL conversation file path for a conversation ID.
+        This allows agents to read complete conversations instead of truncated excerpts."""
+        return await tools.get_full_conversation(ctx, conversation_id, project)
+    
+    logger.info("Reflection tools registered successfully")

package/mcp-server/src/rich_formatting.py

@@ -0,0 +1,196 @@
+"""Rich formatting for search results with emojis and enhanced display."""
+
+import json
+import time
+from datetime import datetime, timezone
+from typing import List, Dict, Any, Optional
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+def format_search_results_rich(
+    results: List[Dict],
+    query: str,
+    target_project: str,
+    collections_searched: int,
+    timing_info: Dict[str, float],
+    start_time: float,
+    brief: bool = False,
+    include_raw: bool = False,
+    indexing_status: Optional[Dict] = None
+) -> str:
+    """Format search results with rich formatting including emojis and performance metrics."""
+
+    # Initialize upfront summary
+    upfront_summary = ""
+
+    # Show result summary with emojis
+    if results:
+        score_info = "high" if results[0]['score'] >= 0.85 else "good" if results[0]['score'] >= 0.75 else "partial"
+        upfront_summary += f"🎯 RESULTS: {len(results)} matches ({score_info} relevance, top score: {results[0]['score']:.3f})\n"
+
+        # Show performance metrics
+        total_time = time.time() - start_time
+        indexing_info = ""
+        if indexing_status and indexing_status.get("percentage", 100) < 100.0:
+            indexing_info = f" | 📊 {indexing_status['indexed_conversations']}/{indexing_status['total_conversations']} indexed"
+        upfront_summary += f"⚡ PERFORMANCE: {int(total_time * 1000)}ms ({collections_searched} collections searched{indexing_info})\n"
+    else:
+        upfront_summary += f"❌ NO RESULTS: No conversations found matching '{query}'\n"
+
+    # Start XML format with upfront summary
+    result_text = upfront_summary + "\n<search>\n"
+
+    # Add indexing status if not fully baselined
+    if indexing_status and indexing_status.get("percentage", 100) < 95.0:
+        result_text += f'  <info status="indexing" progress="{indexing_status["percentage"]:.1f}%" backlog="{indexing_status.get("backlog_count", 0)}">\n'
+        result_text += f'    <message>📊 Indexing: {indexing_status["indexed_conversations"]}/{indexing_status["total_conversations"]} conversations ({indexing_status["percentage"]:.1f}% complete)</message>\n'
+        result_text += f"  </info>\n"
+
+    # Add high-level result summary
+    if results:
+        # Count time-based results
+        now = datetime.now(timezone.utc)
+        today_count = 0
+        yesterday_count = 0
+        week_count = 0
+
+        for result in results:
+            timestamp_str = result.get('timestamp', '')
+            if timestamp_str:
+                try:
+                    # Clean timestamp
+                    timestamp_clean = timestamp_str.replace('Z', '+00:00') if timestamp_str.endswith('Z') else timestamp_str
+                    timestamp_dt = datetime.fromisoformat(timestamp_clean)
+                    if timestamp_dt.tzinfo is None:
+                        timestamp_dt = timestamp_dt.replace(tzinfo=timezone.utc)
+
+                    days_ago = (now - timestamp_dt).days
+                    if days_ago == 0:
+                        today_count += 1
+                    elif days_ago == 1:
+                        yesterday_count += 1
+                    if days_ago <= 7:
+                        week_count += 1
+                except:
+                    pass
+
+        # Compact summary with key info
+        time_info = ""
+        if today_count > 0:
+            time_info = f"{today_count} today"
+        elif yesterday_count > 0:
+            time_info = f"{yesterday_count} yesterday"
+        elif week_count > 0:
+            time_info = f"{week_count} this week"
+        else:
+            time_info = "older results"
+
+        score_info = "high" if results[0]['score'] >= 0.85 else "good" if results[0]['score'] >= 0.75 else "partial"
+
+        result_text += f'  <summary count="{len(results)}" relevance="{score_info}" recency="{time_info}" top-score="{results[0]["score"]:.3f}">\n'
+
+        # Short preview of top result
+        top_excerpt = results[0].get('excerpt', results[0].get('content', ''))[:100].strip()
+        if '...' not in top_excerpt:
+            top_excerpt += "..."
+        result_text += f'    <preview>{top_excerpt}</preview>\n'
+        result_text += f"  </summary>\n"
+    else:
+        result_text += f"  <result-summary>\n"
+        result_text += f"    <headline>No matches found</headline>\n"
+        result_text += f"    <relevance>No conversations matched your query</relevance>\n"
+        result_text += f"  </result-summary>\n"
+
+    # Add metadata
+    result_text += f"  <meta>\n"
+    result_text += f"    <q>{query}</q>\n"
+    result_text += f"    <scope>{target_project if target_project != 'all' else 'all'}</scope>\n"
+    result_text += f"    <count>{len(results)}</count>\n"
+    if results:
+        result_text += f"    <range>{results[-1]['score']:.3f}-{results[0]['score']:.3f}</range>\n"
+
+    # Add performance metadata
+    total_time = time.time() - start_time
+    result_text += f"    <perf>\n"
+    result_text += f"      <ttl>{int(total_time * 1000)}</ttl>\n"
+    result_text += f"      <emb>{int((timing_info.get('embedding_end', 0) - timing_info.get('embedding_start', 0)) * 1000)}</emb>\n"
+    result_text += f"      <srch>{int((timing_info.get('search_all_end', 0) - timing_info.get('search_all_start', 0)) * 1000)}</srch>\n"
+    result_text += f"      <cols>{collections_searched}</cols>\n"
+    result_text += f"    </perf>\n"
+    result_text += f"  </meta>\n"
+
+    # Add individual results
+    result_text += "  <results>\n"
+    for i, result in enumerate(results):
+        result_text += f'    <r rank="{i+1}">\n'
+        result_text += f"      <s>{result['score']:.3f}</s>\n"
+        result_text += f"      <p>{result.get('project_name', 'unknown')}</p>\n"
+
+        # Calculate relative time
+        timestamp_str = result.get('timestamp', '')
+        if timestamp_str:
+            try:
+                timestamp_clean = timestamp_str.replace('Z', '+00:00') if timestamp_str.endswith('Z') else timestamp_str
+                timestamp_dt = datetime.fromisoformat(timestamp_clean)
+                if timestamp_dt.tzinfo is None:
+                    timestamp_dt = timestamp_dt.replace(tzinfo=timezone.utc)
+                now = datetime.now(timezone.utc)
+                days_ago = (now - timestamp_dt).days
+                if days_ago == 0:
+                    time_str = "today"
+                elif days_ago == 1:
+                    time_str = "yesterday"
+                else:
+                    time_str = f"{days_ago}d"
+                result_text += f"      <t>{time_str}</t>\n"
+            except:
+                result_text += f"      <t>unknown</t>\n"
+
+        # Get excerpt/content
+        excerpt = result.get('excerpt', result.get('content', ''))
+
+        if not brief and excerpt:
+            # Extract title from first line of excerpt
+            excerpt_lines = excerpt.split('\n')
+            title = excerpt_lines[0][:80] + "..." if len(excerpt_lines[0]) > 80 else excerpt_lines[0]
+            result_text += f"      <title>{title}</title>\n"
+
+            # Key finding - summarize the main point
+            key_finding = excerpt[:100] + "..." if len(excerpt) > 100 else excerpt
+            result_text += f"      <key-finding>{key_finding.strip()}</key-finding>\n"
+
+        # Always include excerpt
+        if brief:
+            brief_excerpt = excerpt[:100] + "..." if len(excerpt) > 100 else excerpt
+            result_text += f"      <excerpt>{brief_excerpt.strip()}</excerpt>\n"
+        else:
+            result_text += f"      <excerpt><![CDATA[{excerpt}]]></excerpt>\n"
+
+        # Add conversation ID if present
+        if result.get('conversation_id'):
+            result_text += f"      <cid>{result['conversation_id']}</cid>\n"
+
+        # Include raw data if requested
+        if include_raw and result.get('raw_payload'):
+            result_text += "      <raw>\n"
+            payload = result['raw_payload']
+            result_text += f"        <txt><![CDATA[{payload.get('text', '')}]]></txt>\n"
+            result_text += f"        <id>{result.get('id', '')}</id>\n"
+            result_text += "      </raw>\n"
+
+        # Add metadata fields if present
+        if result.get('files_analyzed'):
+            result_text += f"      <files>{', '.join(result['files_analyzed'][:5])}</files>\n"
+        if result.get('tools_used'):
+            result_text += f"      <tools>{', '.join(result['tools_used'][:5])}</tools>\n"
+        if result.get('concepts'):
+            result_text += f"      <concepts>{', '.join(result['concepts'][:5])}</concepts>\n"
+
+        result_text += "    </r>\n"
+
+    result_text += "  </results>\n"
+    result_text += "</search>\n"
+
+    return result_text