devbonzai 2.2.205 → 2.2.207

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devbonzai",
-  "version": "2.2.205",
+  "version": "2.2.207",
   "description": "Quickly set up a local file server in any repository for browser-based file access",
   "main": "cli.js",
   "bin": {

package/templates/handlers/scan_standards.js

@@ -6,20 +6,30 @@ const { listAllFiles } = require('../utils/fileList');
 const { getIgnorePatterns, shouldIgnore } = require('../utils/ignore');
 
 module.exports = async function scanStandards(req, res) {
+  console.log('🔵 [scan_standards] Endpoint hit');
+  
   try {
     const { projectPath, standards } = req.body;
+    console.log('🔵 [scan_standards] projectPath:', projectPath);
+    console.log('🔵 [scan_standards] standards:', Array.isArray(standards) ? standards.length + ' rules' : 'string input');
 
     if (!projectPath || !standards) {
+      console.log('❌ [scan_standards] Error: projectPath and standards required');
       return res.status(400).json({ error: 'projectPath and standards required' });
     }
 
     // Get file structure for context
+    console.log('🔵 [scan_standards] Getting file tree...');
     const fileTree = getFileTree(projectPath);
+    console.log('🔵 [scan_standards] File tree entries:', fileTree.split('\n').length);
 
     // Sample a few key files for AI to analyze (don't send entire codebase)
+    console.log('🔵 [scan_standards] Getting sample files...');
     const sampleFiles = getSampleFiles(projectPath, 10);
+    console.log('🔵 [scan_standards] Sample files found:', sampleFiles.length);
+    sampleFiles.forEach(f => console.log('   📄', f.path, `(${f.size} bytes)`));
 
-    const prompt = `You are analyzing a codebase for architectural violations.
+    const prompt = `Analyze this codebase for architectural violations.
 
 PROJECT STRUCTURE:
 ${fileTree}
@@ -27,25 +37,22 @@ ${fileTree}
 SAMPLE FILES:
 ${sampleFiles.map(f => `=== ${f.path} ===\n${f.content.substring(0, 500)}...\n`).join('\n')}
 
-ARCHITECTURAL STANDARDS TO CHECK:
+STANDARDS TO CHECK:
 ${Array.isArray(standards) ? standards.map((s, i) => `${i + 1}. ${s}`).join('\n') : standards}
 
-Analyze the codebase and identify violations of these standards.
+CRITICAL: Your response must be ONLY a valid JSON array. No markdown, no explanation, no summary text.
+Start your response with [ and end with ]. Nothing else.
 
-Respond ONLY with a JSON array of violations:
-[
-  {
-    "rule": "Controllers should only handle HTTP requests",
-    "file": "src/controllers/UserController.ts",
-    "description": "Contains business logic and database queries",
-    "severity": "high"
-  }
-]
+Output format:
+[{"rule":"rule name","file":"path/to/file","description":"what violates it","severity":"high|medium|low"}]
 
-If no violations found, return empty array: []`;
+Empty if no violations: []`;
+
+    console.log('🔵 [scan_standards] Prompt length:', prompt.length, 'chars');
 
     // Use cursor-agent like prompt_agent does
     const args = ['--print', '--force', '--workspace', projectPath, prompt];
+    console.log('🔵 [scan_standards] Spawning cursor-agent...');
 
     const proc = spawn('cursor-agent', args, {
       cwd: projectPath,
@@ -53,37 +60,60 @@ If no violations found, return empty array: []`;
       stdio: ['ignore', 'pipe', 'pipe']
     });
 
+    console.log('🔵 [scan_standards] Process spawned, PID:', proc.pid);
+
     let stdout = '';
     let stderr = '';
 
     proc.stdout.on('data', (d) => {
-      stdout += d.toString();
+      const data = d.toString();
+      console.log('📤 [scan_standards] stdout chunk:', data.length, 'bytes');
+      stdout += data;
     });
 
     proc.stderr.on('data', (d) => {
-      stderr += d.toString();
+      const data = d.toString();
+      console.log('⚠️  [scan_standards] stderr chunk:', data.length, 'bytes');
+      stderr += data;
     });
 
     proc.on('error', (error) => {
-      console.error('Standards scan process error:', error);
+      console.error('❌ [scan_standards] Process error:', error.message);
       return res.status(500).json({ error: error.message });
     });
 
     proc.on('close', (code) => {
+      console.log('🔵 [scan_standards] Process closed with code:', code);
+      console.log('🔵 [scan_standards] stdout total:', stdout.length, 'bytes');
+      console.log('🔵 [scan_standards] stderr total:', stderr.length, 'bytes');
+
       if (code !== 0) {
-        console.error('Standards scan failed with code:', code);
+        console.error('❌ [scan_standards] Failed with code:', code);
+        console.error('❌ [scan_standards] stderr:', stderr);
         return res.status(500).json({ error: `Process exited with code ${code}`, stderr });
       }
 
       // Parse AI response
+      console.log('🔵 [scan_standards] Parsing response...');
       const jsonMatch = stdout.match(/\[[\s\S]*\]/);
-      const violations = jsonMatch ? JSON.parse(jsonMatch[0]) : [];
+      
+      if (!jsonMatch) {
+        console.log('⚠️  [scan_standards] No JSON array found in response');
+        console.log('⚠️  [scan_standards] Raw stdout:', stdout.substring(0, 500));
+      }
 
-      res.json({ violations });
+      try {
+        const violations = jsonMatch ? JSON.parse(jsonMatch[0]) : [];
+        console.log('✅ [scan_standards] Found', violations.length, 'violations');
+        res.json({ violations });
+      } catch (parseError) {
+        console.error('❌ [scan_standards] JSON parse error:', parseError.message);
+        res.status(500).json({ error: 'Failed to parse response', raw: stdout });
+      }
     });
 
   } catch (error) {
-    console.error('Standards scan error:', error);
+    console.error('❌ [scan_standards] Error:', error.message);
     res.status(500).json({ error: error.message });
   }
 };
@@ -99,7 +129,7 @@ function getFileTree(projectPath) {
     );
     return realFiles.slice(0, 200).join('\n'); // Limit to 200 entries
   } catch (e) {
-    console.error('Error getting file tree:', e);
+    console.error('❌ [scan_standards] Error getting file tree:', e);
     return 'Unable to read file tree';
   }
 }