devbonzai 2.2.21 → 2.2.202

package/package.json

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

package/templates/handlers/index.js

@@ -15,7 +15,8 @@ function indexHandler(req, res) {
       'POST /prompt_agent': 'Execute cursor-agent command (body: {prompt})',
       'POST /prompt_agent_stream': 'Execute cursor-agent with SSE streaming (body: {prompt})',
       'POST /revert_job': 'Revert to a previous commit (body: {beforeCommit})',
-      'POST /shutdown': 'Gracefully shutdown the server'
+      'POST /shutdown': 'Gracefully shutdown the server',
+      'POST /scan_standards': 'Analyze codebase against architectural standards (body: {projectPath, standards, apiKey?})'
     },
     example: 'Try: /list or /read?path=README.md'
   });

package/templates/handlers/scan_code_quality.js

@@ -25,10 +25,24 @@ module.exports = async function scanCodeQuality(req, res) {
     const ignorePatterns = getIgnorePatterns();
     const issues = [];
     
+    // Common build/output directories to always ignore
+    const defaultIgnoreGlobs = [
+      '**/node_modules/**',
+      '**/dist/**',
+      '**/build/**',
+      '**/static/**',
+      '**/out/**',
+      '**/.next/**',
+      '**/*.min.js',
+      '**/*.bundle.js',
+      '**/*.chunk.js'
+    ];
+    
     // Get all files (needed for multiple checks)
     const allFiles = glob.sync('**/*.{js,ts,jsx,tsx,py,java,go}', { 
       cwd: projectPath,
-      nodir: true
+      nodir: true,
+      ignore: defaultIgnoreGlobs
     });
     
     const files = allFiles.filter(file => !shouldIgnore(file, ignorePatterns));
@@ -54,7 +68,8 @@ module.exports = async function scanCodeQuality(req, res) {
     // 2. Check folder sizes
     if (willEnforceFolders) {
       const allFolders = glob.sync('**/', { 
-        cwd: projectPath
+        cwd: projectPath,
+        ignore: defaultIgnoreGlobs
       });
       
       const folders = allFolders.filter(folder => !shouldIgnore(folder, ignorePatterns));
@@ -96,8 +111,7 @@ module.exports = async function scanCodeQuality(req, res) {
               ecmaFeatures: { jsx: true }
             },
             rules: {
-              'no-unused-vars': willFlagDeadCode ? 'error' : 'off',
-              '@typescript-eslint/no-unused-vars': willFlagDeadCode ? 'error' : 'off'
+              'no-unused-vars': willFlagDeadCode ? 'error' : 'off'
             }
           }
         });
