bonzai-burn 1.0.23 → 1.0.24

package/package.json

@@ -1,16 +1,13 @@
 {
   "name": "bonzai-burn",
-  "version": "1.0.23",
+  "version": "1.0.24",
   "description": "Git branch-based cleanup tool with bburn, baccept, and brevert commands",
   "type": "module",
   "main": "src/index.js",
   "bin": {
     "bonzai-burn": "./src/index.js",
     "bburn": "./src/bburn.js",
-    "baccept": "./src/baccept.js",
-    "brevert": "./src/brevert.js",
-    "bgraph": "./src/bgraph.js",
-    "bonzai-mcp": "./src/mcp-server.js"
+    "bgraph": "./src/bgraph.js"
   },
   "keywords": [
     "git",

package/payload-bonzai/config.json

@@ -1,15 +1,24 @@
 {
-  "provider": "cursor",
-  "debugMode": true,
-  "autoBurn": false,
+  "customChecks": {
+    "requirements": "Remove unused imports and variables. Remove all console log statements."
+  },
   "lineLimit": {
-    "enabled": false,
-    "limit": 70,
+    "enabled": true,
+    "limit": 300,
     "prompt": "Split any file with over {{ linelimit }} lines into smaller files."
   },
   "folderLimit": {
-    "enabled": false,
-    "limit": 10,
+    "enabled": true,
+    "limit": 15,
     "prompt": "Split any folder with over {{ folderlimit }} items into smaller, compartmentalized folders."
+  },
+  "testCheck": {
+    "enabled": false,
+    "patterns": {
+      ".vue": ".test.js",
+      ".jsx": ".test.jsx",
+      ".tsx": ".test.tsx"
+    },
+    "prompt": "Create test files for components that are missing them."
   }
 }

package/src/analyzer.js

@@ -0,0 +1,362 @@
+import { execSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+
+/**
+ * Static analyzer for codebase
+ * Runs ESLint, TypeScript, and custom checks based on config.json
+ */
+
+/**
+ * List all files recursively, respecting common ignore patterns
+ */
+function listAllFiles(dir, basePath = '') {
+  const ignorePatterns = ['node_modules', '.git', '.DS_Store', 'dist', 'build', 'coverage', 'bonzai'];
+  let results = [];
+
+  try {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      const relativePath = path.join(basePath, entry.name);
+
+      if (ignorePatterns.some(p => entry.name === p) || entry.name.startsWith('.')) {
+        continue;
+      }
+
+      if (entry.isDirectory()) {
+        results = results.concat(listAllFiles(fullPath, relativePath));
+      } else {
+        results.push({
+          path: relativePath,
+          fullPath: fullPath
+        });
+      }
+    }
+  } catch (e) {
+    // Directory access error, skip
+  }
+
+  return results;
+}
+
+/**
+ * Run ESLint to detect unused imports and variables
+ */
+function runEslintAnalysis(rootDir) {
+  const issues = [];
+
+  try {
+    execSync('which eslint', { encoding: 'utf-8', stdio: 'pipe' });
+  } catch {
+    return { issues, skipped: true, reason: 'ESLint not installed' };
+  }
+
+  try {
+    const result = execSync(
+      `eslint "${rootDir}" --format json --rule "no-unused-vars: error" 2>/dev/null || true`,
+      { encoding: 'utf-8', stdio: 'pipe', maxBuffer: 50 * 1024 * 1024 }
+    );
+
+    if (result.trim()) {
+      const eslintOutput = JSON.parse(result);
+
+      for (const file of eslintOutput) {
+        for (const msg of file.messages || []) {
+          if (msg.ruleId && msg.ruleId.includes('no-unused')) {
+            issues.push({
+              file: path.relative(rootDir, file.filePath),
+              line: msg.line,
+              message: msg.message,
+              rule: msg.ruleId
+            });
+          }
+        }
+      }
+    }
+  } catch (e) {
+    return { issues, skipped: true, reason: 'ESLint analysis failed' };
+  }
+
+  return { issues, skipped: false };
+}
+
+/**
+ * Run TypeScript compiler to check for unused locals
+ */
+function runTypeScriptAnalysis(rootDir) {
+  const issues = [];
+  const tsconfigPath = path.join(rootDir, 'tsconfig.json');
+
+  if (!fs.existsSync(tsconfigPath)) {
+    return { issues, skipped: true, reason: 'No tsconfig.json found' };
+  }
+
+  try {
+    execSync('which tsc', { encoding: 'utf-8', stdio: 'pipe' });
+  } catch {
+    return { issues, skipped: true, reason: 'TypeScript not installed' };
+  }
+
+  try {
+    const result = execSync(
+      `cd "${rootDir}" && tsc --noEmit --noUnusedLocals --noUnusedParameters 2>&1 || true`,
+      { encoding: 'utf-8', stdio: 'pipe', maxBuffer: 50 * 1024 * 1024 }
+    );
+
+    const lines = result.split('\n');
+    const errorRegex = /^(.+)\((\d+),(\d+)\):\s*error\s+TS(\d+):\s*(.+)$/;
+
+    for (const line of lines) {
+      const match = line.match(errorRegex);
+      if (match) {
+        const [, filePath, lineNum, , errorCode, message] = match;
+        // TS6133 = unused variable, TS6196 = unused parameter
+        if (['6133', '6196', '6198'].includes(errorCode)) {
+          issues.push({
+            file: path.relative(rootDir, filePath),
+            line: parseInt(lineNum, 10),
+            message: message,
+            rule: `TS${errorCode}`
+          });
+        }
+      }
+    }
+  } catch (e) {
+    return { issues, skipped: true, reason: 'TypeScript analysis failed' };
+  }
+
+  return { issues, skipped: false };
+}
+
+/**
+ * Check files against line limit
+ */
+function checkLineLimits(files, config) {
+  const issues = [];
+  const cfg = config.lineLimit || {};
+
+  if (!cfg.enabled) {
+    return { issues, skipped: true, reason: 'Disabled in config' };
+  }
+
+  const maxLines = cfg.limit || 500;
+
+  for (const file of files) {
+    // Skip non-code files
+    if (file.path.endsWith('.json') || file.path.endsWith('.lock') || file.path.endsWith('.css')) {
+      continue;
+    }
+
+    try {
+      const content = fs.readFileSync(file.fullPath, 'utf-8');
+      const lineCount = content.split('\n').length;
+
+      if (lineCount > maxLines) {
+        issues.push({
+          file: file.path,
+          count: lineCount,
+          limit: maxLines
+        });
+      }
+    } catch (e) {
+      // Can't read file, skip
+    }
+  }
+
+  issues.sort((a, b) => b.count - a.count);
+  return { issues, skipped: false, prompt: cfg.prompt };
+}
+
+/**
+ * Check folders against item limit
+ */
+function checkFolderLimits(files, config) {
+  const issues = [];
+  const cfg = config.folderLimit || {};
+
+  if (!cfg.enabled) {
+    return { issues, skipped: true, reason: 'Disabled in config' };
+  }
+
+  const maxItems = cfg.limit || 20;
+  const folderCounts = {};
+
+  for (const file of files) {
+    const dir = path.dirname(file.path);
+    if (!folderCounts[dir]) {
+      folderCounts[dir] = 0;
+    }
+    folderCounts[dir]++;
+  }
+
+  for (const [folder, count] of Object.entries(folderCounts)) {
+    if (count > maxItems) {
+      issues.push({
+        file: folder,
+        count: count,
+        limit: maxItems
+      });
+    }
+  }
+
+  issues.sort((a, b) => b.count - a.count);
+  return { issues, skipped: false, prompt: cfg.prompt };
+}
+
+/**
+ * Check for missing test files
+ */
+function checkMissingTests(files, config) {
+  const issues = [];
+  const cfg = config.testCheck || {};
+
+  if (!cfg.enabled) {
+    return { issues, skipped: true, reason: 'Disabled in config' };
+  }
+
+  const patterns = cfg.patterns || {
+    '.vue': '.test.js',
+    '.jsx': '.test.jsx',
+    '.tsx': '.test.tsx'
+  };
+
+  const testFiles = new Set(
+    files
+      .filter(f => f.path.includes('.test.') || f.path.includes('.spec.'))
+      .map(f => f.path.toLowerCase())
+  );
+
+  for (const file of files) {
+    const ext = path.extname(file.path);
+    const testExt = patterns[ext];
+
+    if (!testExt) continue;
+    if (file.path.includes('.test.') || file.path.includes('.spec.')) continue;
+    if (!file.path.startsWith('src/') && !file.path.startsWith('components/')) continue;
+
+    const baseName = path.basename(file.path, ext);
+    const hasTest = [...testFiles].some(t => t.includes(baseName.toLowerCase()) && t.includes('.test.'));
+
+    if (!hasTest) {
+      issues.push({
+        file: file.path,
+        expectedTest: `${baseName}${testExt}`
+      });
+    }
+  }
+
+  return { issues, skipped: false, prompt: cfg.prompt };
+}
+
+/**
+ * Main analyzer function
+ */
+export async function analyze(rootDir = process.cwd(), config = {}) {
+  const startTime = Date.now();
+  const files = listAllFiles(rootDir);
+
+  // Run all checks
+  const eslint = runEslintAnalysis(rootDir);
+  const typescript = runTypeScriptAnalysis(rootDir);
+  const lineLimit = checkLineLimits(files, config);
+  const folderLimit = checkFolderLimits(files, config);
+  const missingTests = checkMissingTests(files, config);
+
+  const duration = Date.now() - startTime;
+
+  return {
+    eslint,
+    typescript,
+    lineLimit,
+    folderLimit,
+    missingTests,
+    customRequirements: config.customChecks?.requirements || null,
+    filesScanned: files.length,
+    durationMs: duration
+  };
+}
+
+/**
+ * Format analysis results for display
+ */
+export function formatAnalysisResults(results) {
+  let output = '';
+  let totalIssues = 0;
+
+  // ESLint issues
+  if (!results.eslint.skipped && results.eslint.issues.length > 0) {
+    output += `🗑️  UNUSED CODE (ESLint) - ${results.eslint.issues.length} issues\n`;
+    for (const issue of results.eslint.issues.slice(0, 15)) {
+      output += `   ${issue.file}:${issue.line} - ${issue.message}\n`;
+    }
+    if (results.eslint.issues.length > 15) {
+      output += `   ... and ${results.eslint.issues.length - 15} more\n`;
+    }
+    output += '\n';
+    totalIssues += results.eslint.issues.length;
+  }
+
+  // TypeScript issues
+  if (!results.typescript.skipped && results.typescript.issues.length > 0) {
+    output += `🔷 UNUSED CODE (TypeScript) - ${results.typescript.issues.length} issues\n`;
+    for (const issue of results.typescript.issues.slice(0, 15)) {
+      output += `   ${issue.file}:${issue.line} - ${issue.message}\n`;
+    }
+    if (results.typescript.issues.length > 15) {
+      output += `   ... and ${results.typescript.issues.length - 15} more\n`;
+    }
+    output += '\n';
+    totalIssues += results.typescript.issues.length;
+  }
+
+  // Line limit issues
+  if (!results.lineLimit.skipped && results.lineLimit.issues.length > 0) {
+    output += `📏 FILES OVER LINE LIMIT - ${results.lineLimit.issues.length} files\n`;
+    for (const issue of results.lineLimit.issues) {
+      output += `   ${issue.file} - ${issue.count} lines (limit: ${issue.limit})\n`;
+    }
+    if (results.lineLimit.prompt) {
+      output += `\n   → ${results.lineLimit.prompt.replace(/\{\{\s*linelimit\s*\}\}/gi, results.lineLimit.issues[0]?.limit || '')}\n`;
+    }
+    output += '\n';
+    totalIssues += results.lineLimit.issues.length;
+  }
+
+  // Folder limit issues
+  if (!results.folderLimit.skipped && results.folderLimit.issues.length > 0) {
+    output += `📁 FOLDERS OVER ITEM LIMIT - ${results.folderLimit.issues.length} folders\n`;
+    for (const issue of results.folderLimit.issues) {
+      output += `   ${issue.file}/ - ${issue.count} items (limit: ${issue.limit})\n`;
+    }
+    if (results.folderLimit.prompt) {
+      output += `\n   → ${results.folderLimit.prompt.replace(/\{\{\s*folderlimit\s*\}\}/gi, results.folderLimit.issues[0]?.limit || '')}\n`;
+    }
+    output += '\n';
+    totalIssues += results.folderLimit.issues.length;
+  }
+
+  // Missing tests
+  if (!results.missingTests.skipped && results.missingTests.issues.length > 0) {
+    output += `🧪 MISSING TESTS - ${results.missingTests.issues.length} files\n`;
+    for (const issue of results.missingTests.issues.slice(0, 10)) {
+      output += `   ${issue.file} → needs ${issue.expectedTest}\n`;
+    }
+    if (results.missingTests.issues.length > 10) {
+      output += `   ... and ${results.missingTests.issues.length - 10} more\n`;
+    }
+    output += '\n';
+    totalIssues += results.missingTests.issues.length;
+  }
+
+  // Custom requirements
+  if (results.customRequirements) {
+    output += `📋 CUSTOM REQUIREMENTS\n`;
+    output += `   ${results.customRequirements}\n\n`;
+  }
+
+  return { output, totalIssues };
+}
+
+export default { analyze, formatAnalysisResults };

package/src/bburn.js

@@ -1,499 +1,58 @@
 #!/usr/bin/env node
-import { execSync, spawn } from 'child_process';
-import crypto from 'crypto';
 import fs from 'fs';
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
+import { join } from 'path';
+import { analyze, formatAnalysisResults } from './analyzer.js';
 
 const BONZAI_DIR = 'bonzai';
-const SPECS_FILE = 'specs.md';
 const CONFIG_FILE = 'config.json';
 
-// Template folder in the package (ships as payload-bonzai, copied as bonzai)
-const TEMPLATE_DIR = join(__dirname, '..', 'payload-bonzai');
-
-// Parse --provider / -p argument, with config as fallback
-function parseProvider(configDefault = 'claude') {
-  const args = process.argv.slice(2);
-  let provider = null;
-
-  for (let i = 0; i < args.length; i++) {
-    if (args[i] === '--provider' || args[i] === '-p') {
-      provider = args[i + 1];
-      break;
-    }
-    if (args[i].startsWith('--provider=')) {
-      provider = args[i].split('=')[1];
-      break;
-    }
-  }
-
-  // Use config default if no CLI arg provided
-  if (!provider) {
-    provider = configDefault;
-  }
-
-  const validProviders = ['claude', 'cursor'];
-  if (!validProviders.includes(provider)) {
-    console.error(`❌ Invalid provider: "${provider}". Must be one of: ${validProviders.join(', ')}`);
-    process.exit(1);
-  }
-
-  return provider;
-}
-
-function initializeBonzai() {
-  const bonzaiPath = join(process.cwd(), BONZAI_DIR);
-  const specsPath = join(bonzaiPath, SPECS_FILE);
-  const configPath = join(bonzaiPath, CONFIG_FILE);
-
-  // Check if bonzai/ folder exists
-  if (!fs.existsSync(bonzaiPath)) {
-    fs.mkdirSync(bonzaiPath, { recursive: true });
-    console.log(`📁 Created ${BONZAI_DIR}/ folder`);
-  }
-
-  // Copy specs.md from package template
-  if (!fs.existsSync(specsPath)) {
-    fs.copyFileSync(join(TEMPLATE_DIR, SPECS_FILE), specsPath);
-    console.log(`📝 Created ${BONZAI_DIR}/${SPECS_FILE}`);
-  }
-
-  // Copy config.json from package template
-  if (!fs.existsSync(configPath)) {
-    fs.copyFileSync(join(TEMPLATE_DIR, CONFIG_FILE), configPath);
-    console.log(`⚙️  Created ${BONZAI_DIR}/${CONFIG_FILE}`);
-    console.log(`\n⚠️  Please edit ${BONZAI_DIR}/${SPECS_FILE} to define your cleanup rules before running bburn.\n`);
-    process.exit(0);
-  }
-}
-
-function ensureBonzaiDir() {
-  const bonzaiPath = join(process.cwd(), BONZAI_DIR);
-  const specsPath = join(bonzaiPath, SPECS_FILE);
-  const configPath = join(bonzaiPath, CONFIG_FILE);
-
-  if (!fs.existsSync(bonzaiPath)) {
-    fs.mkdirSync(bonzaiPath, { recursive: true });
-    console.log(`📁 Created ${BONZAI_DIR}/ folder\n`);
-  }
-
-  if (!fs.existsSync(specsPath)) {
-    fs.copyFileSync(join(TEMPLATE_DIR, SPECS_FILE), specsPath);
-    console.log(`📝 Created ${BONZAI_DIR}/${SPECS_FILE} - edit this file to define your cleanup specs\n`);
-  }
+/**
+ * Load project config from bonzai/config.json
+ * This is the source of truth for all burn configuration
+ */
+function loadConfig() {
+  const configPath = join(process.cwd(), BONZAI_DIR, CONFIG_FILE);
 
   if (!fs.existsSync(configPath)) {
-    fs.copyFileSync(join(TEMPLATE_DIR, CONFIG_FILE), configPath);
-    console.log(`⚙️  Created ${BONZAI_DIR}/${CONFIG_FILE}\n`);
+    console.error(`❌ No config found at ${BONZAI_DIR}/${CONFIG_FILE}`);
+    console.error(`   Run 'bonzai-burn' to initialize.\n`);
+    process.exit(1);
   }
 
-  return { specsPath, configPath };
-}
-
-function loadConfig(configPath) {
   try {
     const content = fs.readFileSync(configPath, 'utf-8');
     return JSON.parse(content);
-  } catch {
-    return { debugMode: false };
-  }
-}
-
-function loadSpecs(specsPath, config) {
-  let content = fs.readFileSync(specsPath, 'utf-8');
-
-  // Process lineLimit if enabled
-  if (config.lineLimit?.enabled) {
-    content = content.replace(/\{\{\s*linelimit\s*\}\}/gi, config.lineLimit.limit);
-  } else {
-    // Remove lines containing {{ linelimit }} if disabled
-    content = content.split('\n')
-      .filter(line => !/\{\{\s*linelimit\s*\}\}/i.test(line))
-      .join('\n');
-  }
-
-  // Process folderLimit if enabled
-  if (config.folderLimit?.enabled) {
-    content = content.replace(/\{\{\s*folderlimit\s*\}\}/gi, config.folderLimit.limit);
-  } else {
-    // Remove lines containing {{ folderlimit }} if disabled
-    content = content.split('\n')
-      .filter(line => !/\{\{\s*folderlimit\s*\}\}/i.test(line))
-      .join('\n');
+  } catch (e) {
+    console.error(`❌ Could not parse ${BONZAI_DIR}/${CONFIG_FILE}`);
+    process.exit(1);
   }
-
-  return `You are a code cleanup assistant. Follow these specifications:\n\n${content}`;
-}
-
-function exec(command) {
-  return execSync(command, { encoding: 'utf-8', stdio: 'pipe' }).trim();
 }
 
-function execVisible(command) {
-  execSync(command, { stdio: 'inherit' });
-}
-
-function executeClaude(requirements, config) {
-  // Check if Claude CLI exists
-  try {
-    execSync('which claude', { encoding: 'utf-8', stdio: 'pipe' });
-  } catch (error) {
-    throw new Error(
-      'Claude Code CLI not found.\n' +
-      'Install it with: npm install -g @anthropic-ai/claude-code'
-    );
-  }
-
-  const debugMode = config.debugMode === true || config.debugMode === 'true';
-
-  // Debug mode: run Claude with visible output
-  if (debugMode) {
-    console.log('🐛 Running in debug mode...\n');
-    return new Promise((resolve, reject) => {
-      const args = [
-        '-p', requirements,
-        '--allowedTools', 'Read,Write,Edit,Bash',
-        '--permission-mode', 'dontAsk'
-      ];
-
-      const claude = spawn('claude', args, {
-        stdio: 'inherit'
-      });
-
-      claude.on('close', (code) => {
-        if (code === 0) {
-          resolve();
-        } else {
-          reject(new Error(`Claude exited with code ${code}`));
-        }
-      });
-
-      claude.on('error', (err) => {
-        reject(new Error(`Failed to execute Claude: ${err.message}`));
-      });
-    });
-  }
-
-  // Headless mode with token tracking
-  let totalInputTokens = 0;
-  let totalOutputTokens = 0;
-  let lastToolName = '';
-
-  return new Promise((resolve, reject) => {
-    const args = [
-      '-p', requirements,
-      '--allowedTools', 'Read,Write,Edit,Bash',
-      '--permission-mode', 'dontAsk',
-      '--output-format', 'stream-json',
-      '--verbose'
-    ];
-
-    const claude = spawn('claude', args, {
-      stdio: ['inherit', 'pipe', 'pipe']
-    });
-
-    let buffer = '';
-
-    claude.stdout.on('data', (data) => {
-      buffer += data.toString();
-
-      // Process complete JSON lines
-      const lines = buffer.split('\n');
-      buffer = lines.pop(); // Keep incomplete line in buffer
-
-      for (const line of lines) {
-        if (!line.trim()) continue;
-
-        try {
-          const event = JSON.parse(line);
+async function main() {
+  console.log('\n🔥 Bonzai Burn - Code Analysis\n');
 
-          // Track tokens from assistant messages
-          if (event.type === 'assistant' && event.message?.usage) {
-            const usage = event.message.usage;
-            if (usage.input_tokens) totalInputTokens += usage.input_tokens;
-            if (usage.output_tokens) totalOutputTokens += usage.output_tokens;
-          }
+  // Load config - source of truth
+  const config = loadConfig();
 
-          // Show tool usage updates
-          if (event.type === 'content_block_start' && event.content_block?.type === 'tool_use') {
-            lastToolName = event.content_block.name || '';
-          }
+  console.log('Scanning...\n');
 
-          if (event.type === 'content_block_stop' && lastToolName) {
-            const icon = getToolIcon(lastToolName);
-            console.log(`  ${icon} ${lastToolName}`);
-            lastToolName = '';
-          }
+  // Run analysis
+  const results = await analyze(process.cwd(), config);
+  const { output, totalIssues } = formatAnalysisResults(results);
 
-          // Show result events with file info
-          if (event.type === 'result') {
-            if (event.usage) {
-              // Final usage stats
-              totalInputTokens = event.usage.input_tokens || totalInputTokens;
-              totalOutputTokens = event.usage.output_tokens || totalOutputTokens;
-            }
-          }
-
-        } catch (e) {
-          // Not valid JSON, skip
-        }
-      }
-    });
-
-    claude.stderr.on('data', (data) => {
-      // Show errors but don't clutter with minor stderr
-      const msg = data.toString().trim();
-      if (msg && !msg.includes('ExperimentalWarning')) {
-        console.error(msg);
-      }
-    });
-
-    claude.on('close', (code) => {
-      // Print token summary
-      console.log(`\n📊 Tokens: ${totalInputTokens.toLocaleString()} in / ${totalOutputTokens.toLocaleString()} out`);
-
-      if (code === 0) {
-        resolve();
-      } else {
-        reject(new Error(`Claude exited with code ${code}`));
-      }
-    });
-
-    claude.on('error', (err) => {
-      reject(new Error(`Failed to execute Claude: ${err.message}`));
-    });
-  });
-}
-
-function getToolIcon(toolName) {
-  const icons = {
-    'Read': '📖',
-    'Write': '✏️',
-    'Edit': '🔧',
-    'Bash': '💻',
-    'Glob': '🔍',
-    'Grep': '🔎'
-  };
-  return icons[toolName] || '🔹';
-}
-
-function executeCursor(requirements, config) {
-  // Check if cursor-agent CLI exists
-  try {
-    execSync('which cursor-agent', { encoding: 'utf-8', stdio: 'pipe' });
-  } catch (error) {
-    throw new Error(
-      'cursor-agent CLI not found.\n' +
-      'Install it with: npm install -g cursor-agent'
-    );
-  }
-
-  const debugMode = config.debugMode === true || config.debugMode === 'true';
-
-  // Debug mode: run cursor-agent with verbose output
-  if (debugMode) {
-    console.log('🐛 Running in debug mode...\n');
-    return new Promise((resolve, reject) => {
-      const args = ['-p', requirements];
-
-      const cursor = spawn('cursor-agent', args, {
-        stdio: 'inherit'
-      });
-
-      cursor.on('close', (code) => {
-        if (code === 0) {
-          resolve();
-        } else {
-          reject(new Error(`cursor-agent exited with code ${code}`));
-        }
-      });
-
-      cursor.on('error', (err) => {
-        reject(new Error(`Failed to execute cursor-agent: ${err.message}`));
-      });
-    });
+  // Display results
+  if (totalIssues > 0 || results.customRequirements) {
+    console.log(output);
+  } else {
+    console.log('✓ No issues found\n');
   }
 
-  // Headless mode with token tracking
-  let totalInputTokens = 0;
-  let totalOutputTokens = 0;
-  let lastToolName = '';
-
-  return new Promise((resolve, reject) => {
-    const args = [
-      '-p', requirements,
-      '--output-format', 'stream-json'
-    ];
-
-    const cursor = spawn('cursor-agent', args, {
-      stdio: ['inherit', 'pipe', 'pipe']
-    });
-
-    let buffer = '';
-
-    cursor.stdout.on('data', (data) => {
-      buffer += data.toString();
-
-      // Process complete JSON lines
-      const lines = buffer.split('\n');
-      buffer = lines.pop(); // Keep incomplete line in buffer
-
-      for (const line of lines) {
-        if (!line.trim()) continue;
-
-        try {
-          const event = JSON.parse(line);
-
-          // Track tokens from assistant messages
-          if (event.type === 'assistant' && event.message?.usage) {
-            const usage = event.message.usage;
-            if (usage.input_tokens) totalInputTokens += usage.input_tokens;
-            if (usage.output_tokens) totalOutputTokens += usage.output_tokens;
-          }
-
-          // Show tool usage updates
-          if (event.type === 'content_block_start' && event.content_block?.type === 'tool_use') {
-            lastToolName = event.content_block.name || '';
-          }
-
-          if (event.type === 'content_block_stop' && lastToolName) {
-            const icon = getToolIcon(lastToolName);
-            console.log(`  ${icon} ${lastToolName}`);
-            lastToolName = '';
-          }
-
-          // Show result events with usage info
-          if (event.type === 'result') {
-            if (event.usage) {
-              totalInputTokens = event.usage.input_tokens || totalInputTokens;
-              totalOutputTokens = event.usage.output_tokens || totalOutputTokens;
-            }
-          }
-
-        } catch (e) {
-          // Not valid JSON, skip
-        }
-      }
-    });
-
-    cursor.stderr.on('data', (data) => {
-      const msg = data.toString().trim();
-      if (msg && !msg.includes('ExperimentalWarning')) {
-        console.error(msg);
-      }
-    });
-
-    cursor.on('close', (code) => {
-      // Print token summary
-      console.log(`\n📊 Tokens: ${totalInputTokens.toLocaleString()} in / ${totalOutputTokens.toLocaleString()} out`);
-
-      if (code === 0) {
-        resolve();
-      } else {
-        reject(new Error(`cursor-agent exited with code ${code}`));
-      }
-    });
-
-    cursor.on('error', (err) => {
-      reject(new Error(`Failed to execute cursor-agent: ${err.message}`));
-    });
-  });
-}
-
-async function burn() {
-  try {
-    // Initialize bonzai folder and specs.md on first execution
-    initializeBonzai();
-
-    // Ensure bonzai directory and specs file exist
-    const { specsPath, configPath } = ensureBonzaiDir();
-    const config = loadConfig(configPath);
-    const specs = loadSpecs(specsPath, config);
-
-    // Determine provider: CLI arg overrides config
-    const provider = parseProvider(config.provider || 'claude');
-
-    // Check if in git repo
-    try {
-      exec('git rev-parse --git-dir');
-    } catch {
-      console.error('❌ Not a git repository');
-      process.exit(1);
-    }
-
-    // Get current branch
-    const originalBranch = exec('git branch --show-current');
-
-    // Handle uncommitted changes - auto-commit to current branch
-    const hasChanges = exec('git status --porcelain') !== '';
-    let madeWipCommit = false;
-
-    if (hasChanges) {
-      const timestamp = Date.now();
-      console.log('💾 Auto-committing your work...');
-      exec('git add -A');
-      exec(`git commit -m "WIP: pre-burn checkpoint ${timestamp}"`);
-      madeWipCommit = true;
-      console.log(`✓ Work saved on ${originalBranch}\n`);
-    }
-
-    // Generate unique branch name with short UUID
-    const shortId = crypto.randomUUID().slice(0, 8);
-    const burnBranch = `bonzai-burn-${shortId}`;
-
-    console.log(`📍 Starting from: ${originalBranch}`);
-    console.log(`🌿 Creating: ${burnBranch}\n`);
-
-    // Create burn branch from current position
-    exec(`git checkout -b ${burnBranch}`);
-
-    // Save metadata for revert
-    exec(`git config bonzai.originalBranch ${originalBranch}`);
-    exec(`git config bonzai.burnBranch ${burnBranch}`);
-    exec(`git config bonzai.madeWipCommit ${madeWipCommit}`);
-
-    console.log(`📋 Specs loaded from: ${BONZAI_DIR}/${SPECS_FILE}`);
-    console.log(`🤖 Provider: ${provider}`);
-    console.log(`🐛 Debug mode: ${config.debugMode === true || config.debugMode === 'true' ? 'on' : 'off'}`);
-    console.log('🔥 Running Bonzai burn...\n');
-
-    const startTime = Date.now();
-
-    // Execute with the selected provider
-    if (provider === 'cursor') {
-      await executeCursor(specs, config);
-    } else {
-      await executeClaude(specs, config);
-    }
-
-    const duration = Math.round((Date.now() - startTime) / 1000);
-
-    console.log(`\n✓ Burn complete (${duration}s)\n`);
-
-    // Commit burn changes
-    const burnTimestamp = Date.now();
-    exec('git add -A');
-    exec(`git commit -m "bonzai burn ${burnTimestamp}" --allow-empty`);
-
-    console.log('Files changed from original:');
-    execVisible(`git diff --stat ${originalBranch}..${burnBranch}`);
-
-    console.log(`\n✅ Changes applied on: ${burnBranch}`);
-    console.log(`📊 Full diff: git diff ${originalBranch}`);
-    console.log(`\n✓ Keep changes: baccept`);
-    console.log(`✗ Discard: brevert\n`);
-
-  } catch (error) {
-    console.error('❌ Burn failed:', error.message);
-    if (error.message.includes('Claude Code CLI not found')) {
-      console.error('\n' + error.message);
-    }
-    process.exit(1);
-  }
+  // Summary
+  console.log('─'.repeat(50));
+  console.log(`Found ${totalIssues} issues across ${results.filesScanned} files (${results.durationMs}ms)\n`);
 }
 
-burn();
+main().catch((error) => {
+  console.error('Error:', error.message);
+  process.exit(1);
+});

package/src/index.js

@@ -19,11 +19,10 @@ function init() {
   }
 
   mkdirSync(bonzaiPath, { recursive: true });
-  copyFileSync(join(TEMPLATE_DIR, 'specs.md'), join(bonzaiPath, 'specs.md'));
   copyFileSync(join(TEMPLATE_DIR, 'config.json'), join(bonzaiPath, 'config.json'));
-  console.log(`📁 Created ${BONZAI_DIR}/ folder with specs.md and config.json`);
-  console.log(`📝 Edit ${BONZAI_DIR}/specs.md to define your cleanup rules`);
-  console.log(`🔥 Run 'bburn' to start a burn session`);
+  console.log(`📁 Created ${BONZAI_DIR}/ folder with config.json`);
+  console.log(`📝 Edit ${BONZAI_DIR}/config.json to configure your burn rules`);
+  console.log(`🔥 Run 'bburn' to analyze your codebase`);
   console.log('');
   console.log('┌─────────────────────────────────────────────────────────────┐');
   console.log('│                                                             │');

package/payload-bonzai/specs.md

@@ -1,9 +0,0 @@
-# Bonzai Specs
-
-Define your cleanup requirements below. bburn will follow these instructions.
-
-## Custom Requirements:
-- Remove unused imports and variables
-- Remove all console log statements
-- Split any file with over {{ linelimit }} lines into smaller files
-- Split any folder with over {{ folderlimit }} items into smaller, compartmentalized folders

package/src/baccept.js

@@ -1,60 +0,0 @@
-#!/usr/bin/env node
-import { execSync } from 'child_process';
-
-function exec(command) {
-  return execSync(command, { encoding: 'utf-8', stdio: 'pipe' }).trim();
-}
-
-function execVisible(command) {
-  execSync(command, { stdio: 'inherit' });
-}
-
-async function accept() {
-  try {
-    // Get saved metadata
-    let originalBranch;
-    let burnBranch;
-    let madeWipCommit;
-
-    try {
-      originalBranch = exec('git config bonzai.originalBranch');
-      burnBranch = exec('git config bonzai.burnBranch');
-      madeWipCommit = exec('git config bonzai.madeWipCommit') === 'true';
-    } catch {
-      console.error('❌ No burn to accept');
-      console.error('Run bburn first');
-      process.exit(1);
-    }
-
-    console.log(`✅ Accepting burn changes...`);
-    console.log(`   Merging: ${burnBranch} → ${originalBranch}\n`);
-
-    // Checkout original branch
-    execVisible(`git checkout ${originalBranch}`);
-
-    // Merge burn branch into original
-    execVisible(`git merge ${burnBranch} -m "Accept bonzai burn from ${burnBranch}"`);
-
-    // If we made a WIP commit, we need to handle it
-    // The merge already includes the burn changes on top of the WIP commit
-    // So we can optionally squash or leave as-is
-    if (madeWipCommit) {
-      console.log('\n💡 Note: Your pre-burn WIP commit was preserved in the history.');
-    }
-
-    // Clean up metadata
-    exec('git config --unset bonzai.originalBranch');
-    exec('git config --unset bonzai.burnBranch');
-    exec('git config --unset bonzai.madeWipCommit');
-
-    console.log(`\n✓ Burn accepted and merged`);
-    console.log(`Now on: ${originalBranch}`);
-    console.log(`Branch kept: ${burnBranch}\n`);
-
-  } catch (error) {
-    console.error('❌ Accept failed:', error.message);
-    process.exit(1);
-  }
-}
-
-accept();

package/src/brevert.js

@@ -1,59 +0,0 @@
-#!/usr/bin/env node
-import { execSync } from 'child_process';
-
-function exec(command) {
-  return execSync(command, { encoding: 'utf-8', stdio: 'pipe' }).trim();
-}
-
-function execVisible(command) {
-  execSync(command, { stdio: 'inherit' });
-}
-
-async function revert() {
-  try {
-    // Get saved metadata
-    let originalBranch;
-    let burnBranch;
-    let madeWipCommit;
-
-    try {
-      originalBranch = exec('git config bonzai.originalBranch');
-      burnBranch = exec('git config bonzai.burnBranch');
-      madeWipCommit = exec('git config bonzai.madeWipCommit') === 'true';
-    } catch {
-      console.error('❌ No burn to revert');
-      console.error('Run bburn first');
-      process.exit(1);
-    }
-
-    console.log(`🔙 Reverting burn...`);
-    console.log(`   Discarding: ${burnBranch}\n`);
-
-    // Checkout original branch
-    execVisible(`git checkout ${originalBranch}`);
-
-    // Delete burn branch
-    execVisible(`git branch -D ${burnBranch}`);
-
-    // Undo WIP commit if we made one
-    if (madeWipCommit) {
-      console.log('↩️  Undoing WIP commit...');
-      exec('git reset HEAD~1');
-      console.log('✓ Back to uncommitted changes\n');
-    }
-
-    // Clean up metadata
-    exec('git config --unset bonzai.originalBranch');
-    exec('git config --unset bonzai.burnBranch');
-    exec('git config --unset bonzai.madeWipCommit');
-
-    console.log(`✓ Burn fully reverted`);
-    console.log(`Back on: ${originalBranch}\n`);
-
-  } catch (error) {
-    console.error('❌ Revert failed:', error.message);
-    process.exit(1);
-  }
-}
-
-revert();