claude-self-reflect 3.3.0 → 3.3.1

package/installer/statusline-setup.js

@@ -0,0 +1,289 @@
+#!/usr/bin/env node
+/**
+ * Claude Code Statusline Integration Setup
+ * Automatically configures CC statusline to show CSR metrics
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { execSync } from 'child_process';
+import os from 'os';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+class StatuslineSetup {
+    constructor() {
+        this.homeDir = os.homedir();
+        this.claudeDir = path.join(this.homeDir, '.claude');
+        this.csrScript = path.join(path.dirname(__dirname), 'scripts', 'csr-status');
+        this.globalBin = '/usr/local/bin/csr-status';
+        this.statuslineWrapper = path.join(this.claudeDir, 'statusline-wrapper.sh');
+        this.statuslineBackup = path.join(this.claudeDir, 'statusline-wrapper.sh.backup');
+    }
+
+    log(message, type = 'info') {
+        const colors = {
+            info: '\x1b[36m',
+            success: '\x1b[32m',
+            warning: '\x1b[33m',
+            error: '\x1b[31m'
+        };
+        console.log(`${colors[type]}${message}\x1b[0m`);
+    }
+
+    checkPrerequisites() {
+        // Check if Claude Code directory exists
+        if (!fs.existsSync(this.claudeDir)) {
+            this.log('Claude Code directory not found. Please ensure Claude Code is installed.', 'warning');
+            return false;
+        }
+
+        // Check if csr-status script exists
+        if (!fs.existsSync(this.csrScript)) {
+            this.log('CSR status script not found. Please ensure the package is installed correctly.', 'error');
+            return false;
+        }
+
+        return true;
+    }
+
+    installGlobalCommand() {
+        try {
+            // Check if we need sudo
+            const needsSudo = !this.canWriteTo('/usr/local/bin');
+
+            if (fs.existsSync(this.globalBin)) {
+                // Check if it's already pointing to our script
+                try {
+                    const target = fs.readlinkSync(this.globalBin);
+                    if (target === this.csrScript) {
+                        this.log('Global csr-status command already installed', 'success');
+                        return true;
+                    }
+                } catch (e) {
+                    // Not a symlink or can't read, will replace
+                }
+            }
+
+            // Create symlink
+            const cmd = needsSudo
+                ? `sudo ln -sf "${this.csrScript}" "${this.globalBin}"`
+                : `ln -sf "${this.csrScript}" "${this.globalBin}"`;
+
+            if (needsSudo) {
+                this.log('Installing global csr-status command (may require password)...', 'info');
+            }
+
+            execSync(cmd, { stdio: 'inherit' });
+
+            // Make executable
+            const chmodCmd = needsSudo
+                ? `sudo chmod +x "${this.globalBin}"`
+                : `chmod +x "${this.globalBin}"`;
+            execSync(chmodCmd);
+
+            this.log('Global csr-status command installed successfully', 'success');
+            return true;
+        } catch (error) {
+            this.log(`Failed to install global command: ${error.message}`, 'warning');
+            this.log('You can manually install by running:', 'info');
+            this.log(`  sudo ln -sf "${this.csrScript}" "${this.globalBin}"`, 'info');
+            return false;
+        }
+    }
+
+    canWriteTo(dir) {
+        try {
+            fs.accessSync(dir, fs.constants.W_OK);
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
+    patchStatuslineWrapper() {
+        if (!fs.existsSync(this.statuslineWrapper)) {
+            this.log('Claude Code statusline wrapper not found. Statusline integration skipped.', 'warning');
+            return false;
+        }
+
+        try {
+            // Read current wrapper
+            let content = fs.readFileSync(this.statuslineWrapper, 'utf8');
+
+            // Check if already patched with new approach
+            if (content.includes('CSR compact status instead of MCP bar')) {
+                this.log('Statusline wrapper already patched', 'success');
+                return true;
+            }
+
+            // Create backup
+            if (!fs.existsSync(this.statuslineBackup)) {
+                fs.copyFileSync(this.statuslineWrapper, this.statuslineBackup);
+                this.log(`Backup created: ${this.statuslineBackup}`, 'info');
+            }
+
+            // Find and replace the MCP bar generation section
+            const barPattern = /# Create mini progress bar[\s\S]*?MCP_COLOR="\\033\[1;90m"  # Gray/;
+
+            if (content.match(barPattern)) {
+                // Replace the entire bar generation section
+                const replacement = `# Use CSR compact status instead of MCP bar
+    # This shows both import percentage and code quality in format: [100% <time>][🟢:A+]
+    CSR_COMPACT=$(csr-status --compact 2>/dev/null || echo "")
+
+    if [[ -n "$CSR_COMPACT" ]]; then
+        MCP_STATUS="$CSR_COMPACT"
+
+        # Color based on content
+        if [[ "$CSR_COMPACT" == *"100%"* ]]; then
+            MCP_COLOR="\\033[1;32m"  # Green for complete
+        elif [[ "$CSR_COMPACT" == *"[🟢:"* ]]; then
+            MCP_COLOR="\\033[1;32m"  # Green for good quality
+        elif [[ "$CSR_COMPACT" == *"[🟡:"* ]]; then
+            MCP_COLOR="\\033[1;33m"  # Yellow for medium quality
+        elif [[ "$CSR_COMPACT" == *"[🔴:"* ]]; then
+            MCP_COLOR="\\033[1;31m"  # Red for poor quality
+        else
+            MCP_COLOR="\\033[1;36m"  # Cyan default
+        fi
+    else
+        MCP_STATUS=""
+        MCP_COLOR="\\033[1;90m"  # Gray`;
+
+                content = content.replace(barPattern, replacement);
+
+                // Write back
+                fs.writeFileSync(this.statuslineWrapper, content);
+                this.log('Statusline wrapper patched successfully (replaced MCP bar)', 'success');
+                return true;
+            } else {
+                // Fallback: Look for the PERCENTAGE check
+                const altPattern = /if \[\[ "\$PERCENTAGE" != "null"[\s\S]*?MCP_COLOR="\\033\[1;90m"  # Gray/;
+
+                if (content.match(altPattern)) {
+                    const replacement = `# Use CSR compact status instead of MCP bar
+    # This shows both import percentage and code quality in format: [100% <time>][🟢:A+]
+    CSR_COMPACT=$(csr-status --compact 2>/dev/null || echo "")
+
+    if [[ -n "$CSR_COMPACT" ]]; then
+        MCP_STATUS="$CSR_COMPACT"
+
+        # Color based on content
+        if [[ "$CSR_COMPACT" == *"100%"* ]]; then
+            MCP_COLOR="\\033[1;32m"  # Green for complete
+        elif [[ "$CSR_COMPACT" == *"[🟢:"* ]]; then
+            MCP_COLOR="\\033[1;32m"  # Green for good quality
+        elif [[ "$CSR_COMPACT" == *"[🟡:"* ]]; then
+            MCP_COLOR="\\033[1;33m"  # Yellow for medium quality
+        elif [[ "$CSR_COMPACT" == *"[🔴:"* ]]; then
+            MCP_COLOR="\\033[1;31m"  # Red for poor quality
+        else
+            MCP_COLOR="\\033[1;36m"  # Cyan default
+        fi
+    else
+        MCP_STATUS=""
+        MCP_COLOR="\\033[1;90m"  # Gray`;
+
+                    content = content.replace(altPattern, replacement);
+
+                    // Write back
+                    fs.writeFileSync(this.statuslineWrapper, content);
+                    this.log('Statusline wrapper patched successfully (replaced PERCENTAGE section)', 'success');
+                    return true;
+                } else {
+                    this.log('Could not find MCP bar section to replace', 'warning');
+                    return false;
+                }
+            }
+        } catch (error) {
+            this.log(`Failed to patch statusline wrapper: ${error.message}`, 'error');
+            return false;
+        }
+    }
+
+    validateIntegration() {
+        try {
+            // Test csr-status command
+            const output = execSync('csr-status --compact', { encoding: 'utf8' });
+            if (output) {
+                this.log(`CSR status output: ${output.trim()}`, 'success');
+                return true;
+            }
+        } catch (error) {
+            this.log('CSR status command not working properly', 'warning');
+            return false;
+        }
+        return false;
+    }
+
+    async run() {
+        this.log('🚀 Setting up Claude Code Statusline Integration...', 'info');
+
+        if (!this.checkPrerequisites()) {
+            this.log('Prerequisites check failed', 'error');
+            return false;
+        }
+
+        const steps = [
+            { name: 'Install global command', fn: () => this.installGlobalCommand() },
+            { name: 'Patch statusline wrapper', fn: () => this.patchStatuslineWrapper() },
+            { name: 'Validate integration', fn: () => this.validateIntegration() }
+        ];
+
+        let success = true;
+        for (const step of steps) {
+            this.log(`\n📋 ${step.name}...`, 'info');
+            if (!step.fn()) {
+                success = false;
+                this.log(`❌ ${step.name} failed`, 'error');
+            }
+        }
+
+        if (success) {
+            this.log('\n✅ Statusline integration completed successfully!', 'success');
+            this.log('The CSR status will now appear in your Claude Code statusline.', 'info');
+            this.log('Format: [import%][🟢:grade] for compact quality metrics', 'info');
+        } else {
+            this.log('\n⚠️ Statusline integration completed with warnings', 'warning');
+            this.log('Some features may need manual configuration.', 'warning');
+        }
+
+        return success;
+    }
+
+    // Restore original statusline if needed
+    restore() {
+        if (fs.existsSync(this.statuslineBackup)) {
+            try {
+                fs.copyFileSync(this.statuslineBackup, this.statuslineWrapper);
+                this.log('Statusline wrapper restored from backup', 'success');
+                return true;
+            } catch (error) {
+                this.log(`Failed to restore: ${error.message}`, 'error');
+                return false;
+            }
+        } else {
+            this.log('No backup found to restore', 'warning');
+            return false;
+        }
+    }
+}
+
+// Run if called directly
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+    const setup = new StatuslineSetup();
+
+    if (process.argv[2] === '--restore') {
+        setup.restore();
+    } else {
+        setup.run().catch(error => {
+            console.error('Setup failed:', error);
+            process.exit(1);
+        });
+    }
+}
+
+export default StatuslineSetup;

package/mcp-server/run-mcp.sh

@@ -11,8 +11,17 @@ SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
 # Navigate to the mcp-server directory
 cd "$SCRIPT_DIR"
 
-# CRITICAL: Load .env file from project root if it exists
-# This ensures the MCP server uses the same settings as other scripts
+# CRITICAL: Environment variables priority:
+# 1. Command-line args from Claude Code (already in environment)
+# 2. .env file (only for missing values)
+# 3. Defaults (as fallback)
+
+# Store any command-line provided values BEFORE loading .env
+CMDLINE_VOYAGE_KEY="${VOYAGE_KEY:-}"
+CMDLINE_PREFER_LOCAL="${PREFER_LOCAL_EMBEDDINGS:-}"
+CMDLINE_QDRANT_URL="${QDRANT_URL:-}"
+
+# Load .env file for any missing values
 if [ -f "../.env" ]; then
     echo "[DEBUG] Loading .env file from project root" >&2
     set -a  # Export all variables
@@ -22,8 +31,23 @@ else
     echo "[DEBUG] No .env file found, using defaults" >&2
 fi
 
-# Set smart defaults if not already set
-# These match what the CLI setup wizard uses
+# Restore command-line values (they take precedence)
+if [ ! -z "$CMDLINE_VOYAGE_KEY" ]; then
+    export VOYAGE_KEY="$CMDLINE_VOYAGE_KEY"
+    echo "[DEBUG] Using command-line VOYAGE_KEY" >&2
+fi
+
+if [ ! -z "$CMDLINE_PREFER_LOCAL" ]; then
+    export PREFER_LOCAL_EMBEDDINGS="$CMDLINE_PREFER_LOCAL"
+    echo "[DEBUG] Using command-line PREFER_LOCAL_EMBEDDINGS: $PREFER_LOCAL_EMBEDDINGS" >&2
+fi
+
+if [ ! -z "$CMDLINE_QDRANT_URL" ]; then
+    export QDRANT_URL="$CMDLINE_QDRANT_URL"
+    echo "[DEBUG] Using command-line QDRANT_URL: $QDRANT_URL" >&2
+fi
+
+# Set smart defaults ONLY if still not set
 if [ -z "$QDRANT_URL" ]; then
     export QDRANT_URL="http://localhost:6333"
     echo "[DEBUG] Using default QDRANT_URL: $QDRANT_URL" >&2

package/mcp-server/src/parallel_search.py

@@ -64,84 +64,11 @@ async def search_single_collection(
         DECAY_SCALE_DAYS = constants.get('DECAY_SCALE_DAYS', 90)
         DECAY_WEIGHT = constants.get('DECAY_WEIGHT', 0.3)
         
-        if should_use_decay and USE_NATIVE_DECAY and NATIVE_DECAY_AVAILABLE:
-            # Use native Qdrant decay with newer API
-            await ctx.debug(f"Using NATIVE Qdrant decay (new API) for {collection_name}")
-            
-            half_life_seconds = DECAY_SCALE_DAYS * 24 * 60 * 60
-            
-            # Build query using Qdrant's Fusion and RankFusion
-            fusion_query = models.Fusion(
-                fusion=models.RankFusion.RRF,
-                queries=[
-                    # Semantic similarity query
-                    models.NearestQuery(
-                        nearest=query_embedding,
-                        score_threshold=min_score
-                    ),
-                    # Time decay query using context pair
-                    models.ContextQuery(
-                        context=[
-                            models.ContextPair(
-                                positive=models.DiscoverQuery(
-                                    target=query_embedding,
-                                    context=[
-                                        models.ContextPair(
-                                            positive=models.DatetimeRange(
-                                                gt=datetime.now().isoformat(),
-                                                lt=(datetime.now().timestamp() + half_life_seconds)
-                                            )
-                                        )
-                                    ]
-                                )
-                            )
-                        ]
-                    )
-                ]
-            )
-            
-            # Execute search with native decay
-            search_results = await qdrant_client.query_points(
-                collection_name=collection_name,
-                query=fusion_query,
-                limit=limit,
-                with_payload=True
-            )
-            
-            # Process results
-            for point in search_results.points:
-                # Process each point and add to results
-                raw_timestamp = point.payload.get('timestamp', datetime.now().isoformat())
-                clean_timestamp = raw_timestamp.replace('Z', '+00:00') if raw_timestamp.endswith('Z') else raw_timestamp
-                
-                point_project = point.payload.get('project', collection_name.replace('conv_', '').replace('_voyage', '').replace('_local', ''))
-                
-                # Apply project filtering
-                if target_project != 'all' and not is_reflection_collection:
-                    if point_project != target_project:
-                        normalized_target = target_project.replace('-', '_')
-                        normalized_point = point_project.replace('-', '_')
-                        if not (normalized_point == normalized_target or 
-                                point_project.endswith(f"/{target_project}") or
-                                point_project.endswith(f"-{target_project}") or
-                                normalized_point.endswith(f"_{normalized_target}") or
-                                normalized_point.endswith(f"/{normalized_target}")):
-                            continue
-                
-                # Create SearchResult
-                search_result = {
-                    'id': str(point.id),
-                    'score': point.score,
-                    'timestamp': clean_timestamp,
-                    'role': point.payload.get('start_role', point.payload.get('role', 'unknown')),
-                    'excerpt': (point.payload.get('text', '')[:350] + '...' 
-                               if len(point.payload.get('text', '')) > 350 
-                               else point.payload.get('text', '')),
-                    'project_name': point_project,
-                    'payload': point.payload
-                }
-                results.append(search_result)
-                
+        # NOTE: Native decay API is not available in current Qdrant, fall back to client-side
+        # The Fusion/RankFusion API was experimental and removed, always use client-side decay
+        if should_use_decay and False:  # Disabled until Qdrant provides stable decay API
+            # This code path is intentionally disabled
+            pass
         else:
             # Standard search without native decay or client-side decay
             search_results = await qdrant_client.search(
@@ -220,17 +147,24 @@ async def search_single_collection(
                                 continue
                         logger.debug(f"Keeping point: project '{point_project}' matches target '{target_project}'")
                     
-                    # Create SearchResult
+                    # Create SearchResult with consistent structure
                     search_result = {
                         'id': str(point.id),
                         'score': adjusted_score,
                         'timestamp': clean_timestamp,
                         'role': point.payload.get('start_role', point.payload.get('role', 'unknown')),
-                        'excerpt': (point.payload.get('text', '')[:350] + '...' 
-                                   if len(point.payload.get('text', '')) > 350 
+                        'excerpt': (point.payload.get('text', '')[:350] + '...'
+                                   if len(point.payload.get('text', '')) > 350
                                    else point.payload.get('text', '')),
                         'project_name': point_project,
-                        'payload': point.payload
+                        'conversation_id': point.payload.get('conversation_id'),
+                        'base_conversation_id': point.payload.get('base_conversation_id'),
+                        'collection_name': collection_name,
+                        'raw_payload': point.payload,  # Renamed from 'payload' for consistency
+                        'code_patterns': point.payload.get('code_patterns'),
+                        'files_analyzed': point.payload.get('files_analyzed'),
+                        'tools_used': list(point.payload.get('tools_used', [])) if isinstance(point.payload.get('tools_used'), set) else point.payload.get('tools_used'),
+                        'concepts': point.payload.get('concepts')
                     }
                     results.append(search_result)
             else:

package/mcp-server/src/reflection_tools.py

@@ -44,9 +44,10 @@ class ReflectionTools:
         await ctx.debug(f"Storing reflection with {len(tags)} tags")
 
         try:
-            # Determine collection name based on embedding type
+            # Determine collection name based on active model type, not prefer_local
             embedding_manager = self.get_embedding_manager()
-            embedding_type = "local" if embedding_manager.prefer_local else "voyage"
+            # Use actual model_type to ensure consistency
+            embedding_type = embedding_manager.model_type or ("voyage" if embedding_manager.voyage_client else "local")
             collection_name = f"reflections_{embedding_type}"
 
             # Ensure reflections collection exists
@@ -57,8 +58,8 @@ class ReflectionTools:
                 # Collection doesn't exist, create it
                 await ctx.debug(f"Creating {collection_name} collection")
 
-                # Determine embedding dimensions
-                embedding_dim = embedding_manager.get_vector_dimension()
+                # Get embedding dimensions for the specific type
+                embedding_dim = embedding_manager.get_vector_dimension(force_type=embedding_type)
 
                 await self.qdrant_client.create_collection(
                     collection_name=collection_name,
@@ -67,10 +68,14 @@ class ReflectionTools:
                         distance=Distance.COSINE
                     )
                 )
-            
-            # Generate embedding for the reflection
-            embedding_manager = self.get_embedding_manager()
-            embedding = await embedding_manager.generate_embedding(content)
+
+            # Generate embedding with the same forced type for consistency
+            embedding = await embedding_manager.generate_embedding(content, force_type=embedding_type)
+
+            # Guard against failed embeddings
+            if not embedding:
+                await ctx.debug("Failed to generate embedding for reflection")
+                return "Failed to store reflection: embedding generation failed"
             
             # Create unique ID
             reflection_id = hashlib.md5(f"{content}{datetime.now().isoformat()}".encode()).hexdigest()