claude-self-reflect 3.2.4 → 3.3.0

package/scripts/add-timestamp-indexes.py

@@ -0,0 +1,134 @@
+#!/usr/bin/env python3
+"""Add timestamp indexes to all collections for OrderBy support."""
+
+import asyncio
+import os
+from pathlib import Path
+import sys
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from qdrant_client import AsyncQdrantClient
+from qdrant_client.models import PayloadSchemaType, OrderBy
+
+QDRANT_URL = os.getenv("QDRANT_URL", "http://localhost:6333")
+
+async def add_timestamp_indexes():
+    """Add timestamp indexes to all collections that need them."""
+    client = AsyncQdrantClient(url=QDRANT_URL)
+    
+    print("Adding timestamp indexes for temporal query support...")
+    print("="*60)
+    
+    # Get all collections
+    collections = await client.get_collections()
+    total = len(collections.collections)
+    print(f"Found {total} collections")
+    
+    success_count = 0
+    skip_count = 0
+    error_count = 0
+    
+    for i, col in enumerate(collections.collections, 1):
+        col_name = col.name
+        print(f"\n[{i}/{total}] Processing {col_name}...")
+        
+        try:
+            # Check if collection has points
+            info = await client.get_collection(col_name)
+            if info.points_count == 0:
+                print(f"  ⏭️  Skipped (empty collection)")
+                skip_count += 1
+                continue
+            
+            # Check if timestamp field exists
+            points, _ = await client.scroll(
+                collection_name=col_name,
+                limit=1,
+                with_payload=["timestamp"]
+            )
+            
+            if not points or not points[0].payload.get('timestamp'):
+                print(f"  ⏭️  Skipped (no timestamp field)")
+                skip_count += 1
+                continue
+            
+            # Try to use OrderBy to check if index exists
+            try:
+                await client.scroll(
+                    collection_name=col_name,
+                    order_by=OrderBy(key="timestamp", direction="desc"),
+                    limit=1
+                )
+                print(f"  ✅ Already has timestamp index")
+                skip_count += 1
+            except Exception as e:
+                if "No range index" in str(e):
+                    # Need to create index
+                    print(f"  🔧 Creating timestamp index...")
+                    try:
+                        await client.create_payload_index(
+                            collection_name=col_name,
+                            field_name="timestamp",
+                            field_schema=PayloadSchemaType.DATETIME
+                        )
+                        print(f"  ✅ Index created successfully")
+                        success_count += 1
+                    except Exception as create_error:
+                        print(f"  ❌ Failed to create index: {create_error}")
+                        error_count += 1
+                else:
+                    print(f"  ⚠️  Unexpected error: {e}")
+                    error_count += 1
+                    
+        except Exception as e:
+            print(f"  ❌ Error: {e}")
+            error_count += 1
+    
+    print("\n" + "="*60)
+    print("SUMMARY")
+    print("="*60)
+    print(f"✅ Indexes created: {success_count}")
+    print(f"⏭️  Skipped: {skip_count}")
+    print(f"❌ Errors: {error_count}")
+    print(f"📊 Total collections: {total}")
+    
+    # Verify temporal queries work
+    if success_count > 0:
+        print("\n" + "="*60)
+        print("VERIFYING TEMPORAL QUERIES")
+        print("="*60)
+        
+        # Find a collection with data to test
+        test_collection = None
+        for col in collections.collections:
+            try:
+                info = await client.get_collection(col.name)
+                if info.points_count > 100:  # Find one with decent amount of data
+                    test_collection = col.name
+                    break
+            except:
+                pass
+        
+        if test_collection:
+            print(f"Testing on {test_collection}...")
+            try:
+                # Test OrderBy
+                results, _ = await client.scroll(
+                    collection_name=test_collection,
+                    order_by=OrderBy(key="timestamp", direction="desc"),
+                    limit=3,
+                    with_payload=["timestamp", "text"]
+                )
+                
+                print(f"✅ OrderBy works! Found {len(results)} recent conversations:")
+                for r in results:
+                    ts = r.payload.get('timestamp', 'N/A')
+                    text = r.payload.get('text', '')[:60] + '...'
+                    print(f"  - {ts}: {text}")
+                    
+            except Exception as e:
+                print(f"❌ OrderBy test failed: {e}")
+
+if __name__ == "__main__":
+    asyncio.run(add_timestamp_indexes())

package/scripts/check-collections.py

