claude-self-reflect 3.3.0 → 4.0.0

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,24 @@ 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:-}"
+
+# CRITICAL: If local mode is explicitly requested, skip VOYAGE_KEY from .env
+if [ "$CMDLINE_PREFER_LOCAL" = "true" ]; then
+    echo "[DEBUG] Local mode explicitly requested - will skip VOYAGE_KEY from .env" >&2
+    # Save current VOYAGE_KEY state
+    SAVED_VOYAGE_KEY="${VOYAGE_KEY:-}"
+fi
+
+# 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 +38,31 @@ 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
+# CRITICAL: Handle local mode by clearing VOYAGE_KEY if local was explicitly requested
+if [ "$CMDLINE_PREFER_LOCAL" = "true" ]; then
+    unset VOYAGE_KEY
+    echo "[DEBUG] Local mode: VOYAGE_KEY cleared to force local embeddings" >&2
+elif [ "${CMDLINE_VOYAGE_KEY+x}" ]; then
+    # Restore command-line VOYAGE_KEY if it was explicitly set
+    export VOYAGE_KEY="$CMDLINE_VOYAGE_KEY"
+    if [ -z "$VOYAGE_KEY" ]; then
+        echo "[DEBUG] VOYAGE_KEY explicitly set to empty (forcing local mode)" >&2
+    else
+        echo "[DEBUG] Using command-line VOYAGE_KEY" >&2
+    fi
+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
@@ -52,9 +91,8 @@ fi
 # CRITICAL FIX: Pass through environment variables from Claude Code
 # These environment variables are set by `claude mcp add -e KEY=value`
 # Export them so the Python process can access them
-if [ ! -z "$VOYAGE_KEY" ]; then
-    export VOYAGE_KEY="$VOYAGE_KEY"
-fi
+# BUT: Don't export VOYAGE_KEY if we're in local mode
+# Note: VOYAGE_KEY might have been unset earlier for local mode, so skip this entirely
 
 if [ ! -z "$VOYAGE_KEY_2" ]; then
     export VOYAGE_KEY_2="$VOYAGE_KEY_2"

package/mcp-server/src/code_reload_tool.py

