bonzai-burn 1.0.15 → 1.0.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bonzai-burn",
-  "version": "1.0.15",
+  "version": "1.0.17",
   "description": "Git branch-based cleanup tool with bburn, baccept, and brevert commands",
   "type": "module",
   "main": "src/index.js",
@@ -8,7 +8,9 @@
     "bonzai-burn": "./src/index.js",
     "bburn": "./src/bburn.js",
     "baccept": "./src/baccept.js",
-    "brevert": "./src/brevert.js"
+    "brevert": "./src/brevert.js",
+    "bgraph": "./src/bgraph.js",
+    "bonzai-mcp": "./src/mcp-server.js"
   },
   "keywords": [
     "git",
@@ -22,5 +24,8 @@
   "files": [
     "src",
     "payload-bonzai"
-  ]
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.25.3"
+  }
 }

package/payload-bonzai/config.json

@@ -2,7 +2,6 @@
   "provider": "cursor",
   "debugMode": true,
   "autoBurn": false,
-  "autoRun": false,
   "lineLimit": {
     "enabled": false,
     "limit": 70,

package/payload-bonzai/graph-templates/config.js

@@ -0,0 +1,18 @@
+const path = require('path');
+
+// Root directory (one level up from templates/)
+const ROOT = path.join(__dirname, '..');
+
+// Initialize babelParser (optional dependency)
+let babelParser = null;
+try {
+  babelParser = require('./node_modules/@babel/parser');
+} catch (e) {
+  // Babel parser not available, will fall back gracefully
+}
+
+module.exports = {
+  ROOT,
+  babelParser
+};
+

package/payload-bonzai/graph-templates/handlers/delete.js

@@ -0,0 +1,20 @@
+const fs = require('fs');
+const path = require('path');
+const { ROOT } = require('../config');
+
+function deleteHandler(req, res) {
+  try {
+    const targetPath = path.join(ROOT, req.body.path || '');
+    if (!targetPath.startsWith(ROOT)) {
+      return res.status(400).send('Invalid path');
+    }
+    // Delete file or directory recursively
+    fs.rmSync(targetPath, { recursive: true, force: true });
+    res.json({ status: 'ok' });
+  } catch (e) {
+    res.status(500).send(e.message);
+  }
+}
+
+module.exports = deleteHandler;
+

package/payload-bonzai/graph-templates/handlers/index.js

@@ -0,0 +1,19 @@
+// Root route - simple API documentation
+function indexHandler(req, res) {
+  res.json({
+    message: 'Local File Server API',
+    endpoints: {
+      'GET /list': 'List all files in the directory',
+      'GET /read?path=<filepath>': 'Read file content',
+      'POST /delete': 'Delete file or directory (body: {path})',
+      'POST /open-cursor': 'Open Cursor (body: {path, line?})',
+      'POST /shutdown': 'Gracefully shutdown the server',
+      'POST /scan_code_quality': 'Scan code quality (body: {projectPath})',
+      'WS /terminal': 'Interactive terminal via WebSocket'
+    },
+    example: 'Try: /list or /read?path=README.md'
+  });
+}
+
+module.exports = indexHandler;
+

package/payload-bonzai/graph-templates/handlers/list.js

@@ -0,0 +1,16 @@
+const path = require('path');
+const { ROOT } = require('../config');
+const { listAllFiles } = require('../utils/fileList');
+
+function listHandler(req, res) {
+  try {
+    const rootName = path.basename(ROOT);
+    const files = listAllFiles(ROOT, rootName);
+    res.json({ files });
+  } catch (e) {
+    res.status(500).send(e.message);
+  }
+}
+
+module.exports = listHandler;
+

package/payload-bonzai/graph-templates/handlers/open-cursor.js

@@ -0,0 +1,108 @@
+const path = require('path');
+const { exec } = require('child_process');
+const { ROOT } = require('../config');
+
+function openCursorHandler(req, res) {
+  try {
+    const requestedPath = req.body.path || '';
+    
+    // Resolve path relative to ROOT (similar to other endpoints)
+    // If path is absolute and within ROOT, use it directly
+    // Otherwise, resolve it relative to ROOT
+    let filePath;
+    if (path.isAbsolute(requestedPath)) {
+      // If absolute path, check if it's within ROOT
+      if (requestedPath.startsWith(ROOT)) {
+        filePath = requestedPath;
+      } else {
+        // Path might contain incorrect segments (like "codemaps")
+        // Try to find ROOT in the path and extract the relative part
+        const rootIndex = requestedPath.indexOf(ROOT);
+        if (rootIndex !== -1) {
+          // Extract the part after ROOT and remove leading slashes
+          let relativePart = requestedPath.substring(rootIndex + ROOT.length);
+          while (relativePart.startsWith('/')) {
+            relativePart = relativePart.substring(1);
+          }
+          filePath = path.join(ROOT, relativePart);
+        } else {
+          return res.status(400).json({ error: 'Invalid path: path must be within project root' });
+        }
+      }
+    } else {
+      // Relative path - resolve relative to ROOT
+      // Remove root directory name prefix if present (from /list endpoint format)
+      const rootName = path.basename(ROOT);
+      let relativePath = requestedPath;
+      if (relativePath.startsWith(rootName + '/')) {
+        relativePath = relativePath.substring(rootName.length + 1);
+      }
+      filePath = path.join(ROOT, relativePath);
+    }
+    
+    // Validate the resolved path is within ROOT
+    if (!filePath.startsWith(ROOT)) {
+      return res.status(400).json({ error: 'Invalid path' });
+    }
+    
+    const { line } = req.body;
+    
+    // Always use cursor CLI command first (it handles line numbers correctly)
+    const cursorCommands = [
+      'cursor',
+      '/Applications/Cursor.app/Contents/Resources/app/bin/cursor',
+      '/usr/local/bin/cursor',
+      'code'
+    ];
+    
+    const tryCommand = (commandIndex = 0) => {
+      if (commandIndex >= cursorCommands.length) {
+        return res.status(500).json({ 
+          error: 'Cursor not found. Please install Cursor CLI or check Cursor installation.' 
+        });
+      }
+      
+      // Use proper Cursor CLI syntax for line numbers
+      const command = line 
+        ? `${cursorCommands[commandIndex]} --goto "${filePath}:${line}"`
+        : `${cursorCommands[commandIndex]} "${filePath}"`;
+    
+    exec(command, (error, stdout, stderr) => {
+      if (error && error.code === 127) {
+        // Command not found, try next one
+        tryCommand(commandIndex + 1);
+      } else if (error) {
+        console.error('Error opening Cursor:', error);
+        return res.status(500).json({ error: error.message });
+      } else {
+        // File opened successfully, now bring Cursor to front
+        const isMac = process.platform === 'darwin';
+        if (isMac) {
+          // Use AppleScript to bring Cursor to the front
+          exec('osascript -e "tell application \\"Cursor\\" to activate"', (activateError) => {
+            if (activateError) {
+              console.log('Could not activate Cursor, but file opened successfully');
+            }
+          });
+          
+          // Additional command to ensure it's really in front
+          setTimeout(() => {
+            exec('osascript -e "tell application \\"System Events\\" to set frontmost of process \\"Cursor\\" to true"', () => {
+              // Don't worry if this fails
+            });
+          }, 500);
+        }
+        
+        res.json({ success: true, message: 'Cursor opened and focused successfully' });
+      }
+    });
+  };
+  
+  tryCommand();
+  } catch (e) {
+    res.status(500).json({ error: e.message });
+  }
+}
+
+module.exports = openCursorHandler;
+

package/payload-bonzai/graph-templates/handlers/read.js

@@ -0,0 +1,120 @@
+const fs = require('fs');
+const path = require('path');
+const { ROOT } = require('../config');
+const { extractPythonFunctions, extractJavaScriptFunctions, extractVueFunctions } = require('../utils/parsers');
+
+function readHandler(req, res) {
+  try {
+    const requestedPath = req.query.path || '';
+    const filePath = path.join(ROOT, requestedPath);
+    
+    if (!filePath.startsWith(ROOT)) {
+      return res.status(400).send('Invalid path');
+    }
+    
+    // Helper function to find and return content from parse result
+    const findAndReturn = (parseResult, name, type) => {
+      if (type === 'function') {
+        const target = parseResult.functions.find(f => f.name === name);
+        if (target) return target.content;
+      } else if (type === 'method') {
+        // Method name format: ClassName.methodName
+        for (const cls of parseResult.classes) {
+          const method = cls.methods.find(m => m.name === name);
+          if (method) return method.content;
+        }
+      } else if (type === 'class') {
+        const target = parseResult.classes.find(c => c.name === name);
+        if (target) return target.content;
+      }
+      return null;
+    };
+    
+    // Check if this is a virtual file request (.function, .method, or .class)
+    if (requestedPath.endsWith('.function') || requestedPath.endsWith('.method') || requestedPath.endsWith('.class')) {
+      // Traverse up the path to find the actual source file
+      let currentPath = filePath;
+      let sourceFilePath = null;
+      let parser = null;
+      
+      // Keep going up until we find a source file (.py, .js, .jsx, .ts, .tsx, .vue)
+      while (currentPath !== ROOT && currentPath !== path.dirname(currentPath)) {
+        const stat = fs.existsSync(currentPath) ? fs.statSync(currentPath) : null;
+        
+        // Check if current path is a file with a supported extension
+        if (stat && stat.isFile()) {
+          if (currentPath.endsWith('.py')) {
+            parser = extractPythonFunctions;
+            sourceFilePath = currentPath;
+            break;
+          } else if (currentPath.endsWith('.js') || currentPath.endsWith('.jsx') || 
+                     currentPath.endsWith('.ts') || currentPath.endsWith('.tsx')) {
+            parser = extractJavaScriptFunctions;
+            sourceFilePath = currentPath;
+            break;
+          } else if (currentPath.endsWith('.vue')) {
+            parser = extractVueFunctions;
+            sourceFilePath = currentPath;
+            break;
+          }
+        }
+        
+        // Move up one level
+        const parentPath = path.dirname(currentPath);
+        if (parentPath === currentPath) break; // Reached root
+        currentPath = parentPath;
+      }
+      
+      if (!sourceFilePath || !parser) {
+        return res.status(404).send('Source file not found for virtual file');
+      }
+      
+      // Extract the requested item name from the requested path
+      let itemName = '';
+      let itemType = '';
+      
+      if (requestedPath.endsWith('.function')) {
+        itemName = path.basename(requestedPath, '.function');
+        itemType = 'function';
+      } else if (requestedPath.endsWith('.method')) {
+        itemName = path.basename(requestedPath, '.method');
+        itemType = 'method';
+      } else if (requestedPath.endsWith('.class')) {
+        itemName = path.basename(requestedPath, '.class');
+        itemType = 'class';
+      }
+      
+      // Check if the source file exists
+      try {
+        if (!fs.existsSync(sourceFilePath)) {
+          return res.status(404).send('Source file not found');
+        }
+        
+        // Parse the file
+        const parseResult = parser(sourceFilePath);
+        
+        // Find and return the content
+        const content = findAndReturn(parseResult, itemName, itemType);
+        
+        if (!content) {
+          return res.status(404).send(`${itemType} '${itemName}' not found in file`);
+        }
+        
+        return res.json({ content });
+      } catch (e) {
+        const errorType = requestedPath.endsWith('.function') ? 'function' : 
+                         requestedPath.endsWith('.method') ? 'method' : 'class';
+        return res.status(500).send('Error reading ' + errorType + ': ' + e.message);
+      }
+    }
+    
+    // Regular file read
+    const content = fs.readFileSync(filePath, 'utf8');
+    res.json({ content });
+  } catch (e) {
+    res.status(500).send(e.message);
+  }
+}
+
+module.exports = readHandler;
+

package/payload-bonzai/graph-templates/handlers/scan_code_quality.js

@@ -0,0 +1,144 @@
+const fs = require('fs');
+const path = require('path');
+const { ROOT } = require('../config');
+
+function scanCodeQualityHandler(req, res) {
+  try {
+    const { projectPath } = req.body;
+    
+    if (!projectPath) {
+      return res.status(400).json({ error: 'projectPath is required' });
+    }
+    
+    const targetPath = path.join(ROOT, projectPath);
+    
+    if (!targetPath.startsWith(ROOT)) {
+      return res.status(400).json({ error: 'Invalid path' });
+    }
+    
+    if (!fs.existsSync(targetPath)) {
+      return res.status(404).json({ error: 'Path not found' });
+    }
+    
+    const issues = [];
+    
+    // Basic code quality checks
+    function scanDirectory(dir) {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+      
+      for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        const relativePath = path.relative(ROOT, fullPath);
+        
+        // Skip node_modules and other ignored directories
+        if (entry.name === 'node_modules' || entry.name === '.git' || entry.name === 'bonzai') {
+          continue;
+        }
+        
+        if (entry.isDirectory()) {
+          scanDirectory(fullPath);
+        } else if (entry.isFile()) {
+          // Check file size (warn if > 500KB)
+          const stats = fs.statSync(fullPath);
+          if (stats.size > 500 * 1024) {
+            issues.push({
+              file: relativePath,
+              severity: 'warning',
+              message: `Large file detected (${(stats.size / 1024).toFixed(2)}KB). Consider splitting into smaller modules.`,
+              type: 'file-size'
+            });
+          }
+          
+          // Check for common code quality issues in JS/TS files
+          if (entry.name.endsWith('.js') || entry.name.endsWith('.jsx') || 
+              entry.name.endsWith('.ts') || entry.name.endsWith('.tsx')) {
+            try {
+              const content = fs.readFileSync(fullPath, 'utf8');
+              const lines = content.split('\n');
+              
+              // Check for very long lines
+              lines.forEach((line, index) => {
+                if (line.length > 200) {
+                  issues.push({
+                    file: relativePath,
+                    line: index + 1,
+                    severity: 'info',
+                    message: `Long line detected (${line.length} characters). Consider breaking into multiple lines.`,
+                    type: 'line-length'
+                  });
+                }
+              });
+              
+              // Check for TODO/FIXME comments
+              lines.forEach((line, index) => {
+                if (line.match(/TODO|FIXME|XXX|HACK/i)) {
+                  issues.push({
+                    file: relativePath,
+                    line: index + 1,
+                    severity: 'info',
+                    message: `TODO/FIXME comment found: ${line.trim().substring(0, 100)}`,
+                    type: 'todo-comment'
+                  });
+                }
+              });
+              
+              // Check for console.log statements (potential debug code)
+              lines.forEach((line, index) => {
+                if (line.match(/console\.(log|debug|info|warn|error)/) && !line.includes('//')) {
+                  issues.push({
+                    file: relativePath,
+                    line: index + 1,
+                    severity: 'warning',
+                    message: `Console statement found. Consider removing or using a proper logging library.`,
+                    type: 'console-statement'
+                  });
+                }
+              });
+              
+            } catch (e) {
+              // Skip files that can't be read
+            }
+          }
+        }
+      }
+    }
+    
+    const stat = fs.statSync(targetPath);
+    if (stat.isDirectory()) {
+      scanDirectory(targetPath);
+    } else {
+      // Single file scan
+      const relativePath = path.relative(ROOT, targetPath);
+      const content = fs.readFileSync(targetPath, 'utf8');
+      const lines = content.split('\n');
+      
+      lines.forEach((line, index) => {
+        if (line.length > 200) {
+          issues.push({
+            file: relativePath,
+            line: index + 1,
+            severity: 'info',
+            message: `Long line detected (${line.length} characters)`,
+            type: 'line-length'
+          });
+        }
+      });
+    }
+    
+    res.json({
+      success: true,
+      issues: issues,
+      totalIssues: issues.length,
+      summary: {
+        errors: issues.filter(i => i.severity === 'error').length,
+        warnings: issues.filter(i => i.severity === 'warning').length,
+        info: issues.filter(i => i.severity === 'info').length
+      }
+    });
+    
+  } catch (e) {
+    res.status(500).json({ error: e.message });
+  }
+}
+
+module.exports = scanCodeQualityHandler;