@@ -0,0 +1,29 @@
+#!/usr/bin/env python3
+"""Check Qdrant collections."""
+
+import os
+from qdrant_client import QdrantClient
+
+# Configuration
+QDRANT_URL = os.getenv("QDRANT_URL", "http://localhost:6333")
+
+def main():
+    """List all collections."""
+    client = QdrantClient(url=QDRANT_URL)
+    
+    # Get all collections
+    collections = client.get_collections()
+    
+    print("Qdrant Collections:")
+    print("-" * 60)
+    
+    voyage_collections = []
+    for collection in collections.collections:
+        print(f"- {collection.name}")
+        if collection.name.endswith("_voyage"):
+            voyage_collections.append(collection.name)
+    
+    print(f"\nFound {len(voyage_collections)} Voyage collections")
+
+if __name__ == "__main__":
+    main()

package/scripts/debug-august-parsing.py

@@ -0,0 +1,76 @@
+#!/usr/bin/env python3
+"""Debug why August files aren't parsing properly."""
+
+import json
+import sys
+
+def parse_jsonl_file(file_path):
+    """Parse JSONL file and extract messages."""
+    messages = []
+    
+    with open(file_path, '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 summary messages
+                if data.get('type') == 'summary':
+                    print(f"Line {line_num}: Skipping summary")
+                    continue
+                
+                # Handle messages with type user/assistant at root level
+                if data.get('type') in ['user', 'assistant']:
+                    if 'message' in data and data['message']:
+                        msg = data['message']
+                        if msg.get('role') and msg.get('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:
+                                messages.append({
+                                    'role': msg['role'],
+                                    'content': content[:200] + '...' if len(content) > 200 else content,
+                                    'line': line_num
+                                })
+                                print(f"Line {line_num}: Extracted {msg['role']} message ({len(content)} chars)")
+                            else:
+                                print(f"Line {line_num}: Empty content for {msg['role']}")
+                        else:
+                            print(f"Line {line_num}: Missing role or content in message field")
+                    else:
+                        print(f"Line {line_num}: No message field for type={data.get('type')}")
+                else:
+                    print(f"Line {line_num}: Unknown type={data.get('type')}")
+                    
+            except Exception as e:
+                print(f"Line {line_num}: Parse error - {e}")
+    
+    return messages
+
+if __name__ == "__main__":
+    file_path = "/Users/ramakrishnanannaswamy/.claude/projects/-Users-ramakrishnanannaswamy-projects-claude-self-reflect/7b3354ed-d6d2-4eab-b328-1fced4bb63bb.jsonl"
+    
+    print(f"Parsing: {file_path}")
+    print("=" * 60)
+    
+    messages = parse_jsonl_file(file_path)
+    
+    print("\n" + "=" * 60)
+    print(f"Total messages extracted: {len(messages)}")
+    
+    if messages:
+        print("\nFirst 5 messages:")
+        for i, msg in enumerate(messages[:5]):
+            print(f"\n{i+1}. Line {msg['line']}: {msg['role']}")
+            print(f"   Content: {msg['content'][:100]}...")

package/scripts/debug-import-single.py

@@ -0,0 +1,91 @@
+#!/usr/bin/env python3
+"""
+Debug import of a single file with summary messages
+"""
+
+import json
+from pathlib import Path
+
+# Target file
+test_file = Path.home() / '.claude/projects/-Users-ramakrishnanannaswamy-projects-claude-self-reflect/c072a61e-aebb-4c85-960b-c5ffeafa7115.jsonl'
+
+print(f"Analyzing: {test_file.name}\n")
+
+# Read and analyze the file
+all_messages = []
+summary_count = 0
+user_count = 0
+assistant_count = 0
+other_count = 0
+
+with open(test_file, 'r') as f:
+    for i, line in enumerate(f, 1):
+        if line.strip():
+            try:
+                data = json.loads(line)
+                msg_type = data.get('type', 'unknown')
+                
+                print(f"Line {i}: type={msg_type}", end="")
+                
+                # Check what would be extracted
+                if msg_type == 'summary':
+                    summary_count += 1
+                    print(f" -> SKIPPED (summary)")
+                    continue
+                
+                # Check for messages with type user/assistant
+                if msg_type in ['user', 'assistant']:
+                    if 'message' in data and data['message']:
+                        msg = data['message']
+                        if msg.get('role') and msg.get('content'):
+                            all_messages.append(msg)
+                            if msg_type == 'user':
+                                user_count += 1
+                            else:
+                                assistant_count += 1
+                            
+                            # Extract a preview of content
+                            content = msg.get('content', '')
+                            if isinstance(content, list) and len(content) > 0:
+                                first_item = content[0]
+                                if isinstance(first_item, dict):
+                                    preview = str(first_item.get('content', first_item.get('text', '')))[:50]
+                                else:
+                                    preview = str(first_item)[:50]
+                            else:
+                                preview = str(content)[:50]
+                            
+                            print(f" -> EXTRACTED (role={msg['role']}, preview: {preview}...)")
+                        else:
+                            print(f" -> NO role/content in message")
+                    else:
+                        print(f" -> NO message field")
+                else:
+                    other_count += 1
+                    print(f" -> OTHER TYPE")
+                    
+            except json.JSONDecodeError as e:
+                print(f"Line {i}: INVALID JSON - {e}")
+
+print(f"\n=== SUMMARY ===")
+print(f"Total lines: {i}")
+print(f"Summaries (skipped): {summary_count}")
+print(f"User messages: {user_count}")
+print(f"Assistant messages: {assistant_count}")
+print(f"Other types: {other_count}")
+print(f"Total extracted messages: {len(all_messages)}")
+
+# Check for Memento content
+memento_found = False
+for msg in all_messages:
+    content = str(msg.get('content', ''))
+    if 'memento' in content.lower():
+        memento_found = True
+        break
+
+print(f"\nMemento content found in messages: {memento_found}")
+
+if len(all_messages) > 0:
+    print(f"\n✅ File SHOULD be importable with {len(all_messages)} messages")
+else:
+    print(f"\n❌ File would result in ZERO messages imported")

package/scripts/debug-project-resolver.py

@@ -0,0 +1,82 @@
+#!/usr/bin/env python3
+"""Test ProjectResolver to see if it's finding collections correctly."""
+
+import sys
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).parent.parent / 'mcp-server' / 'src'))
+
+from qdrant_client import QdrantClient
+from project_resolver import ProjectResolver
+
+# Connect to Qdrant
+client = QdrantClient(url="http://localhost:6333")
+
+# Create resolver
+resolver = ProjectResolver(client)
+
+# Test projects
+test_projects = [
+    "claude-self-reflect",
+    "memento",  
+    "cc-enhance",
+    "all"
+]
+
+print("=== Testing ProjectResolver ===\n")
+
+for project in test_projects:
+    print(f"Project: '{project}'")
+    collections = resolver.find_collections_for_project(project)
+    print(f"  Found {len(collections)} collections")
+    
+    if collections:
+        # Show first 3 collections
+        for coll in collections[:3]:
+            try:
+                info = client.get_collection(coll)
+                suffix = "_local" if coll.endswith("_local") else "_voyage"
+                print(f"    - {coll}: {info.points_count} points ({suffix})")
+            except:
+                print(f"    - {coll}: <error getting info>")
+    else:
+        print("    - No collections found!")
+    print()
+
+# Also test the normalization directly
+print("\n=== Testing Direct Normalization ===")
+from shared.normalization import normalize_project_name
+import hashlib
+
+test_paths = [
+    "/Users/ramakrishnanannaswamy/projects/claude-self-reflect",
+    "/Users/ramakrishnanannaswamy/projects/memento",
+    "/Users/ramakrishnanannaswamy/projects/cc-enhance"
+]
+
+for path in test_paths:
+    normalized = normalize_project_name(path)
+    name_hash = hashlib.md5(normalized.encode()).hexdigest()[:8]
+    collection_local = f"conv_{name_hash}_local"
+    collection_voyage = f"conv_{name_hash}_voyage"
+    
+    print(f"Path: {path}")
+    print(f"  Normalized: {normalized}")
+    print(f"  Hash: {name_hash}")
+    print(f"  Expected collections:")
+    print(f"    - {collection_local}")
+    print(f"    - {collection_voyage}")
+    
+    # Check if these exist
+    all_collections = [c.name for c in client.get_collections().collections]
+    if collection_local in all_collections:
+        info = client.get_collection(collection_local)
+        print(f"    ✓ {collection_local} exists with {info.points_count} points")
+    else:
+        print(f"    ✗ {collection_local} not found")
+    
+    if collection_voyage in all_collections:
+        info = client.get_collection(collection_voyage)
+        print(f"    ✓ {collection_voyage} exists with {info.points_count} points")
+    else:
+        print(f"    ✗ {collection_voyage} not found")
+    print()

