claude-self-reflect 6.0.1 → 6.0.2

package/installer/cli.js

@@ -10,9 +10,12 @@ const __dirname = dirname(__filename);
 
 const commands = {
   setup: 'Run the setup wizard to configure Claude Self-Reflect',
+  update: 'Check for and install missing features or updates',
   status: 'Get indexing status as JSON (overall + per-project breakdown)',
   statusline: 'Configure Claude Code statusline integration',
   doctor: 'Check your installation and diagnose issues',
+  version: 'Show version and check for updates',
+  uninstall: 'Uninstall Claude Self-Reflect',
   help: 'Show this help message'
 };
 
@@ -185,12 +188,13 @@ function help() {
   console.log('\nExamples:');
   console.log('  claude-self-reflect setup --voyage-key=pa-1234567890');
   console.log('  claude-self-reflect setup --local');
-  console.log('  claude-self-reflect setup --debug  # For troubleshooting');
-  console.log('  claude-self-reflect status          # Get indexing status as JSON');
-  
+  console.log('  claude-self-reflect update          # Fix missing features');
+  console.log('  claude-self-reflect status          # Get indexing status');
+  console.log('  claude-self-reflect doctor          # Diagnose issues');
+
   console.log('\nFor more information:');
   console.log('  Documentation: https://github.com/ramakay/claude-self-reflect');
-  console.log('  Status API: See docs/api-reference.md#cli-status-interface');
+  console.log('  Issues: https://github.com/ramakay/claude-self-reflect/issues');
 }
 
 async function statusline() {
@@ -205,6 +209,77 @@ async function statusline() {
   }
 }
 
+// Helper function to run bash scripts with validation
+async function runBashScript(scriptName, errorMessage) {
+  const scriptPath = join(__dirname, '..', 'scripts', 'setup', scriptName);
+
+  // Check bash is available
+  try {
+    execSync('bash --version', { stdio: 'ignore' });
+  } catch {
+    console.error('❌ Bash is required but not found');
+    console.error('   Please ensure bash is installed');
+    process.exit(1);
+  }
+
+  // Check script file exists
+  try {
+    await fs.access(scriptPath);
+  } catch {
+    console.error(`❌ Script not found: ${scriptPath}`);
+    console.error('   Please reinstall claude-self-reflect');
+    process.exit(1);
+  }
+
+  // Run script
+  try {
+    const child = spawn('bash', [scriptPath], { stdio: 'inherit' });
+    child.on('exit', (code) => {
+      process.exit(code || 0);
+    });
+  } catch (error) {
+    console.error(`${errorMessage} ${error.message}`);
+    process.exit(1);
+  }
+}
+
+async function update() {
+  console.log('🔄 Checking for missing features and updates...\n');
+
+  try {
+    const UpdateManager = (await import('./update-manager.js')).default;
+    const manager = new UpdateManager();
+    await manager.run();
+  } catch (error) {
+    // Check if update-manager.js itself is missing (not a nested dependency)
+    // Node uses file:// URLs in error messages, not relative paths
+    const isUpdateManagerMissing =
+      (error.code === 'ERR_MODULE_NOT_FOUND' &&
+       (error.message.includes('update-manager.js') || error.message.includes('update-manager'))) ||
+      (error.message && error.message.includes('Cannot find module') && error.message.includes('update-manager'));
+
+    if (isUpdateManagerMissing) {
+      console.error('❌ Update manager not found');
+      console.error('   Please reinstall: npm install -g claude-self-reflect');
+    } else {
+      console.error('❌ Update check failed:', error.message);
+      console.error('   Run with DEBUG=1 for more details');
+      if (process.env.DEBUG) {
+        console.error('\nStack trace:', error.stack);
+      }
+    }
+    process.exit(1);
+  }
+}
+
+async function version() {
+  await runBashScript('version.sh', 'Failed to check version:');
+}
+
+async function uninstall() {
+  await runBashScript('uninstall.sh', 'Failed to run uninstall:');
+}
+
 // Main
 const command = process.argv[2] || 'help';
 
