claude-self-reflect 3.2.4 → 3.3.1

package/scripts/csr-status

@@ -0,0 +1,366 @@
+#!/usr/bin/env python3
+"""
+Claude Self-Reflect Status for CC Statusline
+Standalone script that doesn't require venv activation.
+"""
+
+import json
+import time
+from pathlib import Path
+from datetime import datetime, timedelta
+import sys
+
+# Configuration
+CYCLE_FILE = Path.home() / ".claude-self-reflect" / "statusline_cycle.json"
+CYCLE_INTERVAL = 5  # seconds between cycles
+
+
+def get_import_status():
+    """Get current import/indexing status."""
+    state_file = Path.home() / ".claude-self-reflect" / "config" / "imported-files.json"
+
+    if not state_file.exists():
+        return "📚 CSR: Not configured"
+
+    try:
+        with open(state_file, 'r') as f:
+            state = json.load(f)
+
+        imported = len(state.get("imported_files", {}))
+
+        # Count total JSONL files
+        claude_dir = Path.home() / ".claude" / "projects"
+        total = 0
+        if claude_dir.exists():
+            for project_dir in claude_dir.iterdir():
+                if project_dir.is_dir():
+                    total += len(list(project_dir.glob("*.jsonl")))
+
+        if total == 0:
+            return "📚 CSR: No files"
+
+        percent = min(100, (imported / total * 100))
+
+        # Color coding
+        if percent >= 95:
+            emoji = "✅"
+        elif percent >= 50:
+            emoji = "🔄"
+        else:
+            emoji = "⏳"
+
+        return f"{emoji} CSR: {percent:.0f}% indexed"
+
+    except Exception:
+        return "📚 CSR: Error"
+
+
+def get_session_health():
+    """Get cached session health."""
+    cache_file = Path.home() / ".claude-self-reflect" / "session_quality.json"
+
+    if not cache_file.exists():
+        # Fall back to import status if no health data
+        return get_import_status()
+
+    try:
+        # Check cache age
+        mtime = datetime.fromtimestamp(cache_file.stat().st_mtime)
+        age = datetime.now() - mtime
+
+        if age > timedelta(minutes=5):
+            # Fall back to import status if stale
+            return get_import_status()
+
+        with open(cache_file, 'r') as f:
+            data = json.load(f)
+
+        if data.get('status') != 'success':
+            # Fall back to import status if no session
+            return get_import_status()
+
+        summary = data['summary']
+        grade = summary['quality_grade']
+        issues = summary['total_issues']
+
+        # Color coding
+        if grade in ['A+', 'A']:
+            emoji = '🟢'
+        elif grade in ['B', 'C']:
+            emoji = '🟡'
+        else:
+            emoji = '🔴'
+
+        if issues > 0:
+            return f"{emoji} Code: {grade} ({issues})"
+        else:
+            return f"{emoji} Code: {grade}"
+
+    except Exception:
+        return get_import_status()
+
+
+def get_current_cycle():
+    """Determine which metric to show based on cycle."""
+    # Read or create cycle state
+    cycle_state = {"last_update": 0, "current": "import"}
+
+    if CYCLE_FILE.exists():
+        try:
+            with open(CYCLE_FILE, 'r') as f:
+                cycle_state = json.load(f)
+        except:
+            pass
+
+    # Check if it's time to cycle
+    now = time.time()
+    if now - cycle_state["last_update"] >= CYCLE_INTERVAL:
+        # Toggle between import and health
+        cycle_state["current"] = "health" if cycle_state["current"] == "import" else "import"
+        cycle_state["last_update"] = now
+
+        # Save state
+        CYCLE_FILE.parent.mkdir(exist_ok=True)
+        with open(CYCLE_FILE, 'w') as f:
+            json.dump(cycle_state, f)
+
+    return cycle_state["current"]
+
+
+def get_compact_status():
+    """Get both import and quality in compact format: [100%][🟢:A+]"""
+    import subprocess
+    import os
+    import re
+    import shutil
+
+    # Get project-specific status using claude-self-reflect status command
+    import_pct = "?"
+    time_behind = ""
+
+    try:
+        # Get current working directory to determine project
+        cwd = os.getcwd()
+        project_name = os.path.basename(cwd)
+
+        # Get status from claude-self-reflect with secure path
+        import shutil
+        csr_binary = shutil.which("claude-self-reflect")
+        if not csr_binary or not os.path.isfile(csr_binary):
+            # Fallback if binary not found
+            import_pct = "?"
+            return f"[{import_pct}]"
+
+        result = subprocess.run(
+            [csr_binary, "status"],
+            capture_output=True,
+            text=True,
+            timeout=2
+        )
+
+        if result.returncode == 0:
+            status_data = json.loads(result.stdout)
+
+            # Try to find project-specific percentage
+            project_pct = None
+            encoded_path = None
+
+            # Try exact project name FIRST
+            if project_name in status_data.get("projects", {}):
+                project_pct = status_data["projects"][project_name].get("percentage")
+                encoded_path = project_name  # Use project name for file lookup
+
+            # Only try encoded path if exact match not found
+            elif project_pct is None:
+                # Convert path to encoded format
+                encoded_path = cwd.replace("/", "-")
+                if encoded_path.startswith("-"):
+                    encoded_path = encoded_path[1:]  # Remove leading dash
+
+                if encoded_path in status_data.get("projects", {}):
+                    project_pct = status_data["projects"][encoded_path].get("percentage")
+
+            # Use project percentage if found, otherwise use overall
+            if project_pct is not None:
+                pct = int(project_pct)
+            else:
+                pct = int(status_data.get("overall", {}).get("percentage", 0))
+
+            import_pct = f"{pct}%"
+
+            # Only show time behind if NOT at 100%
+            # This indicates how old the unindexed files are
+            if pct < 100:
+                # Check for newest unindexed file
+                state_file = Path.home() / ".claude-self-reflect" / "config" / "imported-files.json"
+                if state_file.exists():
+                    with open(state_file, 'r') as f:
+                        state = json.load(f)
+
+                    # Find project directory
+                    claude_dir = Path.home() / ".claude" / "projects"
+                    if encoded_path:
+                        project_dir = claude_dir / encoded_path
+                        if not project_dir.exists() and not encoded_path.startswith("-"):
+                            project_dir = claude_dir / f"-{encoded_path}"
+
+                        if project_dir.exists():
+                            # Find the newest UNINDEXED file
+                            newest_unindexed_time = None
+                            for jsonl_file in project_dir.glob("*.jsonl"):
+                                file_key = str(jsonl_file)
+                                # Only check unindexed files
+                                if file_key not in state.get("imported_files", {}):
+                                    file_time = datetime.fromtimestamp(jsonl_file.stat().st_mtime)
+                                    if newest_unindexed_time is None or file_time > newest_unindexed_time:
+                                        newest_unindexed_time = file_time
+
+                            # Calculate how behind we are
+                            if newest_unindexed_time:
+                                age = datetime.now() - newest_unindexed_time
+                                if age < timedelta(minutes=5):
+                                    time_behind = " <5m"
+                                elif age < timedelta(hours=1):
+                                    time_behind = f" {int(age.total_seconds() / 60)}m"
+                                elif age < timedelta(days=1):
+                                    time_behind = f" {int(age.total_seconds() / 3600)}h"
+                                else:
+                                    time_behind = f" {int(age.days)}d"
+    except:
+        # Fallback to simple file counting
+        state_file = Path.home() / ".claude-self-reflect" / "config" / "imported-files.json"
+        if state_file.exists():
+            try:
+                with open(state_file, 'r') as f:
+                    state = json.load(f)
+                imported = len(state.get("imported_files", {}))
+
+                claude_dir = Path.home() / ".claude" / "projects"
+                total = 0
+                if claude_dir.exists():
+                    for project_dir in claude_dir.iterdir():
+                        if project_dir.is_dir():
+                            total += len(list(project_dir.glob("*.jsonl")))
+
+                if total > 0:
+                    pct = min(100, int(imported / total * 100))
+                    import_pct = f"{pct}%"
+            except:
+                pass
+
+    # Get quality grade - PER PROJECT cache
+    # BUG FIX: Cache must be per-project, not global!
+    project_name = os.path.basename(os.getcwd())
+    # Secure sanitization with whitelist approach
+    import re
+    safe_project_name = re.sub(r'[^a-zA-Z0-9_-]', '_', project_name)[:100]
+    cache_dir = Path.home() / ".claude-self-reflect" / "quality_cache"
+    cache_file = cache_dir / f"{safe_project_name}.json"
+
+    # Validate cache file path stays within cache directory
+    if cache_file.exists() and not str(cache_file.resolve()).startswith(str(cache_dir.resolve())):
+        # Security issue - return placeholder
+        grade_str = "[...]"
+    else:
+        cache_file.parent.mkdir(exist_ok=True, parents=True)
+    grade_str = ""
+
+    # Try to get quality data (regenerate if too old or missing)
+    quality_valid = False
+
+    if cache_file.exists():
+        try:
+            mtime = datetime.fromtimestamp(cache_file.stat().st_mtime)
+            age = datetime.now() - mtime
+
+            # Use quality data up to 24 hours old (more reasonable)
+            if age < timedelta(hours=24):
+                with open(cache_file, 'r') as f:
+                    data = json.load(f)
+
+                if data.get('status') == 'success':
+                    summary = data['summary']
+                    grade = summary['quality_grade']
+                    issues = summary.get('total_issues', 0)
+                    scope = data.get('scope_label', 'Core')  # Get scope label
+
+                    # GPT-5 fix: Remove forced downgrades, trust the analyzer's grade
+                    # Grade should reflect actual quality metrics, not arbitrary thresholds
+
+                    # Pick emoji based on grade
+                    if grade in ['A+', 'A']:
+                        emoji = '🟢'
+                    elif grade in ['B', 'C']:
+                        emoji = '🟡'
+                    else:
+                        emoji = '🔴'
+
+                    # Simple, clear display without confusing scope labels
+                    grade_str = f"[{emoji}:{grade}/{issues}]"
+                    quality_valid = True
+        except:
+            pass
+
+    # If no valid quality data, show last known value or placeholder
+    if not quality_valid and not grade_str:
+        # Try to use last known value from cache even if expired
+        try:
+            if cache_file.exists():
+                with open(cache_file, 'r') as f:
+                    old_data = json.load(f)
+                if old_data.get('status') == 'success':
+                    old_grade = old_data['summary']['quality_grade']
+                    old_issues = old_data['summary'].get('total_issues', 0)
+                    # Show with dimmed indicator that it's old
+                    if old_grade in ['A+', 'A']:
+                        emoji = '🟢'
+                    elif old_grade in ['B', 'C']:
+                        emoji = '🟡'
+                    else:
+                        emoji = '🔴'
+                    grade_str = f"[{emoji}:{old_grade}/{old_issues}]"
+                else:
+                    grade_str = "[...]"
+            else:
+                grade_str = "[...]"
+        except:
+            grade_str = "[...]"
+
+    # Add mini progress bar if not 100%
+    bar_str = ""
+    if import_pct != "?" and import_pct != "100%":
+        pct_num = int(import_pct.rstrip('%'))
+        filled = int(pct_num * 4 / 100)  # 4-char mini bar
+        empty = 4 - filled
+        bar_str = "█" * filled + "░" * empty + " "
+
+    # Return compact format with bar, percentage, time behind, and grade
+    return f"[{bar_str}{import_pct}{time_behind}]{grade_str}"
+
+def main():
+    """Main entry point for CC statusline."""
+    # Check for forced mode
+    if len(sys.argv) > 1:
+        if sys.argv[1] == "--import":
+            print(get_import_status())
+        elif sys.argv[1] == "--health":
+            print(get_session_health())
+        elif sys.argv[1] == "--quality-only":
+            # Only show quality, not import (to avoid duplication with MCP status)
+            health = get_session_health()
+            # Only show if it's actual quality data, not fallback to import
+            if "Code:" in health:
+                print(health)
+        elif sys.argv[1] == "--compact":
+            print(get_compact_status())
+        else:
+            # Default to compact mode
+            print(get_compact_status())
+        return
+
+    # Default to compact format (no cycling)
+    print(get_compact_status())
+
+
+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()