@@ -0,0 +1,271 @@
+"""Runtime code reloading tool for MCP server development."""
+
+import os
+import sys
+import importlib
+import logging
+from pathlib import Path
+from typing import Dict, List, Optional, Literal
+from fastmcp import Context
+from pydantic import Field
+import hashlib
+import json
+
+logger = logging.getLogger(__name__)
+
+
+class CodeReloader:
+    """Handles runtime code reloading for the MCP server."""
+
+    def __init__(self):
+        """Initialize the code reloader."""
+        self.module_hashes: Dict[str, str] = {}
+        self.reload_history: List[Dict] = []
+        self.cache_dir = Path.home() / '.claude-self-reflect' / 'reload_cache'
+        self.cache_dir.mkdir(parents=True, exist_ok=True)
+        # Test comment: Hot reload test at 2025-09-15
+        logger.info("CodeReloader initialized with hot reload support")
+
+    def _get_file_hash(self, filepath: Path) -> str:
+        """Get SHA256 hash of a file."""
+        with open(filepath, 'rb') as f:
+            return hashlib.sha256(f.read()).hexdigest()
+
+    def _get_changed_modules(self) -> List[str]:
+        """Detect which modules have changed since last check."""
+        changed = []
+        src_dir = Path(__file__).parent
+
+        for py_file in src_dir.glob("*.py"):
+            if py_file.name == "__pycache__":
+                continue
+
+            module_name = f"src.{py_file.stem}"
+            current_hash = self._get_file_hash(py_file)
+
+            if module_name in self.module_hashes:
+                if self.module_hashes[module_name] != current_hash:
+                    changed.append(module_name)
+
+            self.module_hashes[module_name] = current_hash
+
+        return changed
+
+    async def reload_modules(
+        self,
+        ctx: Context,
+        modules: Optional[List[str]] = None,
+        auto_detect: bool = True
+    ) -> str:
+        """Reload Python modules at runtime without restarting the MCP server."""
+
+        await ctx.debug("Starting code reload process...")
+
+        try:
+            # Track what we're reloading
+            reload_targets = []
+
+            if auto_detect:
+                # Detect changed modules
+                changed = self._get_changed_modules()
+                if changed:
+                    reload_targets.extend(changed)
+                    await ctx.debug(f"Auto-detected changes in: {changed}")
+
+            if modules:
+                # Add explicitly requested modules
+                reload_targets.extend(modules)
+
+            if not reload_targets:
+                return "📊 No modules to reload. All code is up to date!"
+
+            # Perform the reload
+            reloaded = []
+            failed = []
+
+            for module_name in reload_targets:
+                try:
+                    # SECURITY FIX: Validate module is in whitelist
+                    from .security_patches import ModuleWhitelist
+                    if not ModuleWhitelist.is_allowed_module(module_name):
+                        logger.warning(f"Module not in whitelist, skipping: {module_name}")
+                        failed.append((module_name, "Module not in whitelist"))
+                        continue
+
+                    if module_name in sys.modules:
+                        # Store old module reference for rollback
+                        old_module = sys.modules[module_name]
+
+                        # Reload the module
+                        logger.info(f"Reloading module: {module_name}")
+                        reloaded_module = importlib.reload(sys.modules[module_name])
+
+                        # Update any global references if needed
+                        self._update_global_references(module_name, reloaded_module)
+
+                        reloaded.append(module_name)
+                        await ctx.debug(f"✅ Reloaded: {module_name}")
+                    else:
+                        # Module not loaded yet, import it
+                        importlib.import_module(module_name)
+                        reloaded.append(module_name)
+                        await ctx.debug(f"✅ Imported: {module_name}")
+
+                except Exception as e:
+                    logger.error(f"Failed to reload {module_name}: {e}", exc_info=True)
+                    failed.append((module_name, str(e)))
+                    await ctx.debug(f"❌ Failed: {module_name} - {e}")
+
+            # Record reload history
+            self.reload_history.append({
+                "timestamp": os.environ.get('MCP_REQUEST_ID', 'unknown'),
+                "reloaded": reloaded,
+                "failed": failed
+            })
+
+            # Build response
+            response = "🔄 **Code Reload Results**\n\n"
+
+            if reloaded:
+                response += f"**Successfully Reloaded ({len(reloaded)}):**\n"
+                for module in reloaded:
+                    response += f"- ✅ {module}\n"
+                response += "\n"
+
+            if failed:
+                response += f"**Failed to Reload ({len(failed)}):**\n"
+                for module, error in failed:
+                    response += f"- ❌ {module}: {error}\n"
+                response += "\n"
+
+            response += "**Important Notes:**\n"
+            response += "- Class instances created before reload keep old code\n"
+            response += "- New requests will use the reloaded code\n"
+            response += "- Some changes may require full restart (e.g., new tools)\n"
+
+            return response
+
+        except Exception as e:
+            logger.error(f"Code reload failed: {e}", exc_info=True)
+            return f"❌ Code reload failed: {str(e)}"
+
+    def _update_global_references(self, module_name: str, new_module):
+        """Update global references after module reload."""
+        # This is where we'd update any global singleton references
+        # For example, if we reload embedding_manager, we might need to
+        # update the global embedding manager instance
+
+        if module_name == "src.embedding_manager":
+            # Update the global embedding manager if it exists
+            if hasattr(new_module, 'get_embedding_manager'):
+                # The singleton pattern should handle this automatically
+                pass
+
+        elif module_name == "src.search_tools":
+            # Search tools might need to refresh their references
+            pass
+
+        # Add more specific updates as needed
+
+    async def get_reload_status(self, ctx: Context) -> str:
+        """Get the current reload status and history."""
+
+        try:
+            # Check for changed files
+            changed = self._get_changed_modules()
+
+            response = "📊 **Code Reload Status**\n\n"
+
+            response += "**Module Status:**\n"
+            if changed:
+                response += f"⚠️ {len(changed)} modules have pending changes:\n"
+                for module in changed:
+                    response += f"  - {module}\n"
+            else:
+                response += "✅ All modules are up to date\n"
+
+            response += f"\n**Tracked Modules:** {len(self.module_hashes)}\n"
+
+            if self.reload_history:
+                response += f"\n**Recent Reloads:**\n"
+                for entry in self.reload_history[-5:]:  # Last 5 reloads
+                    response += f"- {entry['timestamp']}: "
+                    response += f"{len(entry['reloaded'])} success, "
+                    response += f"{len(entry['failed'])} failed\n"
+
+            return response
+
+        except Exception as e:
+            logger.error(f"Failed to get reload status: {e}", exc_info=True)
+            return f"❌ Failed to get reload status: {str(e)}"
+
+    async def clear_python_cache(self, ctx: Context) -> str:
+        """Clear Python's module cache and bytecode."""
+
+        try:
+            await ctx.debug("Clearing Python cache...")
+
+            # Clear __pycache__ directories
+            src_dir = Path(__file__).parent
+            pycache_dirs = list(src_dir.rglob("__pycache__"))
+
+            for pycache in pycache_dirs:
+                if pycache.is_dir():
+                    import shutil
+                    shutil.rmtree(pycache)
+                    await ctx.debug(f"Removed: {pycache}")
+
+            # Clear import cache
+            importlib.invalidate_caches()
+
+            return f"✅ Cleared {len(pycache_dirs)} __pycache__ directories and invalidated import caches"
+
+        except Exception as e:
+            logger.error(f"Failed to clear cache: {e}", exc_info=True)
+            return f"❌ Failed to clear cache: {str(e)}"
+
+
+def register_code_reload_tool(mcp, get_embedding_manager):
+    """Register the code reloading tool with the MCP server."""
+
+    reloader = CodeReloader()
+
+    @mcp.tool()
+    async def reload_code(
+        ctx: Context,
+        modules: Optional[List[str]] = Field(
+            default=None,
+            description="Specific modules to reload (e.g., ['src.search_tools', 'src.embedding_manager'])"
+        ),
+        auto_detect: bool = Field(
+            default=True,
+            description="Automatically detect and reload changed modules"
+        )
+    ) -> str:
+        """Reload Python code at runtime without restarting the MCP server.
+
+        This allows hot-reloading of code changes during development, similar to
+        the mode switching capability. Changes take effect for new requests.
+
+        Note: Some changes (new tools, startup configuration) still require restart.
+        """
+        return await reloader.reload_modules(ctx, modules, auto_detect)
+
+    @mcp.tool()
+    async def reload_status(ctx: Context) -> str:
+        """Check which modules have pending changes and reload history.
+
+        Shows which files have been modified since last reload and
+        the history of recent reload operations.
+        """
+        return await reloader.get_reload_status(ctx)
+
+    @mcp.tool()
+    async def clear_module_cache(ctx: Context) -> str:
+        """Clear Python's module cache and __pycache__ directories.
+
+        Useful when reload isn't working due to cached bytecode.
+        """
+        return await reloader.clear_python_cache(ctx)
+
+    logger.info("Code reload tools registered successfully")