package/scripts/debug-temporal-tools.py

@@ -0,0 +1,135 @@
+#!/usr/bin/env python3
+"""
+Debug script for testing temporal tools in Claude Self Reflect.
+This script directly tests the temporal tools that should be available via MCP.
+"""
+
+import os
+import sys
+import asyncio
+import json
+import traceback
+from pathlib import Path
+
+# Add the mcp-server source to Python path
+sys.path.append(str(Path(__file__).parent.parent / "mcp-server" / "src"))
+
+os.environ["QDRANT_URL"] = "http://localhost:6333"
+
+async def test_temporal_tools():
+    """Test all temporal tools."""
+    print("=== TEMPORAL TOOLS DEBUG SCRIPT ===")
+    
+    try:
+        # Import required modules
+        from server import (
+            get_recent_work, search_by_recency, get_timeline,
+            get_all_collections, QDRANT_URL
+        )
+        from fastmcp import Context
+        
+        print(f"✅ Successfully imported temporal tools")
+        print(f"✅ Qdrant URL: {QDRANT_URL}")
+        
+        # Check if Qdrant is available
+        collections = await get_all_collections()
+        print(f"✅ Found {len(collections)} collections: {collections[:5]}...")
+        
+        # Create a mock context for testing
+        class MockContext(Context):
+            def __init__(self):
+                pass
+            async def debug(self, message):
+                print(f"DEBUG: {message}")
+            async def error(self, message):
+                print(f"ERROR: {message}")
+        
+        ctx = MockContext()
+        
+        # Test 1: get_recent_work with default parameters
+        print("\n--- Test 1: get_recent_work (default) ---")
+        try:
+            result = await get_recent_work(ctx)
+            print(f"✅ get_recent_work succeeded")
+            print(f"Result length: {len(result) if result else 0} characters")
+            if result and len(result) < 500:
+                print(f"Result: {result}")
+        except Exception as e:
+            print(f"❌ get_recent_work failed: {e}")
+            traceback.print_exc()
+        
+        # Test 2: get_recent_work with project='all'
+        print("\n--- Test 2: get_recent_work (project=all) ---")
+        try:
+            result = await get_recent_work(ctx, project="all", limit=5)
+            print(f"✅ get_recent_work (project=all) succeeded")
+            print(f"Result length: {len(result) if result else 0} characters")
+        except Exception as e:
+            print(f"❌ get_recent_work (project=all) failed: {e}")
+            traceback.print_exc()
+        
+        # Test 3: get_recent_work with different group_by options
+        for group_by in ["conversation", "day", "session"]:
+            print(f"\n--- Test 3.{group_by}: get_recent_work (group_by={group_by}) ---")
+            try:
+                result = await get_recent_work(ctx, limit=3, group_by=group_by)
+                print(f"✅ get_recent_work (group_by={group_by}) succeeded")
+                print(f"Result length: {len(result) if result else 0} characters")
+            except Exception as e:
+                print(f"❌ get_recent_work (group_by={group_by}) failed: {e}")
+                traceback.print_exc()
+        
+        # Test 4: search_by_recency with time_range
+        print("\n--- Test 4: search_by_recency (time_range) ---")
+        try:
+            result = await search_by_recency(
+                ctx,
+                query="testing debugging",
+                time_range="last week",
+                limit=5
+            )
+            print(f"✅ search_by_recency (time_range) succeeded")
+            print(f"Result length: {len(result) if result else 0} characters")
+        except Exception as e:
+            print(f"❌ search_by_recency (time_range) failed: {e}")
+            traceback.print_exc()
+        
+        # Test 5: search_by_recency with since/until
+        print("\n--- Test 5: search_by_recency (since/until) ---")
+        try:
+            result = await search_by_recency(
+                ctx,
+                query="python script",
+                since="yesterday",
+                limit=3
+            )
+            print(f"✅ search_by_recency (since/until) succeeded")  
+            print(f"Result length: {len(result) if result else 0} characters")
+        except Exception as e:
+            print(f"❌ search_by_recency (since/until) failed: {e}")
+            traceback.print_exc()
+        
+        # Test 6: get_timeline with different granularities
+        for granularity in ["day", "week"]:
+            print(f"\n--- Test 6.{granularity}: get_timeline (granularity={granularity}) ---")
+            try:
+                result = await get_timeline(
+                    ctx,
+                    time_range="last week", 
+                    granularity=granularity,
+                    include_stats=True
+                )
+                print(f"✅ get_timeline (granularity={granularity}) succeeded")
+                print(f"Result length: {len(result) if result else 0} characters")
+            except Exception as e:
+                print(f"❌ get_timeline (granularity={granularity}) failed: {e}")
+                traceback.print_exc()
+        
+        print("\n=== TEMPORAL TOOLS TEST COMPLETE ===")
+        
+    except Exception as e:
+        print(f"❌ Critical error during setup: {e}")
+        traceback.print_exc()
+
+if __name__ == "__main__":
+    asyncio.run(test_temporal_tools())