bonzai-burn 1.0.12 → 1.0.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bonzai-burn",
-  "version": "1.0.12",
+  "version": "1.0.14",
   "description": "Git branch-based cleanup tool with bburn, baccept, and brevert commands",
   "type": "module",
   "main": "src/index.js",

package/payload-bonzai/config.json

@@ -1,15 +1,15 @@
 {
-  "isClaude": false,
-  "isCursor": true,
-  "headlessClaude": true,
+  "provider": "cursor",
+  "headless": true,
   "autoBurn": false,
+  "autoRun": false,
   "lineLimit": {
-    "enabled": true,
+    "enabled": false,
     "limit": 70,
     "prompt": "Split any file with over {{ linelimit }} lines into smaller files."
   },
   "folderLimit": {
-    "enabled": true,
+    "enabled": false,
     "limit": 10,
     "prompt": "Split any folder with over {{ folderlimit }} items into smaller, compartmentalized folders."
   }

package/src/baccept.js

@@ -35,9 +35,6 @@ async function accept() {
     // Merge burn branch into original
     execVisible(`git merge ${burnBranch} -m "Accept bonzai burn from ${burnBranch}"`);
 
-    // Delete burn branch
-    execVisible(`git branch -D ${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
@@ -51,7 +48,8 @@ async function accept() {
     exec('git config --unset bonzai.madeWipCommit');
 
     console.log(`\n✓ Burn accepted and merged`);
-    console.log(`Now on: ${originalBranch}\n`);
+    console.log(`Now on: ${originalBranch}`);
+    console.log(`Branch kept: ${burnBranch}\n`);
 
   } catch (error) {
     console.error('❌ Accept failed:', error.message);

package/src/bburn.js

@@ -15,6 +15,36 @@ 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);
@@ -69,7 +99,7 @@ function loadConfig(configPath) {
     const content = fs.readFileSync(configPath, 'utf-8');
     return JSON.parse(content);
   } catch {
-    return { headlessClaude: true };
+    return { headless: true };
   }
 }
 
@@ -118,7 +148,7 @@ function executeClaude(requirements, config) {
     );
   }
 
-  const headless = config.headlessClaude !== false;
+  const headless = config.headless !== false;
 
   // Non-headless mode: run Claude interactively
   if (!headless) {
@@ -251,6 +281,129 @@ function getToolIcon(toolName) {
   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 headless = config.headless !== false;
+
+  // Non-headless mode: run cursor-agent interactively
+  if (!headless) {
+    console.log('🖥️  Running in interactive 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}`));
+      });
+    });
+  }
+
+  // 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
@@ -261,8 +414,8 @@ async function burn() {
     const config = loadConfig(configPath);
     const specs = loadSpecs(specsPath, config);
 
-    // Check if Claude CLI exists and execute
-    console.log('🔍 Checking for Claude Code CLI...');
+    // Determine provider: CLI arg overrides config
+    const provider = parseProvider(config.provider || 'claude');
 
     // Check if in git repo
     try {
@@ -304,13 +457,18 @@ async function burn() {
     exec(`git config bonzai.madeWipCommit ${madeWipCommit}`);
 
     console.log(`📋 Specs loaded from: ${BONZAI_DIR}/${SPECS_FILE}`);
-    console.log(`⚙️  Headless mode: ${config.headlessClaude !== false ? 'on' : 'off'}`);
+    console.log(`🤖 Provider: ${provider}`);
+    console.log(`⚙️  Headless mode: ${config.headless !== false ? 'on' : 'off'}`);
     console.log('🔥 Running Bonzai burn...\n');
 
     const startTime = Date.now();
 
-    // Execute Claude with specs from bonzai/specs.md
-    await executeClaude(specs, config);
+    // 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);