devbonzai 1.7.9 → 1.8.1

package/README.md

@@ -13,4 +13,72 @@ npm publish
 - node cli.js 
 - this will setup a receiver in this directory
 
-Used for Bonzai's linking functionality from web to local development environment. 
+Used for Bonzai's linking functionality from web to local development environment.
+
+## API Endpoints
+
+The server exposes several endpoints for file operations and code analysis:
+
+### Import Validation
+
+**POST /validate-imports** - Validate imports in a single file
+
+Request body:
+```json
+{
+  "filePath": "src/components/Button.js",
+  "imports": [
+    {
+      "path": "./utils",
+      "line": 5,
+      "symbols": [
+        { "name": "formatDate", "isDefault": false },
+        { "name": "default", "isDefault": true }
+      ]
+    }
+  ]
+}
+```
+
+Response:
+```json
+{
+  "file": "src/components/Button.js",
+  "errors": [
+    {
+      "line": 5,
+      "import": "./utils",
+      "symbol": "formatDate",
+      "error": "'formatDate' is not exported from './utils'"
+    }
+  ],
+  "errorCount": 1
+}
+```
+
+**POST /validate-imports-batch** - Validate imports for multiple files
+
+Request body:
+```json
+{
+  "files": [
+    {
+      "filePath": "src/components/Button.js",
+      "imports": [...]
+    },
+    {
+      "filePath": "src/components/Input.js",
+      "imports": [...]
+    }
+  ]
+}
+```
+
+Response: Array of validation results (same format as single file endpoint)
+
+### Supported Features
+
+- **JavaScript/TypeScript**: Validates default exports, named exports, and namespace imports
+- **Python**: Validates function, class, and variable imports
+- **File Resolution**: Automatically resolves relative imports and checks for files with common extensions (.js, .jsx, .ts, .tsx, .py, index files)
+- **External Packages**: Skips validation for node_modules imports 

package/cli.js

