devbonzai 1.6.8 → 1.7.0

package/cli.js

@@ -65,6 +65,12 @@ const cors = require('./node_modules/cors');
 const fs = require('fs');
 const path = require('path');
 const { exec, spawn } = require('child_process');
+let babelParser = null;
+try {
+  babelParser = require('./node_modules/@babel/parser');
+} catch (e) {
+  // Babel parser not available, will fall back gracefully
+}
 
 const app = express();
 const ROOT = path.join(__dirname, '..');
@@ -137,14 +143,17 @@ function shouldIgnore(relativePath, ignorePatterns) {
   return ignorePatterns.some(pattern => pattern.test(relativePath));
 }
 
-// Extract top-level functions from a Python file
+// Extract functions, classes, and methods from a Python file
 function extractPythonFunctions(filePath) {
   try {
     const content = fs.readFileSync(filePath, 'utf8');
     const lines = content.split('\\n');
     const functions = [];
+    const classes = [];
     let currentFunction = null;
+    let currentClass = null;
     let decorators = [];
+    let classIndent = -1;
     
     for (let i = 0; i < lines.length; i++) {
       const line = lines[i];
@@ -154,20 +163,102 @@ function extractPythonFunctions(filePath) {
       const match = line.match(/^\\s*/);
       const currentIndent = match ? match[0].length : 0;
       
-      // Check for decorators (only at top level, before function)
+      // Check for decorators (only at top level, before function/class)
       if (trimmed.startsWith('@') && currentIndent === 0) {
         decorators.push(line);
         continue;
       }
       
+      // Check if this is a top-level class definition
+      const classMatch = trimmed.match(/^class\\s+(\\w+)/);
+      if (classMatch && currentIndent === 0) {
+        // Save previous function/class if exists
+        if (currentFunction) {
+          currentFunction.content = currentFunction.content.trim();
+          functions.push(currentFunction);
+          currentFunction = null;
+        }
+        if (currentClass) {
+          currentClass.content = currentClass.content.trim();
+          classes.push(currentClass);
+        }
+        
+        // Start new class
+        const className = classMatch[1];
+        let classContent = '';
+        
+        // Add decorators if any
+        if (decorators.length > 0) {
+          classContent = decorators.join('\\n') + '\\n';
+          decorators = [];
+        }
+        
+        classContent += line;
+        classIndent = currentIndent;
+        
+        currentClass = {
+          name: className,
+          content: classContent,
+          methods: [],
+          startLine: i + 1,
+          endLine: i + 1
+        };
+        continue;
+      }
+      
+      // Check if this is a method definition (inside a class)
+      const methodMatch = trimmed.match(/^def\\s+(\\w+)\\s*\\(/);
+      if (methodMatch && currentClass && currentIndent > classIndent) {
+        // Save previous method if exists
+        if (currentFunction) {
+          currentFunction.content = currentFunction.content.trim();
+          currentClass.methods.push(currentFunction);
+          currentFunction = null;
+        }
+        
+        // Start new method
+        const methodName = methodMatch[1];
+        let methodContent = '';
+        
+        // Add decorators if any
+        if (decorators.length > 0) {
+          methodContent = decorators.join('\\n') + '\\n';
+          decorators = [];
+        }
+        
+        methodContent += line;
+        
+        currentFunction = {
+          name: currentClass.name + '.' + methodName,
+          content: methodContent,
+          startLine: i + 1,
+          endLine: i + 1,
+          isMethod: true,
+          className: currentClass.name,
+          methodName: methodName
+        };
+        continue;
+      }
+      
       // Check if this is a top-level function definition
       const funcMatch = trimmed.match(/^def\\s+(\\w+)\\s*\\(/);
       
       if (funcMatch && currentIndent === 0) {
-        // Save previous function if exists
+        // Save previous function/class if exists
         if (currentFunction) {
           currentFunction.content = currentFunction.content.trim();
+          if (currentFunction.isMethod && currentClass) {
+            currentClass.methods.push(currentFunction);
+          } else {
           functions.push(currentFunction);
+          }
+          currentFunction = null;
+        }
+        if (currentClass) {
+          currentClass.content = currentClass.content.trim();
+          classes.push(currentClass);
+          currentClass = null;
+          classIndent = -1;
         }
         
         // Start new function
@@ -188,15 +279,27 @@ function extractPythonFunctions(filePath) {
           startLine: i + 1,
           endLine: i + 1
         };
-      } else if (currentFunction) {
-        // We're processing lines after a function definition
+      } else if (currentFunction || currentClass) {
+        // We're processing lines after a function/class definition
         if (currentIndent === 0 && trimmed && !trimmed.startsWith('#')) {
-          // Back to top level with non-comment content - function ended
+          // Back to top level with non-comment content - function/class ended
+          if (currentFunction) {
           currentFunction.content = currentFunction.content.trim();
+            if (currentFunction.isMethod && currentClass) {
+              currentClass.methods.push(currentFunction);
+            } else {
           functions.push(currentFunction);
+            }
           currentFunction = null;
+          }
+          if (currentClass) {
+            currentClass.content = currentClass.content.trim();
+            classes.push(currentClass);
+            currentClass = null;
+            classIndent = -1;
+          }
           
-          // Check if this line starts a new function
+          // Check if this line starts a new function/class
           if (funcMatch) {
             const functionName = funcMatch[1];
             let functionContent = '';
@@ -214,28 +317,421 @@ function extractPythonFunctions(filePath) {
               startLine: i + 1,
               endLine: i + 1
             };
+          } else if (classMatch) {
+            const className = classMatch[1];
+            let classContent = '';
+            
+            if (decorators.length > 0) {
+              classContent = decorators.join('\\n') + '\\n';
+              decorators = [];
+            }
+            
+            classContent += line;
+            classIndent = currentIndent;
+            
+            currentClass = {
+              name: className,
+              content: classContent,
+              methods: [],
+              startLine: i + 1,
+              endLine: i + 1
+            };
           } else if (trimmed.startsWith('@')) {
             decorators.push(line);
           }
         } else {
-          // Still inside function (indented or empty/comment line)
+          // Still inside function/class (indented or empty/comment line)
+          if (currentFunction) {
           currentFunction.content += '\\n' + line;
           currentFunction.endLine = i + 1;
+          }
+          if (currentClass) {
+            currentClass.content += '\\n' + line;
+            currentClass.endLine = i + 1;
+          }
         }
       }
     }
     
-    // Don't forget the last function
+    // Don't forget the last function/class
     if (currentFunction) {
       currentFunction.content = currentFunction.content.trim();
+      if (currentFunction.isMethod && currentClass) {
+        currentClass.methods.push(currentFunction);
+      } else {
       functions.push(currentFunction);
+      }
+    }
+    if (currentClass) {
+      currentClass.content = currentClass.content.trim();
+      classes.push(currentClass);
     }
     
-    return functions;
+    return { functions, classes };
   } catch (e) {
-    // If parsing fails (invalid Python, etc.), return empty array
+    // If parsing fails (invalid Python, etc.), return empty arrays
     console.warn('Failed to parse Python file:', filePath, e.message);
-    return [];
+    return { functions: [], classes: [] };
+  }
+}
+
+// Extract functions, classes, and methods from a JavaScript/TypeScript file
+function extractJavaScriptFunctions(filePath) {
+  try {
+    if (!babelParser) {
+      return { functions: [], classes: [] };
+    }
+    
+    // Skip .d.ts files, minified files, and node_modules
+    if (filePath.endsWith('.d.ts') || filePath.endsWith('.min.js') || filePath.includes('node_modules')) {
+      return { functions: [], classes: [] };
+    }
+    
+    const content = fs.readFileSync(filePath, 'utf8');
+    const functions = [];
+    const classes = [];
+    
+    // Determine if it's TypeScript
+    const isTypeScript = filePath.endsWith('.ts') || filePath.endsWith('.tsx');
+    
+    try {
+      const ast = babelParser.parse(content, {
+        sourceType: 'module',
+        plugins: [
+          'typescript',
+          'jsx',
+          'decorators-legacy',
+          'classProperties',
+          'objectRestSpread',
+          'asyncGenerators',
+          'functionBind',
+          'exportDefaultFrom',
+          'exportNamespaceFrom',
+          'dynamicImport',
+          'nullishCoalescingOperator',
+          'optionalChaining'
+        ]
+      });
+      
+      // Helper to extract code snippet from source
+      const getCode = (node) => {
+        return content.substring(node.start, node.end);
+      };
+      
+      // Traverse AST
+      function traverse(node) {
+        if (!node) return;
+        
+        // Function declarations: function myFunc() {}
+        if (node.type === 'FunctionDeclaration' && node.id) {
+          functions.push({
+            name: node.id.name,
+            content: getCode(node),
+            startLine: node.loc ? node.loc.start.line : 0,
+            endLine: node.loc ? node.loc.end.line : 0
+          });
+        }
+        
+        // Arrow functions: const myFunc = () => {}
+        if (node.type === 'VariableDeclarator' && 
+            node.init && 
+            (node.init.type === 'ArrowFunctionExpression' || node.init.type === 'FunctionExpression') &&
+            node.id && node.id.type === 'Identifier') {
+          const funcNode = node.init;
+          const funcContent = getCode(node);
+          functions.push({
+            name: node.id.name,
+            content: funcContent,
+            startLine: node.loc ? node.loc.start.line : 0,
+            endLine: node.loc ? node.loc.end.line : 0
+          });
+        }
+        
+        // Class declarations: class User { ... }
+        if (node.type === 'ClassDeclaration' && node.id) {
+          const className = node.id.name;
+          const methods = [];
+          
+          // Extract methods
+          if (node.body && node.body.body) {
+            for (const member of node.body.body) {
+              if (member.type === 'MethodDefinition' && member.key) {
+                const methodName = member.key.type === 'Identifier' ? member.key.name : 
+                                 member.key.type === 'PrivateName' ? '#' + member.key.id.name :
+                                 String(member.key.value || member.key.name);
+                methods.push({
+                  name: className + '.' + methodName,
+                  content: getCode(member),
+                  startLine: member.loc ? member.loc.start.line : 0,
+                  endLine: member.loc ? member.loc.end.line : 0,
+                  isMethod: true,
+                  className: className,
+                  methodName: methodName
+                });
+              }
+            }
+          }
+          
+          classes.push({
+            name: className,
+            content: getCode(node),
+            methods: methods,
+            startLine: node.loc ? node.loc.start.line : 0,
+            endLine: node.loc ? node.loc.end.line : 0
+          });
+        }
+        
+        // Export declarations: export function, export default
+        if (node.type === 'ExportNamedDeclaration' && node.declaration) {
+          if (node.declaration.type === 'FunctionDeclaration' && node.declaration.id) {
+            functions.push({
+              name: node.declaration.id.name,
+              content: getCode(node.declaration),
+              startLine: node.declaration.loc ? node.declaration.loc.start.line : 0,
+              endLine: node.declaration.loc ? node.declaration.loc.end.line : 0,
+              isExported: true
+            });
+          } else if (node.declaration.type === 'ClassDeclaration' && node.declaration.id) {
+            const className = node.declaration.id.name;
+            const methods = [];
+            
+            if (node.declaration.body && node.declaration.body.body) {
+              for (const member of node.declaration.body.body) {
+                if (member.type === 'MethodDefinition' && member.key) {
+                  const methodName = member.key.type === 'Identifier' ? member.key.name :
+                                   member.key.type === 'PrivateName' ? '#' + member.key.id.name :
+                                   String(member.key.value || member.key.name);
+                  methods.push({
+                    name: className + '.' + methodName,
+                    content: getCode(member),
+                    startLine: member.loc ? member.loc.start.line : 0,
+                    endLine: member.loc ? member.loc.end.line : 0,
+                    isMethod: true,
+                    className: className,
+                    methodName: methodName
+                  });
+                }
+              }
+            }
+            
+            classes.push({
+              name: className,
+              content: getCode(node.declaration),
+              methods: methods,
+              startLine: node.declaration.loc ? node.declaration.loc.start.line : 0,
+              endLine: node.declaration.loc ? node.declaration.loc.end.line : 0,
+              isExported: true
+            });
+          }
+        }
+        
+        // Recursively traverse children
+        for (const key in node) {
+          if (key === 'parent' || key === 'leadingComments' || key === 'trailingComments') continue;
+          const child = node[key];
+          if (Array.isArray(child)) {
+            child.forEach(traverse);
+          } else if (child && typeof child === 'object' && child.type) {
+            traverse(child);
+          }
+        }
+      }
+      
+      traverse(ast);
+    } catch (parseError) {
+      // Silently skip parsing errors - these are expected for some files
+      // Only log if it's not in node_modules or a known problematic file type
+      if (!filePath.includes('node_modules') && !filePath.endsWith('.d.ts') && !filePath.endsWith('.min.js')) {
+        // Suppress warnings for common parsing issues
+        const errorMsg = parseError.message || '';
+        if (!errorMsg.includes('outside of function') && 
+            !errorMsg.includes('Missing initializer') &&
+            !errorMsg.includes('Export') &&
+            !errorMsg.includes('Unexpected token')) {
+          // Only log unexpected errors
+        }
+      }
+      return { functions: [], classes: [] };
+    }
+    
+    return { functions, classes };
+  } catch (e) {
+    console.warn('Failed to read JavaScript/TypeScript file:', filePath, e.message);
+    return { functions: [], classes: [] };
+  }
+}
+
+// Extract script content from Vue file and parse it
+function extractVueFunctions(filePath) {
+  try {
+    const content = fs.readFileSync(filePath, 'utf8');
+    
+    // Extract <script> section from Vue file
+    const scriptMatch = content.match(/<script[^>]*>([\\s\\S]*?)<\\/script>/);
+    if (!scriptMatch) {
+      return { functions: [], classes: [] };
+    }
+    
+    const scriptContent = scriptMatch[1];
+    
+    // Create a temporary file path for parsing (just for reference)
+    // Parse the script content as JavaScript/TypeScript
+    if (!babelParser) {
+      return { functions: [], classes: [] };
+    }
+    
+    const functions = [];
+    const classes = [];
+    
+    // Check if it's TypeScript
+    const isTypeScript = scriptMatch[0].includes('lang="ts"') || scriptMatch[0].includes("lang='ts'");
+    
+    try {
+      const ast = babelParser.parse(scriptContent, {
+        sourceType: 'module',
+        plugins: [
+          'typescript',
+          'jsx',
+          'decorators-legacy',
+          'classProperties',
+          'objectRestSpread',
+          'asyncGenerators',
+          'functionBind',
+          'exportDefaultFrom',
+          'exportNamespaceFrom',
+          'dynamicImport',
+          'nullishCoalescingOperator',
+          'optionalChaining'
+        ]
+      });
+      
+      // Helper to extract code snippet from source
+      const getCode = (node) => {
+        return scriptContent.substring(node.start, node.end);
+      };
+      
+      // Traverse AST (same logic as JavaScript parser)
+      function traverse(node) {
+        if (!node) return;
+        
+        if (node.type === 'FunctionDeclaration' && node.id) {
+          functions.push({
+            name: node.id.name,
+            content: getCode(node),
+            startLine: node.loc ? node.loc.start.line : 0,
+            endLine: node.loc ? node.loc.end.line : 0
+          });
+        }
+        
+        if (node.type === 'VariableDeclarator' && 
+            node.init && 
+            (node.init.type === 'ArrowFunctionExpression' || node.init.type === 'FunctionExpression') &&
+            node.id && node.id.type === 'Identifier') {
+          const funcContent = getCode(node);
+          functions.push({
+            name: node.id.name,
+            content: funcContent,
+            startLine: node.loc ? node.loc.start.line : 0,
+            endLine: node.loc ? node.loc.end.line : 0
+          });
+        }
+        
+        if (node.type === 'ClassDeclaration' && node.id) {
+          const className = node.id.name;
+          const methods = [];
+          
+          if (node.body && node.body.body) {
+            for (const member of node.body.body) {
+              if (member.type === 'MethodDefinition' && member.key) {
+                const methodName = member.key.type === 'Identifier' ? member.key.name :
+                                 member.key.type === 'PrivateName' ? '#' + member.key.id.name :
+                                 String(member.key.value || member.key.name);
+                methods.push({
+                  name: className + '.' + methodName,
+                  content: getCode(member),
+                  startLine: member.loc ? member.loc.start.line : 0,
+                  endLine: member.loc ? member.loc.end.line : 0,
+                  isMethod: true,
+                  className: className,
+                  methodName: methodName
+                });
+              }
+            }
+          }
+          
+          classes.push({
+            name: className,
+            content: getCode(node),
+            methods: methods,
+            startLine: node.loc ? node.loc.start.line : 0,
+            endLine: node.loc ? node.loc.end.line : 0
+          });
+        }
+        
+        if (node.type === 'ExportNamedDeclaration' && node.declaration) {
+          if (node.declaration.type === 'FunctionDeclaration' && node.declaration.id) {
+            functions.push({
+              name: node.declaration.id.name,
+              content: getCode(node.declaration),
+              startLine: node.declaration.loc ? node.declaration.loc.start.line : 0,
+              endLine: node.declaration.loc ? node.declaration.loc.end.line : 0,
+              isExported: true
+            });
+          } else if (node.declaration.type === 'ClassDeclaration' && node.declaration.id) {
+            const className = node.declaration.id.name;
+            const methods = [];
+            
+            if (node.declaration.body && node.declaration.body.body) {
+              for (const member of node.declaration.body.body) {
+                if (member.type === 'MethodDefinition' && member.key) {
+                  const methodName = member.key.type === 'Identifier' ? member.key.name :
+                                   member.key.type === 'PrivateName' ? '#' + member.key.id.name :
+                                   String(member.key.value || member.key.name);
+                  methods.push({
+                    name: className + '.' + methodName,
+                    content: getCode(member),
+                    startLine: member.loc ? member.loc.start.line : 0,
+                    endLine: member.loc ? member.loc.end.line : 0,
+                    isMethod: true,
+                    className: className,
+                    methodName: methodName
+                  });
+                }
+              }
+            }
+            
+            classes.push({
+              name: className,
+              content: getCode(node.declaration),
+              methods: methods,
+              startLine: node.declaration.loc ? node.declaration.loc.start.line : 0,
+              endLine: node.declaration.loc ? node.declaration.loc.end.line : 0,
+              isExported: true
+            });
+          }
+        }
+        
+        for (const key in node) {
+          if (key === 'parent' || key === 'leadingComments' || key === 'trailingComments') continue;
+          const child = node[key];
+          if (Array.isArray(child)) {
+            child.forEach(traverse);
+          } else if (child && typeof child === 'object' && child.type) {
+            traverse(child);
+          }
+        }
+      }
+      
+      traverse(ast);
+    } catch (parseError) {
+      // Silently skip parsing errors for Vue files
+      return { functions: [], classes: [] };
+    }
+    
+    return { functions, classes };
+  } catch (e) {
+    console.warn('Failed to read Vue file:', filePath, e.message);
+    return { functions: [], classes: [] };
   }
 }
 
@@ -259,23 +755,65 @@ function listAllFiles(dir, base = '', ignorePatterns = null) {
     
     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);
       
-      // If this is a Python file, extract functions and add them as virtual files
-      if (file.endsWith('.py')) {
-        const functions = extractPythonFunctions(fullPath);
-        for (const func of functions) {
-          // Add function file as downstream from the Python file
-          // Format: <python_file_path>/<function_name.function>
+      // 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 = relativePath + '/' + functionFileName;
+          const functionFilePath = filePath + '/' + functionFileName;
           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 = filePath + '/' + className;
+          results.push(classFilePath);
+          
+          // Add methods with dot notation: ClassName.methodName
+          for (const method of cls.methods) {
+            const methodFileName = method.name + '.method';
+            const methodFilePath = filePath + '/' + methodFileName;
+            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);
       }
     }
   }
@@ -301,30 +839,80 @@ app.get('/read', (req, res) => {
       return res.status(400).send('Invalid path');
     }
     
-    // Check if this is a .function file request
-    if (requestedPath.endsWith('.function')) {
-      // Extract function name and Python file path
-      // Path format: <python_file_path>/<function_name.function>
-      const functionFileName = path.basename(requestedPath, '.function');
-      const pythonFilePath = path.dirname(filePath);
+    // 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')) {
+      const parentFilePath = path.dirname(filePath);
+      const parentRelativePath = path.relative(ROOT, parentFilePath);
+      const fileName = path.basename(parentRelativePath);
       
-      // Check if the Python file exists
+      // Determine file type and parser
+      let parseResult = null;
+      let parser = null;
+      
+      if (fileName.endsWith('.py')) {
+        parser = extractPythonFunctions;
+      } else if (fileName.endsWith('.js') || fileName.endsWith('.jsx') || fileName.endsWith('.ts') || fileName.endsWith('.tsx')) {
+        parser = extractJavaScriptFunctions;
+      } else if (fileName.endsWith('.vue')) {
+        parser = extractVueFunctions;
+      } else {
+        return res.status(404).send('Parent file type not supported');
+      }
+      
+      // Check if the parent file exists
       try {
-        if (!fs.existsSync(pythonFilePath) || !pythonFilePath.endsWith('.py')) {
-          return res.status(404).send('Parent Python file not found');
+        if (!fs.existsSync(parentFilePath)) {
+          return res.status(404).send('Parent file not found');
+        }
+        
+        // Parse the file
+        parseResult = parser(parentFilePath);
+        
+        // Extract the requested item name
+        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';
         }
         
-        // Extract functions from the Python file
-        const functions = extractPythonFunctions(pythonFilePath);
-        const targetFunction = functions.find(f => f.name === functionFileName);
+        // Find and return the content
+        const content = findAndReturn(parseResult, itemName, itemType);
         
-        if (!targetFunction) {
-          return res.status(404).send('Function not found in Python file');
+        if (!content) {
+          return res.status(404).send(\`\${itemType} '\${itemName}' not found in file\`);
         }
         
-        return res.json({ content: targetFunction.content });
+        return res.json({ content });
       } catch (e) {
-        return res.status(500).send('Error reading function: ' + e.message);
+        const errorType = requestedPath.endsWith('.function') ? 'function' : 
+                         requestedPath.endsWith('.method') ? 'method' : 'class';
+        return res.status(500).send('Error reading ' + errorType + ': ' + e.message);
       }
     }
     
@@ -736,6 +1324,7 @@ async function main() {
   packageJson.dependencies.cors = "^2.8.5";
   packageJson.dependencies["body-parser"] = "^1.20.2";
   packageJson.dependencies["raw-body"] = "^2.5.2";
+  packageJson.dependencies["@babel/parser"] = "^7.23.0";
   
   // Add script to run receiver
   if (!packageJson.scripts) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devbonzai",
-  "version": "1.6.8",
+  "version": "1.7.0",
   "description": "Quickly set up a local file server in any repository for browser-based file access",
   "main": "cli.js",
   "bin": {
@@ -21,6 +21,7 @@
     "express": "^4.18.2",
     "cors": "^2.8.5",
     "body-parser": "^1.20.2",
-    "raw-body": "^2.5.2"
+    "raw-body": "^2.5.2",
+    "@babel/parser": "^7.23.0"
   }
 }