@@ -109,7 +123,7 @@ module.exports = async function scanCodeQuality(req, res) {
           const relativePath = path.relative(projectPath, result.filePath);
           
           result.messages.forEach(msg => {
-            if (msg.ruleId === 'no-unused-vars' || msg.ruleId === '@typescript-eslint/no-unused-vars') {
+            if (msg.ruleId === 'no-unused-vars') {
               issues.push({
                 type: 'unused_variable',
                 file: relativePath,

package/templates/handlers/scan_standards.js

@@ -0,0 +1,145 @@
+const fs = require('fs');
+const path = require('path');
+const glob = require('glob');
+const { Anthropic } = require('@anthropic-ai/sdk');
+const { listAllFiles } = require('../utils/fileList');
+const { getIgnorePatterns, shouldIgnore } = require('../utils/ignore');
+
+// Hardcoded API key as fallback
+const DEFAULT_API_KEY = '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';
+
+module.exports = async function scanStandards(req, res) {
+  try {
+    const { projectPath, standards, apiKey } = req.body;
+
+    if (!projectPath || !standards) {
+      return res.status(400).json({ error: 'projectPath and standards required' });
+    }
+
+    // Use provided apiKey or fall back to default
+    const anthropicApiKey = apiKey || DEFAULT_API_KEY;
+
+    // Get file structure for context
+    const fileTree = getFileTree(projectPath);
+
+    // Sample a few key files for AI to analyze (don't send entire codebase)
+    const sampleFiles = getSampleFiles(projectPath, 10);
+
+    const anthropic = new Anthropic({ apiKey: anthropicApiKey });
+
+    const prompt = `You are analyzing a codebase for architectural violations.
+
+PROJECT STRUCTURE:
+${fileTree}
+
+SAMPLE FILES:
+${sampleFiles.map(f => `=== ${f.path} ===\n${f.content.substring(0, 500)}...\n`).join('\n')}
+
+ARCHITECTURAL 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.
+
+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"
+  }
+]
+
+If no violations found, return empty array: []`;
+
+    const message = await anthropic.messages.create({
+      model: 'claude-sonnet-4-20250514',
+      max_tokens: 4000,
+      messages: [{ role: 'user', content: prompt }]
+    });
+
+    // Parse AI response
+    const responseText = message.content[0].text;
+    const jsonMatch = responseText.match(/\[[\s\S]*\]/);
+    const violations = jsonMatch ? JSON.parse(jsonMatch[0]) : [];
+
+    res.json({
+      violations,
+      tokensUsed: message.usage.input_tokens + message.usage.output_tokens,
+      cost: estimateCost(message.usage)
+    });
+
+  } catch (error) {
+    console.error('Standards scan error:', error);
+    res.status(500).json({ error: error.message });
+  }
+};
+
+function getFileTree(projectPath) {
+  try {
+    const files = listAllFiles(projectPath);
+    // Filter out virtual files (.function, .class, .method) for cleaner tree
+    const realFiles = files.filter(f => 
+      !f.endsWith('.function') && 
+      !f.endsWith('.class') && 
+      !f.endsWith('.method')
+    );
+    return realFiles.slice(0, 200).join('\n'); // Limit to 200 entries
+  } catch (e) {
+    console.error('Error getting file tree:', e);
+    return 'Unable to read file tree';
+  }
+}
+
+function getSampleFiles(projectPath, limit = 10) {
+  const ignorePatterns = getIgnorePatterns();
+  
+  // Common build/output directories to always ignore
+  const defaultIgnoreGlobs = [
+    '**/node_modules/**',
+    '**/dist/**',
+    '**/build/**',
+    '**/static/**',
+    '**/out/**',
+    '**/.next/**',
+    '**/*.min.js',
+    '**/*.bundle.js',
+    '**/*.chunk.js'
+  ];
+
+  // Get representative files
+  const files = glob.sync('**/*.{js,ts,jsx,tsx,py,java,go}', {
+    cwd: projectPath,
+    nodir: true,
+    ignore: defaultIgnoreGlobs
+  });
+
+  // Filter using ignore patterns and sort by size, take top N
+  return files
+    .filter(f => !shouldIgnore(f, ignorePatterns))
+    .map(f => {
+      const fullPath = path.join(projectPath, f);
+      try {
+        const stat = fs.statSync(fullPath);
+        const content = fs.readFileSync(fullPath, 'utf8');
+        return {
+          path: f,
+          content,
+          size: stat.size
+        };
+      } catch (e) {
+        return null;
+      }
+    })
+    .filter(Boolean)
+    .sort((a, b) => b.size - a.size)
+    .slice(0, limit);
+}
+
+function estimateCost(usage) {
+  // Claude Sonnet 4 pricing
+  const inputCost = (usage.input_tokens / 1000000) * 3.00;
+  const outputCost = (usage.output_tokens / 1000000) * 15.00;
+  return (inputCost + outputCost).toFixed(4);
+}
+

package/templates/receiver.js

@@ -19,6 +19,7 @@ const promptAgentStreamHandler = require('./handlers/prompt_agent_stream');
 const revertJobHandler = require('./handlers/revert_job');
 const shutdownHandler = require('./handlers/shutdown');
 const scanCodeQualityHandler = require('./handlers/scan_code_quality');
+const scanStandardsHandler = require('./handlers/scan_standards');
 
 const app = express();
 
@@ -41,6 +42,7 @@ app.post('/prompt_agent_stream', promptAgentStreamHandler);
 app.post('/revert_job', revertJobHandler);
 app.post('/shutdown', shutdownHandler);
 app.post('/scan_code_quality', scanCodeQualityHandler);
+app.post('/scan_standards', scanStandardsHandler);
 
 const port = 3001;
 app.listen(port, () => {