devbonzai 2.1.2 → 2.1.3

package/templates/routes/crud.js

@@ -1,208 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-const { listAllFiles } = require('../utils/file-list');
-const { extractPythonFunctions, extractJavaScriptFunctions, extractVueFunctions } = require('../utils/parsers');
-
-function setupCrudRoutes(app, ROOT) {
-  // GET /list - List all files
-  app.get('/list', (req, res) => {
-    try {
-      const rootName = path.basename(ROOT);
-      const files = listAllFiles(ROOT, rootName);
-      res.json({ files });
-    } catch (e) {
-      res.status(500).send(e.message);
-    }
-  });
-
-  // GET /read - Read file content
-  app.get('/read', (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);
-    }
-  });
-
-  // POST /write - Write file content
-  app.post('/write', (req, res) => {
-    try {
-      const filePath = path.join(ROOT, req.body.path || '');
-      if (!filePath.startsWith(ROOT)) {
-        return res.status(400).send('Invalid path');
-      }
-      fs.writeFileSync(filePath, req.body.content, 'utf8');
-      res.json({ status: 'ok' });
-    } catch (e) {
-      res.status(500).send(e.message);
-    }
-  });
-
-  // POST /write_dir - Create directory
-  app.post('/write_dir', (req, res) => {
-    try {
-      const dirPath = path.join(ROOT, req.body.path || '');
-      if (!dirPath.startsWith(ROOT)) {
-        return res.status(400).send('Invalid path');
-      }
-      // Create directory recursively (creates parent directories if they don't exist)
-      fs.mkdirSync(dirPath, { recursive: true });
-      res.json({ status: 'ok' });
-    } catch (e) {
-      res.status(500).send(e.message);
-    }
-  });
-
-  // POST /delete - Delete file or directory
-  app.post('/delete', (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);
-    }
-  });
-
-  // POST /move - Move file or folder
-  app.post('/move', (req, res) => {
-    try {
-      const sourcePath = path.join(ROOT, req.body.source || '');
-      const destinationPath = path.join(ROOT, req.body.destination || '');
-      
-      // Validate both paths are within ROOT directory
-      if (!sourcePath.startsWith(ROOT) || !destinationPath.startsWith(ROOT)) {
-        return res.status(400).send('Invalid path');
-      }
-      
-      // Check if source exists
-      if (!fs.existsSync(sourcePath)) {
-        return res.status(400).send('Source path does not exist');
-      }
-      
-      // Ensure destination directory exists
-      const destinationDir = path.dirname(destinationPath);
-      if (!fs.existsSync(destinationDir)) {
-        fs.mkdirSync(destinationDir, { recursive: true });
-      }
-      
-      // Move the file or folder
-      fs.renameSync(sourcePath, destinationPath);
-      res.json({ status: 'ok' });
-    } catch (e) {
-      res.status(500).send(e.message);
-    }
-  });
-}
-
-module.exports = { setupCrudRoutes };
-

package/templates/routes/infra.js

@@ -1,147 +0,0 @@
-const path = require('path');
-const { exec } = require('child_process');
-
-function setupInfraRoutes(app, ROOT) {
-  // GET / - Root route with API documentation
-  app.get('/', (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 /write': 'Write file content (body: {path, content})',
-        'POST /write_dir': 'Create directory (body: {path})',
-        'POST /delete': 'Delete file or directory (body: {path})',
-        'POST /move': 'Move file or folder (body: {source, destination})',
-        'POST /open-cursor': 'Open Cursor (body: {path, line?})',
-        'POST /analyze_prompt': 'Analyze what files would be modified (body: {prompt})',
-        'POST /prompt_agent': 'Execute cursor-agent command (body: {prompt})',
-        'POST /prompt_agent_stream': 'Execute cursor-agent with SSE streaming (body: {prompt})',
-        'POST /revert_job': 'Revert to a previous commit (body: {beforeCommit})',
-        'POST /shutdown': 'Gracefully shutdown the server'
-      },
-      example: 'Try: /list or /read?path=README.md'
-    });
-  });
-
-  // POST /open-cursor - Open file in Cursor IDE
-  app.post('/open-cursor', (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 });
-    }
-  });
-
-  // POST /shutdown - Gracefully shutdown the server
-  app.post('/shutdown', (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 = { setupInfraRoutes };
-

package/templates/utils/file-list.js

@@ -1,96 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-const { getIgnorePatterns, shouldIgnore } = require('./ignore-patterns');
-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/templates/utils/ignore-patterns.js

@@ -1,53 +0,0 @@
-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$/,
-    /^bonzai(\/.*)?$/
-  ];
-}
-
-// Check if a path should be ignored
-function shouldIgnore(relativePath, ignorePatterns) {
-  return ignorePatterns.some(pattern => pattern.test(relativePath));
-}
-
-module.exports = {
-  getIgnorePatterns,
-  shouldIgnore
-};
-