claude-self-reflect 6.0.2 → 6.0.4

package/installer/fastembed-fallback.js

@@ -6,7 +6,7 @@
 
 import fs from 'fs';
 import path from 'path';
-import { execSync } from 'child_process';
+import { execSync, spawnSync } from 'child_process';
 import https from 'https';
 import os from 'os';
 
@@ -65,20 +65,30 @@ class FastEmbedFallback {
 
         try {
             // Download with curl (handles proxies better than Node's https)
+            // SECURITY: Use array-based arguments to prevent shell injection
             this.log(`Downloading ${this.modelFile} (79MB)...`, 'info');
-            execSync(`curl -L -o "${tarPath}" "${this.gcsUrl}"`, {
+            const curlResult = spawnSync('curl', ['-L', '-o', tarPath, this.gcsUrl], {
                 stdio: 'inherit',
                 timeout: 300000  // 5 minute timeout
             });
 
+            if (curlResult.error || curlResult.status !== 0) {
+                throw new Error(`curl failed: ${curlResult.error?.message || `exit code ${curlResult.status}`}`);
+            }
+
             this.log('Download complete. Extracting...', 'success');
 
             // Extract (with 2 minute timeout to prevent hanging)
-            execSync(`tar -xzf "${tarPath}" -C "${this.cacheDir}"`, {
+            // SECURITY: Use array-based arguments to prevent shell injection
+            const tarResult = spawnSync('tar', ['-xzf', tarPath, '-C', this.cacheDir], {
                 stdio: 'inherit',
                 timeout: 120000  // 2 minute timeout
             });
 
+            if (tarResult.error || tarResult.status !== 0) {
+                throw new Error(`tar extraction failed: ${tarResult.error?.message || `exit code ${tarResult.status}`}`);
+            }
+
             // Verify extraction
             if (this.checkModelExists()) {
                 this.log('FastEmbed model installed successfully!', 'success');

package/installer/postinstall.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 import { fileURLToPath } from 'url';
-import { dirname, join } from 'path';
+import { dirname } from 'path';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);

package/installer/statusline-setup.js

@@ -118,7 +118,7 @@ class StatuslineSetup {
                     fs.unlinkSync(userLocalBin);
                 }
                 fs.symlinkSync(this.csrScript, userLocalBin);
-                // Note: Don't chmod symlink - ensure source script is executable instead
+                // Note: Symlink permissions don't matter - source script permissions are used
 
                 this.log('csr-status installed to ~/bin (no sudo required)', 'success');
                 this.log('Add ~/bin to PATH: export PATH="$HOME/bin:$PATH"', 'info');

package/installer/update-manager.js

@@ -42,9 +42,9 @@ class UpdateManager {
     async checkCCStatusline() {
         try {
             execSync('npm list -g cc-statusline', { stdio: 'ignore' });
-            return { installed: true, name: 'cc-statusline', critical: false };
+            return { installed: true, name: 'cc-statusline', critical: true };
         } catch {
-            return { installed: false, name: 'cc-statusline', critical: false, fix: () => this.installCCStatusline() };
+            return { installed: false, name: 'cc-statusline', critical: true, fix: () => this.installCCStatusline() };
         }
     }
 
@@ -77,18 +77,18 @@ class UpdateManager {
         // 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 };
+            return { installed: true, name: 'AST-Grep', critical: true };
         } 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 };
+                return { installed: true, name: 'AST-Grep (sg)', critical: true };
             } catch {
                 return {
                     installed: false,
-                    name: 'AST-Grep (optional)',
-                    critical: false,
-                    fix: () => this.suggestASTGrep()
+                    name: 'AST-Grep',
+                    critical: true,
+                    fix: () => this.installASTGrep()
                 };
             }
         }
@@ -110,12 +110,45 @@ class UpdateManager {
     }
 
     async checkQdrant() {
+        // Check if fetch is available (Node.js 18+)
+        if (typeof fetch === 'undefined') {
+            this.log('fetch not available, skipping Qdrant health check', 'warning');
+            return {
+                installed: false,
+                name: 'Qdrant',
+                critical: true,
+                fix: () => this.startQdrant(),
+                error: 'Cannot verify Qdrant (fetch not available)'
+            };
+        }
+
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 3000); // 3 second timeout
+
         try {
-            const response = await fetch('http://localhost:6333');
+            const response = await fetch('http://localhost:6333', {
+                signal: controller.signal
+            });
+
+            // Clear timeout immediately after successful fetch
+            clearTimeout(timeout);
+
             if (response.ok) {
+                // Timeout already cleared above, safe to return
                 return { installed: true, name: 'Qdrant', critical: true };
+            } else {
+                // Timeout already cleared above, log and fall through
+                this.log(`Qdrant responded with status: ${response.status}`, 'warning');
+            }
+        } catch (error) {
+            clearTimeout(timeout);
+
+            if (error.name === 'AbortError') {
+                this.log('Qdrant health check timed out after 3 seconds', 'warning');
+            } else {
+                this.log(`Qdrant health check failed: ${error.message}`, 'warning');
             }
-        } catch {}
+        }
 
         return {
             installed: false,
@@ -193,25 +226,71 @@ class UpdateManager {
         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 installASTGrep() {
+        // Try npm installation first (works on all platforms)
+        this.log('Installing AST-Grep via npm...', 'info');
+        try {
+            execSync('npm install -g @ast-grep/cli', { stdio: 'inherit' });
+            this.log('AST-Grep installed successfully', 'success');
+            return true;
+        } catch (npmError) {
+            // Check for permission errors
+            const isPermissionError = npmError.code === 'EACCES' ||
+                                     npmError.code === 'EPERM' ||
+                                     (npmError.stderr && npmError.stderr.toString().includes('EACCES')) ||
+                                     (npmError.message && npmError.message.includes('permission'));
+
+            if (isPermissionError) {
+                this.log('Failed to install AST-Grep via npm: Permission denied', 'error');
+                this.log('Alternative installation methods:', 'info');
+                this.log('  1. With sudo: sudo npm install -g @ast-grep/cli', 'info');
+                this.log('  2. With brew: brew install ast-grep  (macOS/Linux)', 'info');
+                this.log('  3. Use nvm for user-local npm installs', 'info');
+                return false;
+            }
+
+            // If npm fails for other reasons, try suggesting brew on macOS
+            if (process.platform === 'darwin') {
+                this.log('npm installation failed. Checking for Homebrew...', 'warning');
+                try {
+                    execSync('brew --version', { stdio: 'ignore' });
+                    this.log('Install AST-Grep with: brew install ast-grep', 'info');
+                } catch {
+                    this.log('Homebrew not found. Install from: https://brew.sh', 'info');
+                }
+            }
+
+            this.log(`AST-Grep installation failed: ${npmError.message}`, 'error');
+            return false;
+        }
     }
 
     async startQdrant() {
         this.log('Starting Qdrant...', 'info');
+
+        // Try Docker Compose v2 first (docker compose)
         try {
             execSync('docker compose up -d qdrant', {
                 cwd: this.packageRoot,
                 stdio: 'inherit'
             });
-            this.log('Qdrant started', 'success');
+            this.log('Qdrant started (Docker Compose v2)', 'success');
             return true;
-        } catch (error) {
-            this.log(`Failed to start Qdrant: ${error.message}`, 'error');
-            return false;
+        } catch (v2Error) {
+            this.log('Docker Compose v2 failed, trying v1...', 'warning');
+
+            // Fallback to Docker Compose v1 (docker-compose)
+            try {
+                execSync('docker-compose up -d qdrant', {
+                    cwd: this.packageRoot,
+                    stdio: 'inherit'
+                });
+                this.log('Qdrant started (Docker Compose v1)', 'success');
+                return true;
+            } catch (v1Error) {
+                this.log(`Failed to start Qdrant with both v1 and v2: ${v1Error.message}`, 'error');
+                return false;
+            }
         }
     }
 
@@ -225,18 +304,38 @@ class UpdateManager {
         this.log('Analyzing installation...', 'info');
         console.log();
 
-        // Run all checks
+        // Run all checks with Promise.allSettled to prevent throw on first failure
+        // Store checks as objects with name property for maintainability
         const checks = [
-            this.checkDocker(),
-            this.checkQdrant(),
-            this.checkFastEmbedModel(),
-            this.checkDockerComposeConfig(),
-            this.checkCCStatusline(),
-            this.checkCSRStatusScript(),
-            this.checkASTGrep()
+            { name: 'Docker', fn: () => this.checkDocker() },
+            { name: 'Qdrant', fn: () => this.checkQdrant() },
+            { name: 'FastEmbed', fn: () => this.checkFastEmbedModel() },
+            { name: 'Docker Config', fn: () => this.checkDockerComposeConfig() },
+            { name: 'cc-statusline', fn: () => this.checkCCStatusline() },
+            { name: 'csr-status', fn: () => this.checkCSRStatusScript() },
+            { name: 'AST-Grep', fn: () => this.checkASTGrep() }
         ];
 
-        const results = await Promise.all(checks);
+        const settledResults = await Promise.allSettled(checks.map(c => c.fn()));
+
+        // Convert settled results to standard format, treating rejections as failures
+        const results = settledResults.map((result, index) => {
+            if (result.status === 'fulfilled') {
+                return result.value;
+            } else {
+                // Rejected check - treat as critical failure
+                this.log(
+                    `Check failed: ${checks[index].name} - ${result.reason?.message || result.reason}`,
+                    'error'
+                );
+                return {
+                    installed: false,
+                    critical: true,
+                    name: checks[index].name,
+                    error: `Check threw error: ${result.reason?.message || result.reason}`
+                };
+            }
+        });
 
         // Categorize results
         const missing = results.filter(r => !r.installed);
@@ -268,6 +367,40 @@ class UpdateManager {
                     if (!success) {
                         this.log(`Failed to fix: ${issue.name}`, 'error');
                         unresolvedCritical.push(issue);
+                    } else {
+                        // Re-verify the fix worked by re-running the check
+                        this.log(`Verifying fix for ${issue.name}...`, 'info');
+                        const recheckName = issue.name.toLowerCase();
+                        let recheckResult;
+
+                        if (recheckName.includes('docker') && recheckName.includes('config')) {
+                            // Docker config specific check
+                            recheckResult = await this.checkDockerComposeConfig();
+                        } else if (recheckName.includes('docker') && !recheckName.includes('config')) {
+                            recheckResult = await this.checkDocker();
+                        } else if (recheckName.includes('qdrant')) {
+                            // Give Qdrant a moment to come online before rechecking
+                            this.log('Waiting 5 seconds for Qdrant to start...', 'info');
+                            await new Promise(resolve => setTimeout(resolve, 5000));
+                            recheckResult = await this.checkQdrant();
+                        } else if (recheckName.includes('fastembed')) {
+                            recheckResult = await this.checkFastEmbedModel();
+                        } else if (recheckName.includes('cc-statusline')) {
+                            recheckResult = await this.checkCCStatusline();
+                        } else if (recheckName.includes('csr-status')) {
+                            recheckResult = await this.checkCSRStatusScript();
+                        } else if (recheckName.includes('ast-grep')) {
+                            recheckResult = await this.checkASTGrep();
+                        }
+
+                        // Guard against undefined recheckResult (no matching verifier)
+                        if (recheckResult === undefined) {
+                            this.log(`No verifier found for ${issue.name} - cannot verify fix`, 'error');
+                            unresolvedCritical.push(issue);
+                        } else if (!recheckResult.installed) {
+                            this.log(`Fix verification failed for ${issue.name}`, 'error');
+                            unresolvedCritical.push(issue);
+                        }
                     }
                 } else {
                     // Issue has no fix and no error message - track as unresolved

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-self-reflect",
-  "version": "6.0.2",
+  "version": "6.0.4",
   "description": "Give Claude perfect memory of all your conversations - Installation wizard for Python MCP server",
   "keywords": [
     "claude",
@@ -31,7 +31,8 @@
   "author": "Claude-Self-Reflect Contributors",
   "type": "module",
   "bin": {
-    "claude-self-reflect": "installer/cli.js"
+    "claude-self-reflect": "installer/cli.js",
+    "csr-status": "scripts/csr-status"
   },
   "files": [
     "installer/**/*.js",

package/src/runtime/embedding_service.py

@@ -43,8 +43,10 @@ class LocalEmbeddingProvider(EmbeddingProvider):
         """Initialize the FastEmbed model."""
         try:
             from fastembed import TextEmbedding
-            self.model = TextEmbedding(model_name="BAAI/bge-small-en-v1.5")
-            logger.info("Initialized local FastEmbed model (384 dimensions)")
+            # CRITICAL: Use the correct model that matches the rest of the system
+            # This must be sentence-transformers/all-MiniLM-L6-v2 (384 dimensions)
+            self.model = TextEmbedding(model_name="sentence-transformers/all-MiniLM-L6-v2")
+            logger.info("Initialized local FastEmbed model: sentence-transformers/all-MiniLM-L6-v2 (384 dimensions)")
         except ImportError as e:
             logger.error("FastEmbed not installed. Install with: pip install fastembed")
             raise