@@ -92,6 +92,8 @@ app.get('/', (req, res) => {
       'POST /move': 'Move file or folder (body: {source, destination})',
       'POST /open-cursor': 'Open Cursor (body: {path, line?})',
       'POST /prompt_agent': 'Execute cursor-agent command (body: {prompt})',
+      'POST /validate-imports': 'Validate imports in a file (body: {filePath, imports})',
+      'POST /validate-imports-batch': 'Validate imports for multiple files (body: {files})',
       'POST /shutdown': 'Gracefully shutdown the server'
     },
     example: 'Try: /list or /read?path=README.md'
@@ -817,10 +819,10 @@ function listAllFiles(dir, base = '', ignorePatterns = null) {
           const classFilePath = path.join(filePath, className).replace(/\\\\/g, '/');
           results.push(classFilePath);
           
-          // Add methods with dot notation: ClassName.methodName
+          // Add methods nested under the class: ClassName.methodName
           for (const method of cls.methods) {
             const methodFileName = method.name + '.method';
-            const methodFilePath = path.join(filePath, methodFileName).replace(/\\\\/g, '/');
+            const methodFilePath = path.join(classFilePath, methodFileName).replace(/\\\\/g, '/');
             results.push(methodFilePath);
           }
         }
@@ -889,47 +891,66 @@ app.get('/read', (req, res) => {
     
     // 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);
-      
-      // Determine file type and parser
-      let parseResult = null;
+      // Traverse up the path to find the actual source file
+      let currentPath = filePath;
+      let sourceFilePath = 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');
+      // 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 parent file exists
+      // Check if the source file exists
       try {
-        if (!fs.existsSync(parentFilePath)) {
-          return res.status(404).send('Parent file not found');
+        if (!fs.existsSync(sourceFilePath)) {
+          return res.status(404).send('Source 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';
-        }
+        const parseResult = parser(sourceFilePath);
         
         // Find and return the content
         const content = findAndReturn(parseResult, itemName, itemType);
@@ -1275,6 +1296,405 @@ app.post('/prompt_agent', (req, res) => {
   });
 });
 
+// Helper function to resolve import path relative to source file
+function resolveImportPath(importPath, sourceFilePath) {
+  // Remove root folder name if present
+  let relativeSourcePath = sourceFilePath;
+  const rootName = path.basename(ROOT);
+  if (relativeSourcePath.startsWith(rootName + '/')) {
+    relativeSourcePath = relativeSourcePath.substring(rootName.length + 1);
+  }
+  
+  const sourceDir = path.dirname(path.join(ROOT, relativeSourcePath));
+  
+  // Handle relative imports
+  if (importPath.startsWith('./') || importPath.startsWith('../')) {
+    const resolved = path.resolve(sourceDir, importPath);
+    return path.relative(ROOT, resolved).replace(/\\\\/g, '/');
+  }
+  
+  // Handle absolute imports (node_modules, etc.)
+  // For now, just return as-is - we'll check node_modules separately
+  return importPath;
+}
+
+// Helper function to check if a file exists (with various extensions)
+function findFileWithExtensions(basePath) {
+  const extensions = ['', '.js', '.jsx', '.ts', '.tsx', '.py', '/index.js', '/index.ts', '/index.tsx'];
+  const rootName = path.basename(ROOT);
+  
+  for (const ext of extensions) {
+    const testPath = basePath + ext;
+    
+    // Remove root folder name if present
+    let relativePath = testPath;
+    if (relativePath.startsWith(rootName + '/')) {
+      relativePath = relativePath.substring(rootName.length + 1);
+    }
+    const actualPath = path.join(ROOT, relativePath);
+    
+    if (fs.existsSync(actualPath) && fs.statSync(actualPath).isFile()) {
+      return relativePath;
+    }
+  }
+  
+  return null;
+}
+
+// Helper function to extract exports from JavaScript/TypeScript file
+function getJavaScriptExports(filePath) {
+  try {
+    if (!babelParser) {
+      return { default: false, named: [], all: false };
+    }
+    
+    const content = fs.readFileSync(filePath, 'utf8');
+    const isTypeScript = filePath.endsWith('.ts') || filePath.endsWith('.tsx');
+    
+    const ast = babelParser.parse(content, {
+      sourceType: 'module',
+      plugins: [
+        'typescript',
+        'jsx',
+        'decorators-legacy',
+        'classProperties',
+        'objectRestSpread',
+        'asyncGenerators',
+        'functionBind',
+        'exportDefaultFrom',
+        'exportNamespaceFrom',
+        'dynamicImport',
+        'nullishCoalescingOperator',
+        'optionalChaining'
+      ]
+    });
+    
+    const exports = { default: false, named: [], all: false };
+    
+    function traverse(node) {
+      if (!node) return;
+      
+      // export default
+      if (node.type === 'ExportDefaultDeclaration') {
+        exports.default = true;
+      }
+      
+      // export { A, B }
+      if (node.type === 'ExportNamedDeclaration') {
+        if (node.specifiers) {
+          node.specifiers.forEach(spec => {
+            if (spec.type === 'ExportSpecifier') {
+              const name = spec.exported.name || spec.exported.value;
+              if (name === '*') {
+                exports.all = true;
+              } else {
+                exports.named.push(name);
+              }
+            }
+          });
+        }
+        // export function/class
+        if (node.declaration) {
+          if (node.declaration.type === 'FunctionDeclaration' && node.declaration.id) {
+            exports.named.push(node.declaration.id.name);
+          } else if (node.declaration.type === 'ClassDeclaration' && node.declaration.id) {
+            exports.named.push(node.declaration.id.name);
+          }
+        }
+      }
+      
+      // export * from './file'
+      if (node.type === 'ExportAllDeclaration') {
+        exports.all = true;
+      }
+      
+      // Recursively traverse
+      for (const key in node) {
+        if (key === 'parent' || key === 'leadingComments' || key === 'trailingComments') continue;
+        const child = node[key];
+        if (Array.isArray(child)) {
+          child.forEach(c => traverse(c));
+        } else if (child && typeof child === 'object' && child.type) {
+          traverse(child);
+        }
+      }
+    }
+    
+    traverse(ast);
+    return exports;
+  } catch (e) {
+    // If parsing fails, return empty exports
+    return { default: false, named: [], all: false };
+  }
+}
+
+// Helper function to check if symbol exists in Python file
+function checkPythonSymbol(filePath, symbolName) {
+  try {
+    const content = fs.readFileSync(filePath, 'utf8');
+    const lines = content.split('\\n');
+    
+    // Check for function definitions
+    const funcPattern = new RegExp(\`^\\\\s*def\\\\s+\${symbolName}\\\\s*\\\\(\`);
+    // Check for class definitions
+    const classPattern = new RegExp(\`^\\\\s*class\\\\s+\${symbolName}\\\\s*[(:]\`);
+    // Check for variable assignments
+    const varPattern = new RegExp(\`^\\\\s*\${symbolName}\\\\s*=\`);
+    
+    for (const line of lines) {
+      if (funcPattern.test(line) || classPattern.test(line) || varPattern.test(line)) {
+        return true;
+      }
+    }
+    
+    // Check __all__ if present
+    const allMatch = content.match(/^__all__\\s*=\\s*\\[(.*?)\\]/m);
+    if (allMatch) {
+      const allExports = allMatch[1].split(',').map(s => s.trim().replace(/['"]/g, ''));
+      return allExports.includes(symbolName);
+    }
+    
+    return false;
+  } catch (e) {
+    return false;
+  }
+}
+
+// Validate imports for a single file
+app.post('/validate-imports', (req, res) => {
+  try {
+    const { filePath, imports } = req.body;
+    
+    if (!filePath || !imports || !Array.isArray(imports)) {
+      return res.status(400).json({ error: 'filePath and imports array required' });
+    }
+    
+    const errors = [];
+    const rootName = path.basename(ROOT);
+    
+    // Remove root folder name if present
+    let relativeFilePath = filePath;
+    if (relativeFilePath.startsWith(rootName + '/')) {
+      relativeFilePath = relativeFilePath.substring(rootName.length + 1);
+    }
+    
+    for (const imp of imports) {
+      const importPath = imp.path;
+      const symbols = imp.symbols || [];
+      
+      // Resolve import path
+      const resolvedPath = resolveImportPath(importPath, filePath);
+      
+      // Check if file exists
+      const foundFile = findFileWithExtensions(resolvedPath);
+      
+      if (!foundFile) {
+        // Check if it's a node_modules import (skip validation for external packages)
+        if (!importPath.startsWith('./') && !importPath.startsWith('../') && !importPath.startsWith('/')) {
+          // Likely a node_modules import, skip
+          continue;
+        }
+        
+        errors.push({
+          line: imp.line,
+          import: importPath,
+          error: \`Cannot find module '\${importPath}'\`
+        });
+        continue;
+      }
+      
+      // Check exports for each symbol
+      const fullFilePath = path.join(ROOT, foundFile);
+      const extension = foundFile.split('.').pop()?.toLowerCase();
+      
+      if (['js', 'jsx', 'ts', 'tsx'].includes(extension)) {
+        const exports = getJavaScriptExports(fullFilePath);
+        
+        for (const symbol of symbols) {
+          if (symbol.isNamespace || symbol.name === '*') {
+            // Namespace import - check if file has any exports
+            if (!exports.default && exports.named.length === 0 && !exports.all) {
+              errors.push({
+                line: imp.line,
+                import: importPath,
+                symbol: symbol.name,
+                error: \`Module '\${importPath}' has no exports\`
+              });
+            }
+          } else if (symbol.isDefault) {
+            if (!exports.default) {
+              errors.push({
+                line: imp.line,
+                import: importPath,
+                symbol: symbol.name,
+                error: \`'\${symbol.name}' is not exported as default from '\${importPath}'\`
+              });
+            }
+          } else {
+            // Named export
+            if (!exports.named.includes(symbol.name) && !exports.all) {
+              errors.push({
+                line: imp.line,
+                import: importPath,
+                symbol: symbol.name,
+                error: \`'\${symbol.name}' is not exported from '\${importPath}'\`
+              });
+            }
+          }
+        }
+      } else if (extension === 'py') {
+        // Python validation
+        for (const symbol of symbols) {
+          if (symbol.name === '*' || symbol.isNamespace) {
+            // Wildcard import - just check if file exists (already done)
+            continue;
+          }
+          
+          // Check if symbol exists in Python file
+          if (!checkPythonSymbol(fullFilePath, symbol.name)) {
+            errors.push({
+              line: imp.line,
+              import: importPath,
+              symbol: symbol.name,
+              error: \`'\${symbol.name}' is not defined in '\${importPath}'\`
+            });
+          }
+        }
+      }
+    }
+    
+    res.json({
+      file: filePath,
+      errors,
+      errorCount: errors.length
+    });
+  } catch (e) {
+    console.error('Error validating imports:', e);
+    res.status(500).json({ error: e.message });
+  }
+});
+
+// Validate imports for multiple files (batch)
+app.post('/validate-imports-batch', (req, res) => {
+  try {
+    const { files } = req.body;
+    
+    if (!files || !Array.isArray(files)) {
+      return res.status(400).json({ error: 'files array required' });
+    }
+    
+    const results = [];
+    
+    for (const file of files) {
+      const { filePath, imports } = file;
+      
+      if (!filePath || !imports || !Array.isArray(imports)) {
+        results.push({ file: filePath || 'unknown', errors: [], errorCount: 0 });
+        continue;
+      }
+      
+      const errors = [];
+      const rootName = path.basename(ROOT);
+      
+      // Remove root folder name if present
+      let relativeFilePath = filePath;
+      if (relativeFilePath.startsWith(rootName + '/')) {
+        relativeFilePath = relativeFilePath.substring(rootName.length + 1);
+      }
+      
+      for (const imp of imports) {
+        const importPath = imp.path;
+        const symbols = imp.symbols || [];
+        
+        // Resolve import path
+        const resolvedPath = resolveImportPath(importPath, filePath);
+        
+        // Check if file exists
+        const foundFile = findFileWithExtensions(resolvedPath);
+        
+        if (!foundFile) {
+          // Check if it's a node_modules import
+          if (!importPath.startsWith('./') && !importPath.startsWith('../') && !importPath.startsWith('/')) {
+            continue;
+          }
+          
+          errors.push({
+            line: imp.line,
+            import: importPath,
+            error: \`Cannot find module '\${importPath}'\`
+          });
+          continue;
+        }
+        
+        // Check exports
+        const fullFilePath = path.join(ROOT, foundFile);
+        const extension = foundFile.split('.').pop()?.toLowerCase();
+        
+        if (['js', 'jsx', 'ts', 'tsx'].includes(extension)) {
+          const exports = getJavaScriptExports(fullFilePath);
+          
+          for (const symbol of symbols) {
+            if (symbol.isNamespace || symbol.name === '*') {
+              if (!exports.default && exports.named.length === 0 && !exports.all) {
+                errors.push({
+                  line: imp.line,
+                  import: importPath,
+                  symbol: symbol.name,
+                  error: \`Module '\${importPath}' has no exports\`
+                });
+              }
+            } else if (symbol.isDefault) {
+              if (!exports.default) {
+                errors.push({
+                  line: imp.line,
+                  import: importPath,
+                  symbol: symbol.name,
+                  error: \`'\${symbol.name}' is not exported as default from '\${importPath}'\`
+                });
+              }
+            } else {
+              if (!exports.named.includes(symbol.name) && !exports.all) {
+                errors.push({
+                  line: imp.line,
+                  import: importPath,
+                  symbol: symbol.name,
+                  error: \`'\${symbol.name}' is not exported from '\${importPath}'\`
+                });
+              }
+            }
+          }
+        } else if (extension === 'py') {
+          for (const symbol of symbols) {
+            if (symbol.name === '*' || symbol.isNamespace) {
+              continue;
+            }
+            
+            if (!checkPythonSymbol(fullFilePath, symbol.name)) {
+              errors.push({
+                line: imp.line,
+                import: importPath,
+                symbol: symbol.name,
+                error: \`'\${symbol.name}' is not defined in '\${importPath}'\`
+              });
+            }
+          }
+        }
+      }
+      
+      results.push({
+        file: filePath,
+        errors,
+        errorCount: errors.length
+      });
+    }
+    
+    res.json(results);
+  } catch (e) {
+    console.error('Error validating imports batch:', e);
+    res.status(500).json({ error: e.message });
+  }
+});
+
 // Shutdown endpoint to kill the server
 app.post('/shutdown', (req, res) => {
   console.log('🛑 Shutdown endpoint called - terminating server...');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devbonzai",
-  "version": "1.7.9",
+  "version": "1.8.1",
   "description": "Quickly set up a local file server in any repository for browser-based file access",
   "main": "cli.js",
   "bin": {