@@ -212,6 +287,9 @@ switch (command) {
   case 'setup':
     setup();
     break;
+  case 'update':
+    update();
+    break;
   case 'status':
     status();
     break;
@@ -221,6 +299,12 @@ switch (command) {
   case 'doctor':
     doctor();
     break;
+  case 'version':
+    version();
+    break;
+  case 'uninstall':
+    uninstall();
+    break;
   case 'help':
   default:
     help();

package/installer/fastembed-fallback.js

@@ -0,0 +1,261 @@
+#!/usr/bin/env node
+/**
+ * FastEmbed Fallback Installer
+ * Automatically detects SSL/proxy issues and downloads model from Google Cloud Storage
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+import https from 'https';
+import os from 'os';
+
+class FastEmbedFallback {
+    constructor() {
+        this.homeDir = os.homedir();
+        this.cacheDir = path.join(this.homeDir, '.cache', 'fastembed');
+        this.modelName = 'sentence-transformers-all-MiniLM-L6-v2';
+        this.modelFile = `${this.modelName}.tar.gz`;
+        this.gcsUrl = `https://storage.googleapis.com/qdrant-fastembed/${this.modelFile}`;
+    }
+
+    log(message, type = 'info') {
+        const colors = {
+            info: '\x1b[36m',
+            success: '\x1b[32m',
+            warning: '\x1b[33m',
+            error: '\x1b[31m'
+        };
+        const prefix = {
+            info: 'ℹ',
+            success: '✓',
+            warning: '⚠',
+            error: '✗'
+        };
+        console.log(`${colors[type]}${prefix[type]} ${message}\x1b[0m`);
+    }
+
+    checkModelExists() {
+        const modelPath = path.join(this.cacheDir, this.modelName);
+        return fs.existsSync(modelPath);
+    }
+
+    async testHuggingFace() {
+        this.log('Testing HuggingFace connectivity...', 'info');
+        try {
+            execSync('curl -s -m 5 https://huggingface.co > /dev/null 2>&1', { timeout: 5000 });
+            this.log('HuggingFace is accessible', 'success');
+            return true;
+        } catch (error) {
+            this.log('HuggingFace blocked by proxy/firewall', 'warning');
+            return false;
+        }
+    }
+
+    downloadFromGCS() {
+        this.log('Downloading FastEmbed model from Google Cloud Storage...', 'info');
+        this.log('(Using GCS mirror to bypass corporate proxies)', 'info');
+
+        // Create cache directory
+        if (!fs.existsSync(this.cacheDir)) {
+            fs.mkdirSync(this.cacheDir, { recursive: true });
+        }
+
+        const tarPath = path.join(this.cacheDir, this.modelFile);
+
+        try {
+            // Download with curl (handles proxies better than Node's https)
+            this.log(`Downloading ${this.modelFile} (79MB)...`, 'info');
+            execSync(`curl -L -o "${tarPath}" "${this.gcsUrl}"`, {
+                stdio: 'inherit',
+                timeout: 300000  // 5 minute timeout
+            });
+
+            this.log('Download complete. Extracting...', 'success');
+
+            // Extract (with 2 minute timeout to prevent hanging)
+            execSync(`tar -xzf "${tarPath}" -C "${this.cacheDir}"`, {
+                stdio: 'inherit',
+                timeout: 120000  // 2 minute timeout
+            });
+
+            // Verify extraction
+            if (this.checkModelExists()) {
+                this.log('FastEmbed model installed successfully!', 'success');
+
+                // Clean up tar file
+                fs.unlinkSync(tarPath);
+
+                return true;
+            } else {
+                this.log('Model extraction failed', 'error');
+                return false;
+            }
+        } catch (error) {
+            this.log(`Download failed: ${error.message}`, 'error');
+            return false;
+        }
+    }
+
+    configureDockerCompose() {
+        this.log('Configuring docker-compose for offline model...', 'info');
+
+        const dockerComposePath = path.join(process.cwd(), 'docker-compose.yaml');
+
+        if (!fs.existsSync(dockerComposePath)) {
+            this.log('docker-compose.yaml not found, skipping configuration', 'warning');
+            return false;
+        }
+
+        try {
+            const content = fs.readFileSync(dockerComposePath, 'utf8');
+
+            // Check if already configured
+            if (content.includes('HF_HUB_OFFLINE')) {
+                this.log('docker-compose already configured for offline mode', 'success');
+                return true;
+            }
+
+            // Line-by-line processing is more reliable than regex for YAML
+            const lines = content.split('\n');
+            const services = ['importer', 'watcher', 'streaming-importer', 'async-importer', 'safe-watcher', 'mcp-server'];
+            let currentService = null;
+            let inEnvironment = false;
+            let environmentIndent = '';
+
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                const trimmed = line.trim();
+
+                // Track which service we're in
+                for (const service of services) {
+                    if (trimmed === `${service}:`) {
+                        currentService = service;
+                        inEnvironment = false;
+                        break;
+                    }
+                }
+
+                // Detect environment section
+                if (currentService && trimmed === 'environment:') {
+                    inEnvironment = true;
+                    environmentIndent = line.match(/^(\s+)/)?.[1] || '    ';
+                }
+
+                // Add HF_HUB_OFFLINE after first environment entry
+                if (inEnvironment && trimmed.startsWith('-') && !content.includes('HF_HUB_OFFLINE')) {
+                    lines.splice(i + 1, 0, `${environmentIndent}  - HF_HUB_OFFLINE=1`);
+                    inEnvironment = false;
+                }
+
+                // Add volume mount after volumes section
+                if (currentService && trimmed === 'volumes:' && !content.includes('.cache/fastembed')) {
+                    const volumeIndent = line.match(/^(\s+)/)?.[1] || '    ';
+                    // Find next line with volume entry
+                    if (lines[i + 1] && lines[i + 1].trim().startsWith('-')) {
+                        lines.splice(i + 2, 0, `${volumeIndent}  - ~/.cache/fastembed:/root/.cache/fastembed:ro`);
+                    }
+                }
+
+                // Reset when we exit a service (next service or same-level key)
+                if (currentService && line.match(/^\s{0,2}\w+:/) && !trimmed.startsWith(`${currentService}:`)) {
+                    currentService = null;
+                    inEnvironment = false;
+                }
+            }
+
+            // Write back
+            fs.writeFileSync(dockerComposePath, lines.join('\n'));
+            this.log('docker-compose.yaml updated for offline mode', 'success');
+            return true;
+        } catch (error) {
+            this.log(`Failed to update docker-compose: ${error.message}`, 'error');
+            return false;
+        }
+    }
+
+    configureMCPServer() {
+        this.log('Configuring MCP server for offline model...', 'info');
+
+        const mcpRunScript = path.join(process.cwd(), 'mcp-server', 'run-mcp.sh');
+
+        if (!fs.existsSync(mcpRunScript)) {
+            this.log('run-mcp.sh not found, skipping configuration', 'warning');
+            return false;
+        }
+
+        try {
+            let content = fs.readFileSync(mcpRunScript, 'utf8');
+
+            // Check if already configured
+            if (content.includes('HF_HUB_OFFLINE')) {
+                this.log('MCP server already configured for offline mode', 'success');
+                return true;
+            }
+
+            // Add exports at the beginning
+            const exports = `
+# Offline FastEmbed configuration (auto-added by installer)
+export HF_HUB_OFFLINE=1
+export FASTEMBED_CACHE_PATH="$HOME/.cache/fastembed"
+
+`;
+
+            // Insert after shebang
+            content = content.replace(/(#!\/bin\/bash\n)/, `$1${exports}`);
+
+            fs.writeFileSync(mcpRunScript, content);
+            this.log('MCP server configured for offline mode', 'success');
+            return true;
+        } catch (error) {
+            this.log(`Failed to update run-mcp.sh: ${error.message}`, 'error');
+            return false;
+        }
+    }
+
+    async run() {
+        this.log('🔍 Checking FastEmbed model availability...', 'info');
+
+        // Check if model already exists
+        if (this.checkModelExists()) {
+            this.log('FastEmbed model already installed ✓', 'success');
+            return true;
+        }
+
+        // Test HuggingFace connectivity
+        const hfAccessible = await this.testHuggingFace();
+
+        if (!hfAccessible) {
+            this.log('Corporate proxy detected - using Google Cloud Storage mirror', 'warning');
+
+            // Download from GCS
+            if (!this.downloadFromGCS()) {
+                this.log('Failed to download model from GCS', 'error');
+                return false;
+            }
+
+            // Configure for offline use
+            this.configureDockerCompose();
+            this.configureMCPServer();
+
+            this.log('✅ FastEmbed configured for offline use', 'success');
+            this.log('Your installation will now work behind corporate proxies', 'info');
+            return true;
+        }
+
+        // HuggingFace is accessible, let Python handle the download
+        this.log('HuggingFace accessible - standard installation will work', 'info');
+        return true;
+    }
+}
+
+// Run if called directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+    const fallback = new FastEmbedFallback();
+    fallback.run().catch(error => {
+        console.error('FastEmbed fallback failed:', error);
+        process.exit(1);
+    });
+}
+
+export default FastEmbedFallback;

package/installer/postinstall.js

@@ -2,7 +2,6 @@
 
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
-import StatuslineSetup from './statusline-setup.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -10,18 +9,24 @@ const __dirname = dirname(__filename);
 // Only show message if not in development
 if (!process.cwd().includes('claude-self-reflect')) {
   console.log('\n🎉 Claude Self-Reflect installed!\n');
-  console.log('Run "claude-self-reflect setup" to configure your installation.\n');
+  console.log('🔍 Checking installation...\n');
 
-  // Attempt to setup statusline integration automatically
-  console.log('\n📊 Setting up Claude Code statusline integration...');
-  const statuslineSetup = new StatuslineSetup();
-  statuslineSetup.run().then(success => {
-    if (success) {
-      console.log('✅ Statusline integration configured automatically!');
-    } else {
-      console.log('⚠️ Statusline integration requires manual setup. Run "claude-self-reflect setup" for help.');
-    }
+  // Import and run update manager for comprehensive setup
+  import('./update-manager.js').then(module => {
+    const UpdateManager = module.default;
+    const manager = new UpdateManager();
+    manager.run().then(() => {
+      console.log('\n✅ Installation complete!');
+      console.log('\n📋 Next steps:');
+      console.log('   1. Run: claude-self-reflect setup');
+      console.log('   2. Configure your embedding preferences');
+      console.log('   3. Start using Claude with perfect memory!\n');
+    }).catch(error => {
+      console.log('\n⚠️  Setup encountered issues:', error.message);
+      console.log('   Run "claude-self-reflect update" to fix any problems\n');
+    });
   }).catch(error => {
-    console.log('⚠️ Statusline setup skipped:', error.message);
+    console.log('⚠️  Could not run automatic setup');
+    console.log('   Run "claude-self-reflect setup" to configure manually\n');
   });
 }

package/installer/statusline-setup.js

@@ -23,6 +23,34 @@ class StatuslineSetup {
         this.statuslineBackup = path.join(this.claudeDir, 'statusline-wrapper.sh.backup');
     }
 
+    checkCCStatusline() {
+        try {
+            execSync('npm list -g cc-statusline', { stdio: 'ignore' });
+            this.log('cc-statusline is installed', 'success');
+            return true;
+        } catch {
+            this.log('cc-statusline not found', 'warning');
+            return false;
+        }
+    }
+
+    installCCStatusline() {
+        if (this.checkCCStatusline()) {
+            return true;
+        }
+
+        this.log('Installing cc-statusline...', 'info');
+        try {
+            execSync('npm install -g cc-statusline', { stdio: 'inherit' });
+            this.log('cc-statusline installed successfully', 'success');
+            return true;
+        } catch (error) {
+            this.log(`Failed to install cc-statusline: ${error.message}`, 'error');
+            this.log('Statusline features will not be available', 'warning');
+            return false;
+        }
+    }
+
     log(message, type = 'info') {
         const colors = {
             info: '\x1b[36m',
@@ -34,6 +62,15 @@ class StatuslineSetup {
     }
 
     checkPrerequisites() {
+        // Check npm is available
+        try {
+            execSync('npm --version', { stdio: 'ignore' });
+        } catch {
+            this.log('npm is required but not found', 'error');
+            this.log('Please install Node.js and npm from nodejs.org', 'error');
+            return false;
+        }
+
         // 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');
@@ -67,15 +104,48 @@ class StatuslineSetup {
                 }
             }
 
+            // Try user-local installation first (no sudo needed)
+            const userBin = path.join(this.homeDir, 'bin');
+            const userLocalBin = path.join(userBin, 'csr-status');
+
+            if (!fs.existsSync(userBin)) {
+                fs.mkdirSync(userBin, { recursive: true });
+            }
+
+            // Create symlink in ~/bin
+            try {
+                if (fs.existsSync(userLocalBin)) {
+                    fs.unlinkSync(userLocalBin);
+                }
+                fs.symlinkSync(this.csrScript, userLocalBin);
+                // Note: Don't chmod symlink - ensure source script is executable instead
+
+                this.log('csr-status installed to ~/bin (no sudo required)', 'success');
+                this.log('Add ~/bin to PATH: export PATH="$HOME/bin:$PATH"', 'info');
+
+                // Check if ~/bin is in PATH
+                const pathDirs = process.env.PATH.split(':');
+                if (!pathDirs.includes(userBin) && !pathDirs.includes('~/bin')) {
+                    this.log('⚠️ Add this to ~/.bashrc or ~/.zshrc:', 'warning');
+                    this.log('   export PATH="$HOME/bin:$PATH"', 'info');
+                }
+
+                return true;
+            } catch (userError) {
+                this.log(`User-local install failed: ${userError.message}`, 'warning');
+            }
+
+            // Fallback to global install if user has sudo access
+            if (needsSudo) {
+                this.log('Attempting global install (requires sudo)...', 'info');
+                this.log('Corporate machines may not allow this - using user-local is fine', 'info');
+            }
+
             // 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
@@ -87,10 +157,10 @@ class StatuslineSetup {
             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;
+            this.log('Statusline installation skipped (no sudo access)', 'info');
+            this.log('This is normal on corporate machines', 'info');
+            this.log('✅ Core MCP search works fine without statusline!', 'success');
+            return false;  // Return false but don't treat as critical error
         }
     }
 
@@ -228,6 +298,7 @@ class StatuslineSetup {
         }
 
         const steps = [
+            { name: 'Install cc-statusline', fn: () => this.installCCStatusline() },
             { name: 'Install global command', fn: () => this.installGlobalCommand() },
             { name: 'Patch statusline wrapper', fn: () => this.patchStatuslineWrapper() },
             { name: 'Validate integration', fn: () => this.validateIntegration() }

package/installer/update-manager.js

@@ -0,0 +1,318 @@
+#!/usr/bin/env node
+/**
+ * Update Manager
+ * Detects and fixes missing features, updates configurations
+ * Ensures user's installation matches the package capabilities
+ */
+
+import { execSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { fileURLToPath } from 'url';
+import StatuslineSetup from './statusline-setup.js';
+import FastEmbedFallback from './fastembed-fallback.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+class UpdateManager {
+    constructor() {
+        this.homeDir = os.homedir();
+        this.packageRoot = path.dirname(__dirname);
+    }
+
+    log(message, type = 'info') {
+        const colors = {
+            info: '\x1b[36m',
+            success: '\x1b[32m',
+            warning: '\x1b[33m',
+            error: '\x1b[31m'
+        };
+        const icons = {
+            info: 'ℹ',
+            success: '✓',
+            warning: '⚠',
+            error: '✗'
+        };
+        console.log(`${colors[type]}${icons[type]} ${message}\x1b[0m`);
+    }
+
+    // Feature checks
+    async checkCCStatusline() {
+        try {
+            execSync('npm list -g cc-statusline', { stdio: 'ignore' });
+            return { installed: true, name: 'cc-statusline', critical: false };
+        } catch {
+            return { installed: false, name: 'cc-statusline', critical: false, fix: () => this.installCCStatusline() };
+        }
+    }
+
+    async checkCSRStatusScript() {
+        const userBin = path.join(this.homeDir, 'bin', 'csr-status');
+        const globalBin = '/usr/local/bin/csr-status';
+
+        const exists = fs.existsSync(userBin) || fs.existsSync(globalBin);
+        return {
+            installed: exists,
+            name: 'csr-status command',
+            critical: false,
+            fix: () => this.installCSRStatus()
+        };
+    }
+
+    async checkFastEmbedModel() {
+        const modelPath = path.join(this.homeDir, '.cache', 'fastembed', 'sentence-transformers-all-MiniLM-L6-v2');
+        const exists = fs.existsSync(modelPath);
+
+        return {
+            installed: exists,
+            name: 'FastEmbed model',
+            critical: true,
+            fix: () => this.installFastEmbed()
+        };
+    }
+
+    async checkASTGrep() {
+        // Check for both 'ast-grep' (brew) and 'sg' (npm) binaries
+        try {
+            execSync('ast-grep --version', { stdio: 'ignore' });
+            return { installed: true, name: 'AST-Grep', critical: false };
+        } catch {
+            // Try 'sg' binary (npm install -g @ast-grep/cli)
+            try {
+                execSync('sg --version', { stdio: 'ignore' });
+                return { installed: true, name: 'AST-Grep (sg)', critical: false };
+            } catch {
+                return {
+                    installed: false,
+                    name: 'AST-Grep (optional)',
+                    critical: false,
+                    fix: () => this.suggestASTGrep()
+                };
+            }
+        }
+    }
+
+    async checkDocker() {
+        try {
+            execSync('docker info', { stdio: 'ignore' });
+            return { installed: true, name: 'Docker', critical: true };
+        } catch {
+            return {
+                installed: false,
+                name: 'Docker',
+                critical: true,
+                fix: null,
+                error: 'Docker is required. Install Docker Desktop from docker.com'
+            };
+        }
+    }
+
+    async checkQdrant() {
+        try {
+            const response = await fetch('http://localhost:6333');
+            if (response.ok) {
+                return { installed: true, name: 'Qdrant', critical: true };
+            }
+        } catch {}
+
+        return {
+            installed: false,
+            name: 'Qdrant',
+            critical: true,
+            fix: () => this.startQdrant()
+        };
+    }
+
+    async checkDockerComposeConfig() {
+        const composePath = path.join(this.packageRoot, 'docker-compose.yaml');
+
+        if (!fs.existsSync(composePath)) {
+            return { installed: false, name: 'docker-compose.yaml', critical: true, fix: null };
+        }
+
+        const content = fs.readFileSync(composePath, 'utf8');
+
+        // Check for offline FastEmbed configuration
+        const hasOfflineConfig = content.includes('HF_HUB_OFFLINE') && content.includes('fastembed:ro');
+
+        return {
+            installed: hasOfflineConfig,
+            name: 'Docker offline FastEmbed config',
+            critical: false,
+            fix: () => this.fixDockerConfig()
+        };
+    }
+
+    // Fix functions
+    async installCCStatusline() {
+        // Check npm is available
+        try {
+            execSync('npm --version', { stdio: 'ignore' });
+        } catch {
+            this.log('npm is required but not found', 'error');
+            this.log('Please install Node.js and npm from nodejs.org', 'error');
+            return false;
+        }
+
+        this.log('Installing cc-statusline...', 'info');
+        try {
+            execSync('npm install -g cc-statusline', { stdio: 'inherit' });
+            this.log('cc-statusline installed', 'success');
+            return true;
+        } catch (error) {
+            // Check for permission errors
+            const isPermissionError = error.code === 'EACCES' ||
+                                     error.code === 'EPERM' ||
+                                     (error.stderr && error.stderr.toString().includes('EACCES')) ||
+                                     (error.message && error.message.includes('permission'));
+
+            if (isPermissionError) {
+                this.log('Failed to install cc-statusline: Permission denied', 'error');
+                this.log('Try one of:', 'info');
+                this.log('  1. Run with elevated privileges: sudo npm install -g cc-statusline', 'info');
+                this.log('  2. Use a node version manager like nvm', 'info');
+                this.log('  3. Configure npm for user-local installs', 'info');
+            } else {
+                this.log(`Failed to install cc-statusline: ${error.message}`, 'error');
+            }
+            return false;
+        }
+    }
+
+    async installCSRStatus() {
+        this.log('Setting up csr-status command...', 'info');
+        const statuslineSetup = new StatuslineSetup();
+        return await statuslineSetup.installGlobalCommand();
+    }
+
+    async installFastEmbed() {
+        this.log('Setting up FastEmbed model...', 'info');
+        const fallback = new FastEmbedFallback();
+        return await fallback.run();
+    }
+
+    async suggestASTGrep() {
+        this.log('AST-Grep is optional but recommended for code quality features', 'info');
+        this.log('Install with: brew install ast-grep  (macOS)', 'info');
+        this.log('         or: npm install -g @ast-grep/cli', 'info');
+        return true;  // Not critical
+    }
+
+    async startQdrant() {
+        this.log('Starting Qdrant...', 'info');
+        try {
+            execSync('docker compose up -d qdrant', {
+                cwd: this.packageRoot,
+                stdio: 'inherit'
+            });
+            this.log('Qdrant started', 'success');
+            return true;
+        } catch (error) {
+            this.log(`Failed to start Qdrant: ${error.message}`, 'error');
+            return false;
+        }
+    }
+
+    async fixDockerConfig() {
+        this.log('Updating Docker Compose configuration...', 'info');
+        const fallback = new FastEmbedFallback();
+        return await fallback.configureDockerCompose();
+    }
+
+    async run() {
+        this.log('Analyzing installation...', 'info');
+        console.log();
+
+        // Run all checks
+        const checks = [
+            this.checkDocker(),
+            this.checkQdrant(),
+            this.checkFastEmbedModel(),
+            this.checkDockerComposeConfig(),
+            this.checkCCStatusline(),
+            this.checkCSRStatusScript(),
+            this.checkASTGrep()
+        ];
+
+        const results = await Promise.all(checks);
+
+        // Categorize results
+        const missing = results.filter(r => !r.installed);
+        const critical = missing.filter(r => r.critical);
+        const optional = missing.filter(r => !r.critical);
+
+        // Display status
+        console.log('📊 Installation Status:\n');
+        for (const result of results) {
+            const icon = result.installed ? '✅' : (result.critical ? '❌' : '⚠️ ');
+            const status = result.installed ? 'Installed' : 'Missing';
+            console.log(`${icon} ${result.name}: ${status}`);
+        }
+        console.log();
+
+        // Handle critical issues
+        const unresolvedCritical = [];
+        if (critical.length > 0) {
+            this.log(`Found ${critical.length} critical issue(s) that need fixing`, 'error');
+            console.log();
+
+            for (const issue of critical) {
+                if (issue.error) {
+                    this.log(issue.error, 'error');
+                    unresolvedCritical.push(issue);
+                } else if (issue.fix) {
+                    this.log(`Fixing: ${issue.name}...`, 'info');
+                    const success = await issue.fix();
+                    if (!success) {
+                        this.log(`Failed to fix: ${issue.name}`, 'error');
+                        unresolvedCritical.push(issue);
+                    }
+                } else {
+                    // Issue has no fix and no error message - track as unresolved
+                    this.log(`${issue.name} is missing (no automatic fix available)`, 'error');
+                    unresolvedCritical.push(issue);
+                }
+            }
+        }
+
+        // Handle optional issues
+        if (optional.length > 0) {
+            this.log(`Found ${optional.length} optional feature(s) to install`, 'warning');
+            console.log();
+
+            for (const issue of optional) {
+                if (issue.fix) {
+                    this.log(`Installing: ${issue.name}...`, 'info');
+                    await issue.fix();
+                }
+            }
+        }
+
+        // Final status
+        console.log();
+        if (unresolvedCritical.length === 0 && optional.length === 0) {
+            this.log('All features are up to date! ✨', 'success');
+        } else if (unresolvedCritical.length === 0) {
+            this.log('Core features are working. Optional features installed.', 'success');
+        } else {
+            this.log('Please address critical issues before using Claude Self-Reflect', 'error');
+            process.exit(1);
+        }
+
+        console.log();
+        this.log('Run "claude-self-reflect doctor" for detailed diagnostics', 'info');
+    }
+}
+
+// Run if called directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+    const manager = new UpdateManager();
+    manager.run().catch(error => {
+        console.error('Update failed:', error);
+        process.exit(1);
+    });
+}
+
+export default UpdateManager;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-self-reflect",
-  "version": "6.0.1",
+  "version": "6.0.2",
   "description": "Give Claude perfect memory of all your conversations - Installation wizard for Python MCP server",
   "keywords": [
     "claude",

package/shared/ast_grep_utils.py

@@ -0,0 +1,89 @@
+"""
+AST-Grep Utilities
+Gracefully handles AST-Grep availability for code quality features
+"""
+import shutil
+import subprocess
+from functools import wraps
+from typing import Optional
+
+def is_ast_grep_installed() -> bool:
+    """Check if ast-grep or sg (npm install) is available in PATH"""
+    return shutil.which('ast-grep') is not None or shutil.which('sg') is not None
+
+def get_ast_grep_command() -> Optional[str]:
+    """Get the available AST-Grep command (ast-grep or sg)"""
+    if shutil.which('ast-grep'):
+        return 'ast-grep'
+    elif shutil.which('sg'):
+        return 'sg'
+    return None
+
+def get_ast_grep_version() -> Optional[str]:
+    """Get installed AST-Grep version"""
+    cmd = get_ast_grep_command()
+    if not cmd:
+        return None
+
+    try:
+        result = subprocess.run(
+            [cmd, '--version'],
+            capture_output=True,
+            text=True,
+            timeout=5
+        )
+        if result.returncode == 0:
+            return result.stdout.strip()
+    except Exception:
+        pass
+
+    return None
+
+def check_ast_grep_or_warn(feature_name: str = "Quality analysis") -> bool:
+    """
+    Check if AST-Grep is installed, warn if not
+
+    Returns:
+        True if installed, False otherwise
+    """
+    if is_ast_grep_installed():
+        return True
+
+    print(f"⚠️  {feature_name} requires AST-Grep")
+    print("   This is an optional feature for advanced code quality analysis")
+    print()
+    print("   To install:")
+    print("   • macOS:  brew install ast-grep")
+    print("   • Linux:  npm install -g @ast-grep/cli")
+    print("   • Or:     Download from https://github.com/ast-grep/ast-grep/releases")
+    print()
+    print("   ✅ Core MCP functionality works fine without it!")
+    print()
+
+    return False
+
+def ast_grep_required(func):
+    """Decorator to mark functions that require AST-Grep"""
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        if not check_ast_grep_or_warn(func.__name__):
+            return None
+        return func(*args, **kwargs)
+
+    return wrapper
+
+# Example usage in scripts:
+# from shared.ast_grep_utils import ast_grep_required, check_ast_grep_or_warn
+#
+# @ast_grep_required
+# def run_quality_analysis():
+#     # AST-Grep code here
+#     pass
+#
+# if __name__ == "__main__":
+#     if check_ast_grep_or_warn("Code Quality Scanner"):
+#         # Run AST-Grep features
+#         pass
+#     else:
+#         # Fallback to basic analysis
+#         print("Running basic quality checks without AST-Grep...")