devbonzai 2.0.9 → 2.1.1

package/templates/receiver.js

@@ -0,0 +1,1729 @@
+#!/usr/bin/env node
+
+const express = require('./node_modules/express');
+const cors = require('./node_modules/cors');
+const fs = require('fs');
+const path = require('path');
+const { exec, spawn, execSync } = 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, '..');
+
+app.use(cors());
+app.use(express.json());
+
+// Root route - simple 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',
+      'GET /git-churn?path=<filepath>&commits=30': 'Get git commit churn for a file',
+      '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'
+  });
+});
+
+// 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));
+}
+
+// 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];
+      const trimmed = line.trim();
+      
+      // Calculate indentation level
+      const match = line.match(/^\s*/);
+      const currentIndent = match ? match[0].length : 0;
+      
+      // 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/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
+        const functionName = funcMatch[1];
+        let functionContent = '';
+        
+        // Add decorators if any
+        if (decorators.length > 0) {
+          functionContent = decorators.join('\n') + '\n';
+          decorators = [];
+        }
+        
+        functionContent += line;
+        
+        currentFunction = {
+          name: functionName,
+          content: functionContent,
+          startLine: i + 1,
+          endLine: i + 1
+        };
+      } 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/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/class
+          if (funcMatch) {
+            const functionName = funcMatch[1];
+            let functionContent = '';
+            
+            if (decorators.length > 0) {
+              functionContent = decorators.join('\n') + '\n';
+              decorators = [];
+            }
+            
+            functionContent += line;
+            
+            currentFunction = {
+              name: functionName,
+              content: functionContent,
+              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/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/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, classes };
+  } catch (e) {
+    // If parsing fails (invalid Python, etc.), return empty arrays
+    console.warn('Failed to parse Python file:', filePath, e.message);
+    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);
+      };
+      
+      // Track visited nodes to avoid duplicates
+      const visitedNodes = new Set();
+      
+      // Traverse AST
+      function traverse(node, parentType = null) {
+        if (!node) return;
+        
+        // Skip if already visited (avoid processing same node twice)
+        if (visitedNodes.has(node)) return;
+        visitedNodes.add(node);
+        
+        // Function declarations: function myFunc() {}
+        // Skip if inside ExportNamedDeclaration (will be handled below)
+        if (node.type === 'FunctionDeclaration' && node.id && parentType !== 'ExportNamedDeclaration') {
+          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 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
+          });
+        }
+        
+        // Helper function to extract methods from a class body
+        const extractClassMethods = (classNode, className) => {
+          const methods = [];
+          if (classNode.body && classNode.body.body && Array.isArray(classNode.body.body)) {
+            for (const member of classNode.body.body) {
+              // Handle MethodDefinition (regular methods, constructors, getters, setters, static methods)
+              if (member && member.type === 'MethodDefinition' && member.key) {
+                let methodName;
+                if (member.key.type === 'Identifier') {
+                  methodName = member.key.name;
+                } else if (member.key.type === 'PrivateName') {
+                  methodName = '#' + member.key.id.name;
+                } else if (member.key.type === 'StringLiteral' || member.key.type === 'NumericLiteral') {
+                  methodName = String(member.key.value);
+                } else {
+                  methodName = String(member.key.value || member.key.name || 'unknown');
+                }
+                
+                // Include kind (constructor, get, set, method) in the name for clarity
+                const kind = member.kind || 'method';
+                const isStatic = member.static || false;
+                
+                // For getters and setters, include the kind in the method name to distinguish them
+                // e.g., "value" getter vs "value" setter -> "get value" and "set value"
+                let fullMethodName = methodName;
+                if (kind === 'get') {
+                  fullMethodName = 'get ' + methodName;
+                } else if (kind === 'set') {
+                  fullMethodName = 'set ' + methodName;
+                } else if (kind === 'constructor') {
+                  fullMethodName = 'constructor';
+                } else if (isStatic) {
+                  fullMethodName = 'static ' + methodName;
+                }
+                
+                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,
+                  kind: kind,
+                  static: isStatic
+                });
+              }
+            }
+          }
+          return methods;
+        };
+        
+        // Class declarations: class User { ... }
+        // Skip if inside ExportNamedDeclaration or ExportDefaultDeclaration (will be handled below)
+        if (node.type === 'ClassDeclaration' && node.id && 
+            parentType !== 'ExportNamedDeclaration' && parentType !== 'ExportDefaultDeclaration') {
+          const className = node.id.name;
+          const methods = extractClassMethods(node, className);
+          
+          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 class
+        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
+            });
+            // Mark as visited to avoid duplicate processing
+            visitedNodes.add(node.declaration);
+          } else if (node.declaration.type === 'ClassDeclaration' && node.declaration.id) {
+            const className = node.declaration.id.name;
+            const methods = extractClassMethods(node.declaration, className);
+            
+            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
+            });
+            // Mark as visited to avoid duplicate processing
+            visitedNodes.add(node.declaration);
+          }
+        }
+        
+        // Export default declarations: export default class
+        if (node.type === 'ExportDefaultDeclaration' && node.declaration) {
+          if (node.declaration.type === 'ClassDeclaration' && node.declaration.id) {
+            const className = node.declaration.id.name;
+            const methods = extractClassMethods(node.declaration, className);
+            
+            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,
+              isDefaultExport: true
+            });
+            // Mark as visited to avoid duplicate processing
+            visitedNodes.add(node.declaration);
+          } else 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,
+              isDefaultExport: true
+            });
+            visitedNodes.add(node.declaration);
+          }
+        }
+        
+        // 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(c => traverse(c, node.type));
+          } else if (child && typeof child === 'object' && child.type) {
+            traverse(child, node.type);
+          }
+        }
+      }
+      
+      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);
+      };
+      
+      // Track visited nodes to avoid duplicates
+      const visitedNodes = new Set();
+      
+      // Traverse AST (same logic as JavaScript parser)
+      function traverse(node, parentType = null) {
+        if (!node) return;
+        
+        // Skip if already visited (avoid processing same node twice)
+        if (visitedNodes.has(node)) return;
+        visitedNodes.add(node);
+        
+        // Function declarations: function myFunc() {}
+        // Skip if inside ExportNamedDeclaration (will be handled below)
+        if (node.type === 'FunctionDeclaration' && node.id && parentType !== 'ExportNamedDeclaration') {
+          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 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
+          });
+        }
+        
+        // Helper function to extract methods from a class body
+        const extractClassMethods = (classNode, className) => {
+          const methods = [];
+          if (classNode.body && classNode.body.body && Array.isArray(classNode.body.body)) {
+            for (const member of classNode.body.body) {
+              // Handle MethodDefinition (regular methods, constructors, getters, setters, static methods)
+              if (member && member.type === 'MethodDefinition' && member.key) {
+                let methodName;
+                if (member.key.type === 'Identifier') {
+                  methodName = member.key.name;
+                } else if (member.key.type === 'PrivateName') {
+                  methodName = '#' + member.key.id.name;
+                } else if (member.key.type === 'StringLiteral' || member.key.type === 'NumericLiteral') {
+                  methodName = String(member.key.value);
+                } else {
+                  methodName = String(member.key.value || member.key.name || 'unknown');
+                }
+                
+                // Include kind (constructor, get, set, method) in the name for clarity
+                const kind = member.kind || 'method';
+                const isStatic = member.static || false;
+                
+                // For getters and setters, include the kind in the method name to distinguish them
+                // e.g., "value" getter vs "value" setter -> "get value" and "set value"
+                let fullMethodName = methodName;
+                if (kind === 'get') {
+                  fullMethodName = 'get ' + methodName;
+                } else if (kind === 'set') {
+                  fullMethodName = 'set ' + methodName;
+                } else if (kind === 'constructor') {
+                  fullMethodName = 'constructor';
+                } else if (isStatic) {
+                  fullMethodName = 'static ' + methodName;
+                }
+                
+                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,
+                  kind: kind,
+                  static: isStatic
+                });
+              }
+            }
+          }
+          return methods;
+        };
+        
+        // Class declarations: class User { ... }
+        // Skip if inside ExportNamedDeclaration or ExportDefaultDeclaration (will be handled below)
+        if (node.type === 'ClassDeclaration' && node.id && 
+            parentType !== 'ExportNamedDeclaration' && parentType !== 'ExportDefaultDeclaration') {
+          const className = node.id.name;
+          const methods = extractClassMethods(node, className);
+          
+          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 class
+        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
+            });
+            // Mark as visited to avoid duplicate processing
+            visitedNodes.add(node.declaration);
+          } else if (node.declaration.type === 'ClassDeclaration' && node.declaration.id) {
+            const className = node.declaration.id.name;
+            const methods = extractClassMethods(node.declaration, className);
+            
+            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
+            });
+            // Mark as visited to avoid duplicate processing
+            visitedNodes.add(node.declaration);
+          }
+        }
+        
+        // Export default declarations: export default class
+        if (node.type === 'ExportDefaultDeclaration' && node.declaration) {
+          if (node.declaration.type === 'ClassDeclaration' && node.declaration.id) {
+            const className = node.declaration.id.name;
+            const methods = extractClassMethods(node.declaration, className);
+            
+            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,
+              isDefaultExport: true
+            });
+            // Mark as visited to avoid duplicate processing
+            visitedNodes.add(node.declaration);
+          } else 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,
+              isDefaultExport: true
+            });
+            visitedNodes.add(node.declaration);
+          }
+        }
+        
+        // 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(c => traverse(c, node.type));
+          } else if (child && typeof child === 'object' && child.type) {
+            traverse(child, node.type);
+          }
+        }
+      }
+      
+      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: [] };
+  }
+}
+
+// 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;
+}
+
+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);
+  }
+});
+
+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);
+  }
+});
+
+app.get('/git-churn', (req, res) => {
+  try {
+    const filePath = path.join(ROOT, req.query.path || '');
+    if (!filePath.startsWith(ROOT)) {
+      return res.status(400).json({ error: 'Invalid path' });
+    }
+    
+    // Get commits parameter, default to 30
+    const commits = parseInt(req.query.commits) || 30;
+    
+    // Get relative path from ROOT for git command
+    const relativePath = path.relative(ROOT, filePath);
+    
+    // Build git log command with relative path
+    const gitCommand = `git log --oneline --all -${commits} -- "${relativePath}"`;
+    
+    exec(gitCommand, { cwd: ROOT }, (error, stdout, stderr) => {
+      // If git command fails (no repo, file not tracked, etc.), return 0 churn
+      if (error) {
+        // Check if it's because file is not in git or no git repo
+        if (error.code === 128 || stderr.includes('not a git repository')) {
+          return res.json({ churn: 0 });
+        }
+        // For other errors, still return 0 churn gracefully
+        return res.json({ churn: 0 });
+      }
+      
+      // Count non-empty lines (each line is a commit)
+      const commitCount = stdout.trim().split('\n').filter(line => line.trim().length > 0).length;
+      
+      res.json({ churn: commitCount });
+    });
+  } catch (e) {
+    // Handle any other errors gracefully
+    res.status(500).json({ error: e.message, churn: 0 });
+  }
+});
+
+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);
+  }
+});
+
+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);
+  }
+});
+
+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);
+  }
+});
+
+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);
+  }
+});
+
+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 });
+  }
+});
+
+// Analyze prompt endpoint - asks agent what files it would modify without making changes
+app.post('/analyze_prompt', (req, res) => {
+  console.log('🔵 [analyze_prompt] Endpoint hit');
+  const { prompt } = req.body;
+  console.log('🔵 [analyze_prompt] Received prompt:', prompt ? `${prompt.substring(0, 50)}...` : 'none');
+
+  if (!prompt || typeof prompt !== 'string') {
+    console.log('❌ [analyze_prompt] Error: prompt required');
+    return res.status(400).json({ error: 'prompt required' });
+  }
+
+  // Configurable timeout (default 2 minutes for analysis)
+  const timeoutMs = parseInt(req.body.timeout) || 2 * 60 * 1000;
+  let timeoutId = null;
+  let responseSent = false;
+
+  // Build analysis prompt - ask agent to list files without making changes
+  const analysisPrompt = `You are analyzing a coding task. Do NOT make any changes to any files. Only analyze and list the files you would need to modify to complete this task.
+
+Respond ONLY with valid JSON in this exact format (no other text):
+{"files": [{"path": "path/to/file.ext", "reason": "brief reason for modification"}]}
+
+If no files need modification, respond with: {"files": []}
+
+Task to analyze: ${prompt}`;
+
+  const args = ['--print', '--force', '--workspace', '.', analysisPrompt];
+
+  console.log('🔵 [analyze_prompt] Spawning cursor-agent process...');
+  const proc = spawn(
+    'cursor-agent',
+    args,
+    {
+      cwd: ROOT,
+      env: process.env,
+      stdio: ['ignore', 'pipe', 'pipe']
+    }
+  );
+
+  console.log('🔵 [analyze_prompt] Process spawned, PID:', proc.pid);
+
+  let stdout = '';
+  let stderr = '';
+
+  timeoutId = setTimeout(() => {
+    if (!responseSent && proc && !proc.killed) {
+      console.log('⏱️  [analyze_prompt] Timeout reached, killing process...');
+      proc.kill('SIGTERM');
+      setTimeout(() => {
+        if (!proc.killed) proc.kill('SIGKILL');
+      }, 5000);
+      
+      if (!responseSent) {
+        responseSent = true;
+        res.status(500).json({
+          error: 'Process timeout',
+          message: `Analysis exceeded timeout of ${timeoutMs / 1000} seconds`
+        });
+      }
+    }
+  }, timeoutMs);
+
+  proc.stdout.on('data', (d) => {
+    stdout += d.toString();
+  });
+
+  proc.stderr.on('data', (d) => {
+    stderr += d.toString();
+  });
+
+  proc.on('error', (error) => {
+    console.log('❌ [analyze_prompt] Process error:', error.message);
+    if (timeoutId) clearTimeout(timeoutId);
+    if (!responseSent) {
+      responseSent = true;
+      return res.status(500).json({ error: error.message });
+    }
+  });
+
+  proc.on('close', (code, signal) => {
+    console.log('🔵 [analyze_prompt] Process closed with code:', code);
+    if (timeoutId) clearTimeout(timeoutId);
+    
+    if (!responseSent) {
+      responseSent = true;
+      
+      // Try to parse JSON from the output
+      try {
+        // Look for JSON in the output - it might be wrapped in other text
+        const jsonMatch = stdout.match(/\{[\s\S]*"files"[\s\S]*\}/);
+        if (jsonMatch) {
+          const parsed = JSON.parse(jsonMatch[0]);
+          console.log('✅ [analyze_prompt] Parsed files:', parsed.files);
+          res.json({ files: parsed.files || [] });
+        } else {
+          console.log('⚠️ [analyze_prompt] No JSON found in output, returning raw');
+          res.json({ 
+            files: [],
+            raw: stdout,
+            warning: 'Could not parse structured response'
+          });
+        }
+      } catch (parseError) {
+        console.log('⚠️ [analyze_prompt] JSON parse error:', parseError.message);
+        res.json({ 
+          files: [],
+          raw: stdout,
+          warning: 'Could not parse JSON: ' + parseError.message
+        });
+      }
+    }
+  });
+});
+
+app.post('/prompt_agent', (req, res) => {
+  console.log('🔵 [prompt_agent] Endpoint hit');
+  const { prompt } = req.body;
+  console.log('🔵 [prompt_agent] Received prompt:', prompt ? `${prompt.substring(0, 50)}...` : 'none');
+
+  if (!prompt || typeof prompt !== 'string') {
+    console.log('❌ [prompt_agent] Error: prompt required');
+    return res.status(400).json({ error: 'prompt required' });
+  }
+
+  // Capture beforeCommit
+  let beforeCommit = '';
+  try {
+    beforeCommit = execSync('git rev-parse HEAD', { cwd: ROOT }).toString().trim();
+    console.log('🔵 [prompt_agent] beforeCommit:', beforeCommit);
+  } catch (e) {
+    console.log('⚠️ [prompt_agent] Could not get beforeCommit:', e.message);
+  }
+
+  // Capture initial state of modified files (files already dirty before job starts)
+  const initiallyModifiedFiles = new Set();
+  try {
+    const initialStatus = execSync('git status --short', { cwd: ROOT }).toString();
+    initialStatus.split('\n').filter(Boolean).forEach(line => {
+      const filePath = line.substring(3).trim();
+      if (filePath) initiallyModifiedFiles.add(filePath);
+    });
+    console.log('🔵 [prompt_agent] Initially modified files:', Array.from(initiallyModifiedFiles));
+  } catch (e) {
+    console.log('⚠️ [prompt_agent] Could not get initial status:', e.message);
+  }
+
+  // Set up file change tracking - only track NEW changes during job
+  const changedFiles = new Set();
+  const pollInterval = setInterval(() => {
+    try {
+      const status = execSync('git status --short', { cwd: ROOT }).toString();
+      status.split('\n').filter(Boolean).forEach(line => {
+        const filePath = line.substring(3).trim(); // Remove status prefix (XY + space)
+        // Only add if this file was NOT already modified before the job started
+        if (filePath && !initiallyModifiedFiles.has(filePath)) {
+          const wasNew = !changedFiles.has(filePath);
+          changedFiles.add(filePath);
+          if (wasNew) {
+            console.log('📁 [prompt_agent] New file changed:', filePath);
+          }
+        }
+      });
+    } catch (e) {
+      // Ignore git status errors
+    }
+  }, 500);
+
+  // Configurable timeout (default 5 minutes)
+  const timeoutMs = parseInt(req.body.timeout) || 5 * 60 * 1000;
+  let timeoutId = null;
+  let responseSent = false;
+
+  // Build command arguments
+  const args = ['--print', '--force', '--workspace', '.', prompt];
+
+  console.log('🔵 [prompt_agent] Spawning cursor-agent process...');
+  const proc = spawn(
+    'cursor-agent',
+    args,
+    {
+      cwd: ROOT,
+      env: process.env,
+      stdio: ['ignore', 'pipe', 'pipe'] // Ignore stdin, pipe stdout/stderr
+    }
+  );
+
+  console.log('🔵 [prompt_agent] Process spawned, PID:', proc.pid);
+
+  let stdout = '';
+  let stderr = '';
+
+  // Set up timeout to kill process if it takes too long
+  timeoutId = setTimeout(() => {
+    if (!responseSent && proc && !proc.killed) {
+      console.log('⏱️  [prompt_agent] Timeout reached, killing process...');
+      clearInterval(pollInterval);
+      proc.kill('SIGTERM');
+      
+      // Force kill after a short grace period if SIGTERM doesn't work
+      setTimeout(() => {
+        if (!proc.killed) {
+          console.log('💀 [prompt_agent] Force killing process...');
+          proc.kill('SIGKILL');
+        }
+      }, 5000);
+      
+      if (!responseSent) {
+        responseSent = true;
+        res.status(500).json({
+          error: 'Process timeout',
+          message: `cursor-agent exceeded timeout of ${timeoutMs / 1000} seconds`,
+          code: -1,
+          stdout,
+          stderr,
+          changedFiles: Array.from(changedFiles),
+          beforeCommit,
+          afterCommit: ''
+        });
+      }
+    }
+  }, timeoutMs);
+
+  proc.stdout.on('data', (d) => {
+    const data = d.toString();
+    console.log('📤 [prompt_agent] stdout data received:', data.length, 'bytes');
+    stdout += data;
+  });
+
+  proc.stderr.on('data', (d) => {
+    const data = d.toString();
+    console.log('⚠️  [prompt_agent] stderr data received:', data.length, 'bytes');
+    stderr += data;
+  });
+
+  proc.on('error', (error) => {
+    console.log('❌ [prompt_agent] Process error:', error.message);
+    clearInterval(pollInterval);
+    if (timeoutId) clearTimeout(timeoutId);
+    if (!responseSent) {
+      responseSent = true;
+      return res.status(500).json({ error: error.message });
+    }
+  });
+
+  proc.on('close', (code, signal) => {
+    console.log('🔵 [prompt_agent] Process closed with code:', code, 'signal:', signal);
+    console.log('🔵 [prompt_agent] stdout length:', stdout.length);
+    console.log('🔵 [prompt_agent] stderr length:', stderr.length);
+    
+    // Stop polling for file changes
+    clearInterval(pollInterval);
+    if (timeoutId) clearTimeout(timeoutId);
+    
+    // Capture afterCommit
+    let afterCommit = '';
+    try {
+      afterCommit = execSync('git rev-parse HEAD', { cwd: ROOT }).toString().trim();
+      console.log('🔵 [prompt_agent] afterCommit:', afterCommit);
+    } catch (e) {
+      console.log('⚠️ [prompt_agent] Could not get afterCommit:', e.message);
+    }
+    
+    if (!responseSent) {
+      responseSent = true;
+      // Check if process was killed due to timeout
+      if (signal === 'SIGTERM' || signal === 'SIGKILL') {
+        res.status(500).json({
+          error: 'Process terminated',
+          message: signal === 'SIGTERM' ? 'Process was terminated due to timeout' : 'Process was force killed',
+          code: code || -1,
+          stdout,
+          stderr,
+          changedFiles: Array.from(changedFiles),
+          beforeCommit,
+          afterCommit
+        });
+      } else {
+        res.json({
+          code,
+          stdout,
+          stderr,
+          changedFiles: Array.from(changedFiles),
+          beforeCommit,
+          afterCommit
+        });
+      }
+    }
+  });
+});
+
+// Streaming version of prompt_agent using Server-Sent Events
+app.post('/prompt_agent_stream', (req, res) => {
+  console.log('🔵 [prompt_agent_stream] Endpoint hit');
+  const { prompt } = req.body;
+  console.log('🔵 [prompt_agent_stream] Received prompt:', prompt ? `${prompt.substring(0, 50)}...` : 'none');
+
+  if (!prompt || typeof prompt !== 'string') {
+    console.log('❌ [prompt_agent_stream] Error: prompt required');
+    return res.status(400).json({ error: 'prompt required' });
+  }
+
+  // Set up SSE headers
+  res.setHeader('Content-Type', 'text/event-stream');
+  res.setHeader('Cache-Control', 'no-cache');
+  res.setHeader('Connection', 'keep-alive');
+  res.setHeader('Access-Control-Allow-Origin', '*');
+  res.flushHeaders();
+
+  // Helper to send SSE events
+  const sendEvent = (type, data) => {
+    res.write(`data: ${JSON.stringify({ type, ...data })}\n\n`);
+  };
+
+  // Capture beforeCommit
+  let beforeCommit = '';
+  try {
+    beforeCommit = execSync('git rev-parse HEAD', { cwd: ROOT }).toString().trim();
+    console.log('🔵 [prompt_agent_stream] beforeCommit:', beforeCommit);
+  } catch (e) {
+    console.log('⚠️ [prompt_agent_stream] Could not get beforeCommit:', e.message);
+  }
+
+  // Capture initial state of modified files
+  const initiallyModifiedFiles = new Set();
+  try {
+    const initialStatus = execSync('git status --short', { cwd: ROOT }).toString();
+    initialStatus.split('\n').filter(Boolean).forEach(line => {
+      const filePath = line.substring(3).trim();
+      if (filePath) initiallyModifiedFiles.add(filePath);
+    });
+  } catch (e) {
+    // Ignore
+  }
+
+  // Send starting event
+  sendEvent('start', { beforeCommit });
+
+  // Set up file change tracking with real-time updates
+  const changedFiles = new Set();
+  const pollInterval = setInterval(() => {
+    try {
+      const status = execSync('git status --short', { cwd: ROOT }).toString();
+      status.split('\n').filter(Boolean).forEach(line => {
+        const filePath = line.substring(3).trim();
+        if (filePath && !initiallyModifiedFiles.has(filePath)) {
+          if (!changedFiles.has(filePath)) {
+            changedFiles.add(filePath);
+            console.log('📁 [prompt_agent_stream] File changed:', filePath);
+            // Send real-time update to client
+            sendEvent('file_changed', { path: filePath });
+          }
+        }
+      });
+    } catch (e) {
+      // Ignore git status errors
+    }
+  }, 500);
+
+  const timeoutMs = parseInt(req.body.timeout) || 5 * 60 * 1000;
+  let timeoutId = null;
+  let responseSent = false;
+
+  const args = ['--print', '--force', '--workspace', '.', prompt];
+
+  console.log('🔵 [prompt_agent_stream] Spawning cursor-agent process...');
+  const proc = spawn(
+    'cursor-agent',
+    args,
+    {
+      cwd: ROOT,
+      env: process.env,
+      stdio: ['ignore', 'pipe', 'pipe']
+    }
+  );
+
+  console.log('🔵 [prompt_agent_stream] Process spawned, PID:', proc.pid);
+
+  let stdout = '';
+  let stderr = '';
+
+  timeoutId = setTimeout(() => {
+    if (!responseSent && proc && !proc.killed) {
+      console.log('⏱️ [prompt_agent_stream] Timeout reached');
+      clearInterval(pollInterval);
+      proc.kill('SIGTERM');
+      
+      setTimeout(() => {
+        if (!proc.killed) proc.kill('SIGKILL');
+      }, 5000);
+      
+      if (!responseSent) {
+        responseSent = true;
+        sendEvent('error', {
+          error: 'Process timeout',
+          message: `cursor-agent exceeded timeout of ${timeoutMs / 1000} seconds`
+        });
+        sendEvent('complete', {
+          code: -1,
+          stdout,
+          stderr,
+          changedFiles: Array.from(changedFiles),
+          beforeCommit,
+          afterCommit: ''
+        });
+        res.end();
+      }
+    }
+  }, timeoutMs);
+
+  proc.stdout.on('data', (d) => {
+    stdout += d.toString();
+  });
+
+  proc.stderr.on('data', (d) => {
+    stderr += d.toString();
+  });
+
+  proc.on('error', (error) => {
+    console.log('❌ [prompt_agent_stream] Process error:', error.message);
+    clearInterval(pollInterval);
+    if (timeoutId) clearTimeout(timeoutId);
+    if (!responseSent) {
+      responseSent = true;
+      sendEvent('error', { error: error.message });
+      res.end();
+    }
+  });
+
+  proc.on('close', (code, signal) => {
+    console.log('🔵 [prompt_agent_stream] Process closed with code:', code);
+    clearInterval(pollInterval);
+    if (timeoutId) clearTimeout(timeoutId);
+    
+    let afterCommit = '';
+    try {
+      afterCommit = execSync('git rev-parse HEAD', { cwd: ROOT }).toString().trim();
+    } catch (e) {
+      // Ignore
+    }
+    
+    if (!responseSent) {
+      responseSent = true;
+      sendEvent('complete', {
+        code,
+        stdout,
+        stderr,
+        changedFiles: Array.from(changedFiles),
+        beforeCommit,
+        afterCommit
+      });
+      res.end();
+    }
+  });
+
+  // Handle client disconnect - DON'T kill the process, let it complete
+  req.on('close', () => {
+    console.log('🔵 [prompt_agent_stream] Client disconnected (process continues in background)');
+    // Don't kill the process - let it complete
+    // Just mark that we shouldn't try to send more events
+    responseSent = true;
+  });
+});
+
+// Revert job endpoint to reset to a previous commit
+app.post('/revert_job', (req, res) => {
+  console.log('🔵 [revert_job] Endpoint hit');
+  const { beforeCommit } = req.body;
+  
+  if (!beforeCommit || typeof beforeCommit !== 'string') {
+    console.log('❌ [revert_job] Error: beforeCommit required');
+    return res.status(400).json({ error: 'beforeCommit required' });
+  }
+  
+  // Validate commit hash format (basic sanitization to prevent command injection)
+  if (!/^[a-f0-9]{7,40}$/i.test(beforeCommit)) {
+    console.log('❌ [revert_job] Error: invalid commit hash format');
+    return res.status(400).json({ error: 'Invalid commit hash format' });
+  }
+  
+  try {
+    console.log('🔵 [revert_job] Resetting to commit:', beforeCommit);
+    execSync(`git reset --hard ${beforeCommit}`, { cwd: ROOT });
+    console.log('✅ [revert_job] Successfully reverted to commit:', beforeCommit);
+    res.json({ success: true });
+  } catch (e) {
+    console.log('❌ [revert_job] Error:', e.message);
+    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...');
+  
+  res.json({ 
+    success: true, 
+    message: 'Server shutting down...' 
+  });
+  
+  // Close the server gracefully
+  setTimeout(() => {
+    process.exit(0);
+  }, 100); // Small delay to ensure response is sent
+});
+
+const port = 3001;
+app.listen(port, () => {
+  console.log('📂 File server running on http://localhost:' + port);
+});
+