package/payload-bonzai/graph-templates/handlers/shutdown.js

@@ -0,0 +1,16 @@
+function shutdownHandler(req, res) {
+  console.log('🛑 Shutdown endpoint called - terminating server...');
+  
+  res.json({ 
+    success: true, 
+    message: 'Server shutting down...' 
+  });
+  
+  // Close the server gracefully
+  setTimeout(() => {
+    process.exit(0);
+  }, 100); // Small delay to ensure response is sent
+}
+
+module.exports = shutdownHandler;
+

package/payload-bonzai/graph-templates/handlers/terminal.js

@@ -0,0 +1,162 @@
+console.log(`[Terminal] Node version: ${process.version}`);
+console.log(`[Terminal] Platform: ${process.platform} ${process.arch}`);
+
+let pty;
+try {
+  pty = require('node-pty');
+  console.log('[Terminal] node-pty loaded successfully');
+} catch (err) {
+  console.error('[Terminal] Failed to load node-pty:', err.message);
+  console.error('[Terminal] This usually means node-pty native binaries failed to install.');
+  console.error('[Terminal] Try running: cd bonzai && npm rebuild node-pty');
+  pty = null;
+}
+
+// Store active terminal sessions
+const terminals = new Map();
+
+// Get default shell based on platform
+function getDefaultShell() {
+  if (process.platform === 'win32') {
+    return process.env.COMSPEC || 'powershell.exe';
+  }
+  // Prefer SHELL env var, but always use full path
+  const shell = process.env.SHELL || '/bin/bash';
+  // Ensure we have a full path
+  if (!shell.startsWith('/')) {
+    return '/bin/bash';
+  }
+  return shell;
+}
+
+// Create a new terminal session
+function createTerminal(sessionId, cols = 80, rows = 24) {
+  if (!pty) {
+    throw new Error('node-pty is not available. Native binaries may not have installed correctly.');
+  }
+
+  const shell = getDefaultShell();
+  const cwd = process.env.HOME || process.cwd();
+
+  console.log(`[Terminal] Spawning shell: ${shell}`);
+  console.log(`[Terminal] Working directory: ${cwd}`);
+  console.log(`[Terminal] PATH: ${process.env.PATH}`);
+
+  let ptyProcess;
+  try {
+    ptyProcess = pty.spawn(shell, [], {
+      name: 'xterm-256color',
+      cols,
+      rows,
+      cwd,
+      env: {
+        ...process.env,
+        TERM: 'xterm-256color',
+        PATH: process.env.PATH || '/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin'
+      }
+    });
+  } catch (spawnErr) {
+    console.error('[Terminal] pty.spawn failed:', spawnErr);
+    console.error('[Terminal] Error code:', spawnErr.code);
+    console.error('[Terminal] Error errno:', spawnErr.errno);
+    // Try with /bin/bash as fallback
+    console.log('[Terminal] Retrying with /bin/bash...');
+    try {
+      ptyProcess = pty.spawn('/bin/bash', [], {
+        name: 'xterm-256color',
+        cols,
+        rows,
+        cwd,
+        env: {
+          ...process.env,
+          TERM: 'xterm-256color',
+          PATH: process.env.PATH || '/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin'
+        }
+      });
+    } catch (bashErr) {
+      console.error('[Terminal] /bin/bash also failed:', bashErr);
+      throw spawnErr; // throw original error
+    }
+  }
+
+  terminals.set(sessionId, {
+    pty: ptyProcess,
+    buffer: ''
+  });
+
+  return ptyProcess;
+}
+
+// HTTP handler for terminal info
+function terminalHandler(req, res) {
+  res.json({
+    message: 'Terminal WebSocket API',
+    usage: {
+      websocket: 'ws://localhost:3001/terminal',
+      events: {
+        'input': 'Send terminal input (data: string)',
+        'resize': 'Resize terminal (cols: number, rows: number)',
+        'output': 'Receive terminal output'
+      }
+    }
+  });
+}
+
+// WebSocket handler for terminal sessions
+function setupTerminalWebSocket(wss) {
+  wss.on('connection', (ws) => {
+    const sessionId = Date.now().toString();
+    let ptyProcess;
+
+    try {
+      ptyProcess = createTerminal(sessionId);
+      console.log(`Terminal session ${sessionId} started`);
+    } catch (err) {
+      console.error('Failed to create terminal:', err.message);
+      ws.send(JSON.stringify({ type: 'error', message: 'Failed to create terminal: ' + err.message }));
+      ws.close();
+      return;
+    }
+
+    // Send terminal output to WebSocket client
+    ptyProcess.onData((data) => {
+      try {
+        ws.send(JSON.stringify({ type: 'output', data }));
+      } catch (e) {
+        // Client disconnected
+      }
+    });
+
+    ptyProcess.onExit(({ exitCode }) => {
+      ws.send(JSON.stringify({ type: 'exit', exitCode }));
+      ws.close();
+    });
+
+    // Handle incoming messages from client
+    ws.on('message', (message) => {
+      try {
+        const msg = JSON.parse(message);
+
+        switch (msg.type) {
+          case 'input':
+            ptyProcess.write(msg.data);
+            break;
+          case 'resize':
+            ptyProcess.resize(msg.cols, msg.rows);
+            break;
+        }
+      } catch (e) {
+        console.error('Terminal message error:', e);
+      }
+    });
+
+    // Cleanup on disconnect
+    ws.on('close', () => {
+      console.log(`Terminal session ${sessionId} closed`);
+      ptyProcess.kill();
+      terminals.delete(sessionId);
+    });
+  });
+}
+
+module.exports = { terminalHandler, setupTerminalWebSocket };