bonzai-burn 1.0.52 → 1.0.53

package/dist/bconfig.js

@@ -0,0 +1,224 @@
+#!/usr/bin/env node
+import fs from 'fs';
+import path from 'path';
+import { spawn, exec } from 'child_process';
+import { fileURLToPath } from 'url';
+import { ENABLED_LOOPS } from './loops.config.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Template folder in the package
+const TEMPLATE_DIR = path.join(__dirname, 'graph-templates');
+
+// Helper function to recursively copy directory
+function copyDirectory(src, dest) {
+  if (!fs.existsSync(dest)) {
+    fs.mkdirSync(dest, { recursive: true });
+  }
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+
+    if (entry.isDirectory()) {
+      copyDirectory(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+async function main() {
+  const currentDir = process.cwd();
+  const bonzaiDir = path.join(currentDir, 'bonzai');
+  const receiverPath = path.join(bonzaiDir, 'receiver.js');
+
+  console.log('Setting up local file server...');
+
+  // Create bonzai directory
+  if (!fs.existsSync(bonzaiDir)) {
+    console.log('Creating bonzai directory...');
+    fs.mkdirSync(bonzaiDir);
+  }
+
+  // Write receiver.js
+  console.log('Writing receiver.js...');
+  const receiverContent = fs.readFileSync(path.join(TEMPLATE_DIR, 'receiver.js'), 'utf8');
+  fs.writeFileSync(receiverPath, receiverContent);
+  fs.chmodSync(receiverPath, '755');
+
+  // Write config.js
+  console.log('Writing config.js...');
+  const configContent = fs.readFileSync(path.join(TEMPLATE_DIR, 'config.js'), 'utf8');
+  fs.writeFileSync(path.join(bonzaiDir, 'config.js'), configContent);
+
+  // Copy handlers from enabled loops
+  console.log('Copying handlers...');
+  const handlersDest = path.join(bonzaiDir, 'handlers');
+  if (!fs.existsSync(handlersDest)) {
+    fs.mkdirSync(handlersDest, { recursive: true });
+  }
+
+  // Copy visualization loop handlers
+  if (ENABLED_LOOPS.includes('visualization')) {
+    const vizSrc = path.join(TEMPLATE_DIR, 'loops', 'visualization');
+    if (fs.existsSync(vizSrc)) {
+      for (const file of fs.readdirSync(vizSrc)) {
+        fs.copyFileSync(path.join(vizSrc, file), path.join(handlersDest, file));
+      }
+    }
+  }
+
+  // Copy backend loop handlers
+  if (ENABLED_LOOPS.includes('backend')) {
+    const backendSrc = path.join(TEMPLATE_DIR, 'loops', 'backend');
+    if (fs.existsSync(backendSrc)) {
+      for (const file of fs.readdirSync(backendSrc)) {
+        fs.copyFileSync(path.join(backendSrc, file), path.join(handlersDest, file));
+      }
+    }
+  }
+
+  // Copy utils directory
+  console.log('Copying utils...');
+  const utilsSrc = path.join(TEMPLATE_DIR, 'utils');
+  const utilsDest = path.join(bonzaiDir, 'utils');
+  copyDirectory(utilsSrc, utilsDest);
+
+  // Write .ignore file in bonzai directory
+  const ignoreTargetPath = path.join(bonzaiDir, '.ignore');
+  if (!fs.existsSync(ignoreTargetPath)) {
+    console.log('Writing .ignore file...');
+    const ignoreContent = fs.readFileSync(path.join(TEMPLATE_DIR, 'ignore.txt'), 'utf8');
+    fs.writeFileSync(ignoreTargetPath, ignoreContent);
+  }
+
+  // Setup package.json in bonzai directory
+  const packageJsonPath = path.join(bonzaiDir, 'package.json');
+  let packageJson = {};
+
+  if (fs.existsSync(packageJsonPath)) {
+    packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+  } else {
+    packageJson = {
+      name: "bonzai-server",
+      version: "1.0.0",
+      description: "Dependencies for bonzai graph server",
+      main: "receiver.js",
+      scripts: {
+        test: "echo \"Error: no test specified\" && exit 1"
+      },
+      author: "",
+      license: "ISC"
+    };
+  }
+
+  // Add dependencies
+  if (!packageJson.dependencies) {
+    packageJson.dependencies = {};
+  }
+  packageJson.dependencies.express = "^4.18.2";
+  packageJson.dependencies.cors = "^2.8.5";
+  packageJson.dependencies["@babel/parser"] = "^7.23.0";
+  packageJson.dependencies.ws = "^8.14.2";
+  packageJson.dependencies["node-pty"] = "^1.0.0";
+
+  // Add script to run receiver
+  if (!packageJson.scripts) {
+    packageJson.scripts = {};
+  }
+  packageJson.scripts["file-server"] = "node receiver.js";
+
+  fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+
+  console.log('Installing dependencies...');
+
+  // Install dependencies in bonzai directory
+  return new Promise((resolve, reject) => {
+    const npm = spawn('npm', ['install'], {
+      stdio: 'inherit',
+      cwd: bonzaiDir
+    });
+
+    npm.on('close', (code) => {
+      if (code === 0) {
+        // Fix node-pty spawn-helper permissions (npm doesn't preserve execute bits)
+        const nodePtyPrebuilds = path.join(bonzaiDir, 'node_modules', 'node-pty', 'prebuilds');
+        if (fs.existsSync(nodePtyPrebuilds)) {
+          const archDirs = ['darwin-arm64', 'darwin-x64', 'linux-x64', 'linux-arm64'];
+          for (const arch of archDirs) {
+            const spawnHelperPath = path.join(nodePtyPrebuilds, arch, 'spawn-helper');
+            if (fs.existsSync(spawnHelperPath)) {
+              try {
+                fs.chmodSync(spawnHelperPath, '755');
+                console.log(`Fixed node-pty spawn-helper permissions (${arch})`);
+              } catch (e) {
+                console.warn(`Warning: Could not fix spawn-helper permissions for ${arch}:`, e.message);
+              }
+            }
+          }
+        }
+
+        console.log('\nListener endpoints successfully deployed');
+        console.log('All code stays on your machine\n');
+        console.log('Relay server running on localhost:3001');
+        console.log('Terminal WebSocket available at ws://localhost:3001/terminal');
+        console.log('Diagram available at https://bonzai.dev/\n');
+
+        // Start the server automatically
+        const server = spawn('node', ['receiver.js'], {
+          stdio: 'inherit',
+          cwd: bonzaiDir,
+          env: {
+            ...process.env,
+            BONZAI_REPO_DIR: currentDir
+          }
+        });
+
+        // Open browser automatically
+        exec('open https://bonzai.dev/');
+
+        // Handle server process
+        server.on('close', (serverCode) => {
+          console.log(`\nServer stopped with code ${serverCode}`);
+          process.exit(serverCode);
+        });
+
+        server.on('error', (err) => {
+          console.error('Error starting server:', err.message);
+          process.exit(1);
+        });
+
+        // Handle cleanup on exit
+        process.on('SIGINT', () => {
+          console.log('\nShutting down server...');
+          server.kill('SIGINT');
+        });
+
+        process.on('SIGTERM', () => {
+          console.log('\nShutting down server...');
+          server.kill('SIGTERM');
+        });
+
+        resolve();
+      } else {
+        reject(new Error('npm install failed with code ' + code));
+      }
+    });
+
+    npm.on('error', (err) => {
+      reject(err);
+    });
+  });
+}
+
+// Export for use via index.js flags
+export { main };
+
+// Run directly if called as standalone command
+const isDirectRun = process.argv[1]?.endsWith('bconfig.js');
+if (isDirectRun) {
+  main().catch(console.error);
+}

package/dist/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/dist/graph-templates/ignore.txt

@@ -0,0 +1,58 @@
+# Ignore patterns for file listing
+# Lines starting with # are comments
+# Use * for wildcards and ** for recursive patterns
+
+# Dependencies
+node_modules/
+package.json
+package-lock.json
+
+# IDE and editor files
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS generated files
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Environment and config files
+.env
+.env.local
+.env.production
+.env.staging
+
+# Version control
+.git/
+.gitignore
+.ignore
+
+# Logs
+*.log
+logs/
+
+# Build outputs
+dist/
+build/
+static/
+out/
+.next/
+*.min.js
+*.min.css
+*.bundle.js
+*.chunk.js
+
+# Temporary files
+*.tmp
+*.temp
+
+# Project-specific files
+receiver.js
+bonzai/
+

package/dist/graph-templates/loops/visualization/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/dist/graph-templates/loops/visualization/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/dist/graph-templates/loops/visualization/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/dist/graph-templates/receiver.js

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+
+const express = require('./node_modules/express');
+const cors = require('./node_modules/cors');
+const http = require('http');
+const fs = require('fs');
+const path = require('path');
+
+const app = express();
+const server = http.createServer(app);
+
+app.use(cors());
+app.use(express.json());
+
+// Root route
+app.get('/', (req, res) => {
+  res.json({ message: 'Bonzai Server', status: 'running' });
+});
+
+// Dynamically load handlers based on what exists
+const handlersDir = path.join(__dirname, 'handlers');
+
+function tryLoad(name) {
+  const filePath = path.join(handlersDir, name + '.js');
+  if (fs.existsSync(filePath)) {
+    return require(filePath);
+  }
+  return null;
+}
+
+// Visualization loop handlers
+const listHandler = tryLoad('list');
+const readHandler = tryLoad('read');
+const scanCodeQualityHandler = tryLoad('scan_code_quality');
+
+if (listHandler) app.get('/list', listHandler);
+if (readHandler) app.get('/read', readHandler);
+if (scanCodeQualityHandler) app.post('/scan_code_quality', scanCodeQualityHandler);
+
+// Backend loop handlers
+const deleteHandler = tryLoad('delete');
+const openCursorHandler = tryLoad('open-cursor');
+const writeHandler = tryLoad('write');
+const shutdownHandler = tryLoad('shutdown');
+const gitHandlers = tryLoad('git');
+const terminalHandlers = tryLoad('terminal');
+
+if (deleteHandler) app.post('/delete', deleteHandler);
+if (openCursorHandler) app.post('/open-cursor', openCursorHandler);
+if (writeHandler) app.post('/write', writeHandler);
+if (shutdownHandler) app.post('/shutdown', shutdownHandler);
+if (gitHandlers) {
+  app.get('/git/burns', gitHandlers.listBurns);
+  app.post('/git/checkout', gitHandlers.checkoutBranch);
+}
+if (terminalHandlers) {
+  const { WebSocketServer } = require('./node_modules/ws');
+  const wss = new WebSocketServer({ server, path: '/terminal' });
+  terminalHandlers.setupTerminalWebSocket(wss);
+  app.get('/terminal', terminalHandlers.terminalHandler);
+}
+
+const port = 3001;
+server.listen(port, () => {
+  console.log('File server running on http://localhost:' + port);
+});