bonzai-tools 1.0.92

package/dist/graph-templates/receiver.js

@@ -0,0 +1,59 @@
+#!/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 { ROOT } = require('./config');
+
+const app = express();
+const server = http.createServer(app);
+
+app.use(cors());
+app.use(express.json());
+
+// Root route
+app.get('/', (req, res) => {
+  const repoName = path.basename(ROOT);
+  res.json({ message: 'Bonzai Server', status: 'running', repoName });
+});
+
+// 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');
+
+if (listHandler) app.get('/list', listHandler);
+if (readHandler) app.get('/read', readHandler);
+
+// Backend loop handlers
+const deleteHandler = tryLoad('delete');
+const writeHandler = tryLoad('write');
+const shutdownHandler = tryLoad('shutdown');
+const terminalHandlers = tryLoad('terminal');
+
+if (deleteHandler) app.post('/delete', deleteHandler);
+if (writeHandler) app.post('/write', writeHandler);
+if (shutdownHandler) app.post('/shutdown', shutdownHandler);
+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);
+});

package/dist/graph-templates/utils/fileList.js

@@ -0,0 +1,96 @@
+const fs = require('fs');
+const path = require('path');
+const { getIgnorePatterns, shouldIgnore } = require('./ignore');
+const { extractPythonFunctions, extractJavaScriptFunctions, extractVueFunctions } = require('./parsers');
+
+// Recursively list all files in a directory, respecting ignore patterns
+function listAllFiles(dir, base = '', ignorePatterns = null) {
+  if (ignorePatterns === null) {
+    ignorePatterns = getIgnorePatterns();
+  }
+  
+  let results = [];
+  const list = fs.readdirSync(dir);
+  
+  for (const file of list) {
+    const fullPath = path.join(dir, file);
+    const relativePath = path.join(base, file);
+    
+    // Check if this path should be ignored
+    if (shouldIgnore(relativePath, ignorePatterns)) {
+      continue;
+    }
+    
+    const stat = fs.statSync(fullPath);
+    if (stat && stat.isDirectory()) {
+      // Skip node_modules directories explicitly
+      if (file === 'node_modules' || relativePath.includes('node_modules/')) {
+        continue;
+      }
+      // Add the directory itself to results
+      results.push(relativePath + '/');
+      // Recursively list files inside the directory
+      results = results.concat(listAllFiles(fullPath, relativePath, ignorePatterns));
+    } else {
+      // Skip files in node_modules explicitly
+      if (relativePath.includes('node_modules/') || fullPath.includes('node_modules')) {
+        continue;
+      }
+      
+      results.push(relativePath);
+      
+      // Helper function to add functions, classes, and methods as virtual files
+      const addVirtualFiles = (parseResult, filePath) => {
+        // Add functions
+        for (const func of parseResult.functions) {
+          const functionFileName = func.name + '.function';
+          const functionFilePath = path.join(filePath, functionFileName).replace(/\\/g, '/');
+          results.push(functionFilePath);
+        }
+        
+        // Add classes and their methods
+        for (const cls of parseResult.classes) {
+          // Add class itself (optional, but useful)
+          const className = cls.name + '.class';
+          const classFilePath = path.join(filePath, className).replace(/\\/g, '/');
+          results.push(classFilePath);
+          
+          // Add methods nested under the class: ClassName.methodName
+          if (cls.methods && cls.methods.length > 0) {
+            for (const method of cls.methods) {
+              const methodFileName = method.name + '.method';
+              const methodFilePath = path.join(classFilePath, methodFileName).replace(/\\/g, '/');
+              results.push(methodFilePath);
+            }
+          }
+        }
+      };
+      
+      // Handle Python files
+      if (file.endsWith('.py')) {
+        const parseResult = extractPythonFunctions(fullPath);
+        addVirtualFiles(parseResult, relativePath);
+      }
+      
+      // Handle JavaScript/TypeScript files
+      // Skip .d.ts files (TypeScript declaration files) and .min.js files (minified)
+      if ((file.endsWith('.js') || file.endsWith('.jsx') || file.endsWith('.ts') || file.endsWith('.tsx')) &&
+          !file.endsWith('.d.ts') && !file.endsWith('.min.js')) {
+        const parseResult = extractJavaScriptFunctions(fullPath);
+        addVirtualFiles(parseResult, relativePath);
+      }
+      
+      // Handle Vue files
+      if (file.endsWith('.vue')) {
+        const parseResult = extractVueFunctions(fullPath);
+        addVirtualFiles(parseResult, relativePath);
+      }
+    }
+  }
+  return results;
+}
+
+module.exports = {
+  listAllFiles
+};
+

package/dist/graph-templates/utils/ignore.js

@@ -0,0 +1,52 @@
+const fs = require('fs');
+const path = require('path');
+
+// Read and parse ignore patterns from .ignore file
+function getIgnorePatterns() {
+  try {
+    const ignorePath = path.join(__dirname, '..', '.ignore');
+    if (fs.existsSync(ignorePath)) {
+      const content = fs.readFileSync(ignorePath, 'utf8');
+      return content
+        .split('\n')
+        .map(line => line.trim())
+        .filter(line => line && !line.startsWith('#'))
+        .map(pattern => {
+          // Convert simple glob patterns to regex
+          if (pattern.endsWith('/')) {
+            // Directory pattern
+            pattern = pattern.slice(0, -1);
+          }
+          
+          // Simple approach: escape dots and convert globs
+          pattern = pattern.replace(/\./g, '\\.');
+          pattern = pattern.replace(/\*\*/g, '|||DOUBLESTAR|||');
+          pattern = pattern.replace(/\*/g, '[^/]*');
+          pattern = pattern.replace(/\|\|\|DOUBLESTAR\|\|\|/g, '.*');
+          
+          return new RegExp('^' + pattern + '(/.*)?$');
+        });
+    }
+  } catch (e) {
+    console.warn('Could not read .ignore file:', e.message);
+  }
+  
+  // Default ignore patterns if no .ignore file exists
+  return [
+    /^node_modules(\/.*)?$/,
+    /^\.git(\/.*)?$/,
+    /^\.DS_Store$/,
+    /^\.env$/,
+  ];
+}
+
+// Check if a path should be ignored
+function shouldIgnore(relativePath, ignorePatterns) {
+  return ignorePatterns.some(pattern => pattern.test(relativePath));
+}
+
+module.exports = {
+  getIgnorePatterns,
+  shouldIgnore
+};
+