ai-first-cli 1.3.5 → 1.3.6

package/src/analyzers/entrypoints.ts

@@ -96,6 +96,33 @@ export function discoverEntrypoints(files: FileInfo[], rootDir: string): Entrypo
     } catch {}
   }
   
+  // Detect Go entrypoints
+  const goFiles = files.filter(f => f.extension === "go");
+  if (goFiles.length > 0) {
+    try {
+      const goEntrypoints = discoverGoEntrypoints(goFiles, rootDir);
+      entrypoints.push(...goEntrypoints);
+    } catch {}
+  }
+  
+  // Detect Rust entrypoints
+  const rustFiles = files.filter(f => f.extension === "rs");
+  if (rustFiles.length > 0) {
+    try {
+      const rustEntrypoints = discoverRustEntrypoints(rustFiles, rootDir);
+      entrypoints.push(...rustEntrypoints);
+    } catch {}
+  }
+  
+  // Detect PHP entrypoints
+  const phpFiles = files.filter(f => f.extension === "php");
+  if (phpFiles.length > 0) {
+    try {
+      const phpEntrypoints = discoverPHPEntrypoints(phpFiles, rootDir);
+      entrypoints.push(...phpEntrypoints);
+    } catch {}
+  }
+  
   return entrypoints;
 }
 
@@ -276,6 +303,264 @@ function getScriptType(name: string): Entrypoint["type"] | null {
   return null;
 }
 
+function discoverGoEntrypoints(goFiles: FileInfo[], rootDir: string): Entrypoint[] {
+  const entrypoints: Entrypoint[] = [];
+  
+  for (const file of goFiles) {
+    try {
+      const content = readFile(path.join(rootDir, file.relativePath));
+      const fileName = file.name;
+      
+      if (fileName === "main.go") {
+        const hasMain = content.match(/func\s+main\s*\(\s*\)/);
+        const packageMatch = content.match(/package\s+(\w+)/);
+        const packageName = packageMatch ? packageMatch[1] : "main";
+        
+        const handlers: string[] = [];
+        const handlerMatches = content.matchAll(/http\.HandleFunc\s*\(\s*["']([^"']+)["']/g);
+        for (const match of handlerMatches) {
+          handlers.push(match[1]);
+        }
+        
+        const portMatches = content.matchAll(/:\s*(\d{2,5})/g);
+        const ports: string[] = [];
+        for (const match of portMatches) {
+          ports.push(match[1]);
+        }
+        
+        let description = `Go main package (${packageName})`;
+        if (handlers.length > 0) {
+          description += ` with HTTP handlers: ${handlers.join(", ")}`;
+        }
+        if (ports.length > 0) {
+          description += ` on port${ports.length > 1 ? "s" : ""} :${ports.join(", :")}`;
+        }
+        
+        entrypoints.push({
+          name: "main.go",
+          path: file.relativePath,
+          type: hasMain ? "server" : "library",
+          description,
+        });
+      } else {
+        const structMatches = content.matchAll(/type\s+(\w+)\s+struct/g);
+        const structs: string[] = [];
+        for (const match of structMatches) {
+          structs.push(match[1]);
+        }
+        
+        const methodMatches = content.matchAll(/func\s*\(?\s*\*?\s*(\w+)\s*\)?\s*(\w+)\s*\(/g);
+        const methods: string[] = [];
+        for (const match of methodMatches) {
+          methods.push(match[2]);
+        }
+        
+        if (structs.length > 0 || methods.length > 0) {
+          let description = "Go module";
+          if (structs.length > 0) {
+            description += ` with structs: ${structs.slice(0, 3).join(", ")}`;
+          }
+          if (methods.length > 0) {
+            description += `, methods: ${methods.slice(0, 3).join(", ")}`;
+          }
+          
+          entrypoints.push({
+            name: fileName,
+            path: file.relativePath,
+            type: "library",
+            description,
+          });
+        }
+      }
+    } catch {}
+  }
+  
+  const goModPath = path.join(rootDir, "go.mod");
+  try {
+    const goMod = readFile(goModPath);
+    const moduleMatch = goMod.match(/module\s+(\S+)/);
+    if (moduleMatch) {
+      entrypoints.push({
+        name: "go.mod",
+        path: "go.mod",
+        type: "config",
+        description: `Go module: ${moduleMatch[1]}`,
+      });
+    }
+  } catch {}
+  
+  return entrypoints;
+}
+
+function discoverRustEntrypoints(rustFiles: FileInfo[], rootDir: string): Entrypoint[] {
+  const entrypoints: Entrypoint[] = [];
+  
+  for (const file of rustFiles) {
+    try {
+      const content = readFile(path.join(rootDir, file.relativePath));
+      const fileName = file.name;
+      
+      if (fileName === "main.rs") {
+        const hasMain = content.match(/fn\s+main\s*\(\s*\)/);
+        
+        const structMatches = content.matchAll(/struct\s+(\w+)/g);
+        const structs: string[] = [];
+        for (const match of structMatches) {
+          structs.push(match[1]);
+        }
+        
+        const implMatches = content.matchAll(/impl\s+(?:\w+\s+for\s+)?(\w+)/g);
+        const implementations: string[] = [];
+        for (const match of implMatches) {
+          implementations.push(match[1]);
+        }
+        
+        let description = "Rust main";
+        if (structs.length > 0) {
+          description += ` with structs: ${structs.slice(0, 3).join(", ")}`;
+        }
+        if (implementations.length > 0) {
+          description += `, implementations: ${implementations.slice(0, 3).join(", ")}`;
+        }
+        
+        entrypoints.push({
+          name: "main.rs",
+          path: file.relativePath,
+          type: hasMain ? "cli" : "library",
+          description,
+        });
+      } else if (fileName === "lib.rs") {
+        const pubFnMatches = content.matchAll(/pub\s+fn\s+(\w+)/g);
+        const publicFns: string[] = [];
+        for (const match of pubFnMatches) {
+          publicFns.push(match[1]);
+        }
+        
+        let description = "Rust library";
+        if (publicFns.length > 0) {
+          description += ` with public functions: ${publicFns.slice(0, 3).join(", ")}`;
+        }
+        
+        entrypoints.push({
+          name: "lib.rs",
+          path: file.relativePath,
+          type: "library",
+          description,
+        });
+      }
+    } catch {}
+  }
+  
+  const cargoPath = path.join(rootDir, "Cargo.toml");
+  try {
+    const cargoContent = readFile(cargoPath);
+    const nameMatch = cargoContent.match(/name\s*=\s*"([^"]+)"/);
+    const versionMatch = cargoContent.match(/version\s*=\s*"([^"]+)"/);
+    
+    let description = "Rust project";
+    if (nameMatch) {
+      description += `: ${nameMatch[1]}`;
+    }
+    if (versionMatch) {
+      description += ` v${versionMatch[1]}`;
+    }
+    
+    const binMatch = cargoContent.match(/\[\[bin\]\]/);
+    if (binMatch) {
+      description += " (has binaries)";
+    }
+    
+    entrypoints.push({
+      name: "Cargo.toml",
+      path: "Cargo.toml",
+      type: "config",
+      description,
+    });
+  } catch {}
+  
+  return entrypoints;
+}
+
+function discoverPHPEntrypoints(phpFiles: FileInfo[], rootDir: string): Entrypoint[] {
+  const entrypoints: Entrypoint[] = [];
+  
+  const hasIndexPhp = phpFiles.some(f => f.name === "index.php");
+  const hasPublicIndex = phpFiles.some(f => f.relativePath.includes("public/index.php"));
+  
+  if (hasIndexPhp) {
+    const indexFile = phpFiles.find(f => f.name === "index.php")!;
+    try {
+      const content = readFile(path.join(rootDir, indexFile.relativePath));
+      
+      const classMatches = content.matchAll(/class\s+(\w+)/g);
+      const classes: string[] = [];
+      for (const match of classMatches) {
+        classes.push(match[1]);
+      }
+      
+      const routes: string[] = [];
+      
+      // Match $router->get('/path') or $app->post('/path') patterns
+      const httpMethodMatches = content.matchAll(/->\s*(?:get|post|put|delete|patch)\s*\(\s*["']([^"']+)["']/g);
+      for (const match of httpMethodMatches) {
+        routes.push(match[1]);
+      }
+      
+      // Match $router->add('METHOD', '/path') patterns (second argument is the path)
+      const addMethodMatches = content.matchAll(/->\s*add\s*\(\s*["'][^"']+["']\s*,\s*["']([^"']+)["']/g);
+      for (const match of addMethodMatches) {
+        routes.push(match[1]);
+      }
+      
+      let description = "PHP entry point";
+      if (classes.length > 0) {
+        description += ` with classes: ${classes.slice(0, 3).join(", ")}`;
+      }
+      if (routes.length > 0) {
+        description += `, routes: ${routes.slice(0, 3).join(", ")}`;
+      }
+      
+      entrypoints.push({
+        name: "index.php",
+        path: indexFile.relativePath,
+        type: hasPublicIndex ? "server" : "api",
+        description,
+      });
+    } catch {}
+  }
+  
+  const composerPath = path.join(rootDir, "composer.json");
+  try {
+    const composer = readJsonFile(composerPath) as { name?: string; description?: string; require?: Record<string, string> };
+    
+    let description = "PHP project";
+    if (composer.name) {
+      description += `: ${composer.name}`;
+    }
+    if (composer.description) {
+      description += ` - ${composer.description}`;
+    }
+    
+    const hasLaravel = composer.require && (composer.require["laravel/framework"] || composer.require["illuminate/support"]);
+    const hasSymfony = composer.require && (composer.require["symfony/framework-bundle"] || composer.require["symfony/symfony"]);
+    
+    if (hasLaravel) {
+      description += " (Laravel)";
+    } else if (hasSymfony) {
+      description += " (Symfony)";
+    }
+    
+    entrypoints.push({
+      name: "composer.json",
+      path: "composer.json",
+      type: "config",
+      description,
+    });
+  } catch {}
+  
+  return entrypoints;
+}
+
 export function generateEntrypointsFile(entrypoints: Entrypoint[]): string {
   const grouped = new Map<string, Entrypoint[]>();
   for (const ep of entrypoints) {

package/src/analyzers/symbols.ts

@@ -533,8 +533,24 @@ function parseSwift(file: FileInfo, content: string, lines: string[], symbols: S
  * Parse Apex (Salesforce) files
  */
 function parseApex(file: FileInfo, content: string, lines: string[], symbols: Symbol[]): void {
+  // Track annotations across lines
+  let pendingAnnotations: string[] = [];
+
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i].trim();
+
+    // Skip empty lines
+    if (!line) {
+      continue;
+    }
+
+    // Collect annotations (@AuraEnabled, @IsTest, etc.) - handles both single-line and multi-line
+    // Match patterns like @AuraEnabled, @AuraEnabled(cacheable=true), @IsTest
+    const annotationMatch = line.match(/^@(\w+)(?:\s*\([^)]*\))?\s*$/);
+    if (annotationMatch) {
+      pendingAnnotations.push(annotationMatch[1]);
+      continue;
+    }
     
     // Classes: public with sharing class ClassName, public class ClassName, etc.
     const classMatch = line.match(/^(?:\s*(?:public|private|global)(?:\s+(?:with|without|inherited)\s+sharing)?\s+)?class\s+(\w+)/);
@@ -547,6 +563,8 @@ function parseApex(file: FileInfo, content: string, lines: string[], symbols: Sy
         line: i + 1,
         export: true,
       });
+      pendingAnnotations = [];
+      continue;
     }
 
     // Interfaces
@@ -560,11 +578,16 @@ function parseApex(file: FileInfo, content: string, lines: string[], symbols: Sy
         line: i + 1,
         export: true,
       });
+      pendingAnnotations = [];
+      continue;
     }
 
     // Methods: public static ReturnType methodName(
     // Also handles @AuraEnabled public static ReturnType methodName(
-    const methodMatch = line.match(/^(?:@\w+\s+)?(?:public|private|protected|global)\s+(?:static\s+)?(?:\w+)\s+(\w+)\s*\(/);
+    // Also handles @AuraEnabled(cacheable=true) on separate line
+    // Handles generic return types like List<Account>, Map<String, Object>
+    // Also handles webservice methods
+    const methodMatch = line.match(/^(?:@\w+(?:\s*\([^)]*\))?\s+)?(?:public|private|protected|global|webservice)\s+(?:static\s+)?(?:[\w<>,\s]+?)\s+(\w+)\s*\(/);
     if (methodMatch && !["if", "for", "while", "switch"].includes(methodMatch[1])) {
       symbols.push({
         id: generateSymbolId(file.relativePath, methodMatch[1]),
@@ -572,8 +595,28 @@ function parseApex(file: FileInfo, content: string, lines: string[], symbols: Sy
         type: "function",
         file: file.relativePath,
         line: i + 1,
-        export: line.includes("public") || line.includes("global"),
+        export: line.includes("public") || line.includes("global") || line.includes("webservice"),
       });
+      pendingAnnotations = [];
+      continue;
+    }
+
+    // Alternative: Method with annotations on previous lines
+    // Check if we have pending annotations and current line looks like a method
+    if (pendingAnnotations.length > 0) {
+      const methodWithAnnotationMatch = line.match(/^(?:public|private|protected|global|webservice)\s+(?:static\s+)?(?:[\w<>,\s]+?)\s+(\w+)\s*\(/);
+      if (methodWithAnnotationMatch && !["if", "for", "while", "switch"].includes(methodWithAnnotationMatch[1])) {
+        symbols.push({
+          id: generateSymbolId(file.relativePath, methodWithAnnotationMatch[1]),
+          name: methodWithAnnotationMatch[1],
+          type: "function",
+          file: file.relativePath,
+          line: i + 1,
+          export: line.includes("public") || line.includes("global") || line.includes("webservice"),
+        });
+        pendingAnnotations = [];
+        continue;
+      }
     }
 
     // Triggers: trigger TriggerName on ObjectName
@@ -587,6 +630,13 @@ function parseApex(file: FileInfo, content: string, lines: string[], symbols: Sy
         line: i + 1,
         export: true,
       });
+      pendingAnnotations = [];
+      continue;
+    }
+    
+    // Reset pending annotations if we encounter non-annotation, non-method line
+    if (!line.startsWith("@")) {
+      pendingAnnotations = [];
     }
   }
 }

package/src/analyzers/techStack.ts

@@ -134,6 +134,18 @@ function detectFrameworks(files: FileInfo[], fileNames: Set<string>, rootDir: st
         frameworks.push(...names);
       }
     }
+    
+    // Check for @nestjs/* packages (NestJS framework)
+    const hasNestJs = Object.keys(deps).some(dep => dep.startsWith("@nestjs/"));
+    if (hasNestJs && !frameworks.includes("NestJS")) {
+      frameworks.push("NestJS");
+    }
+    
+    // Check for Spring Boot in dependencies
+    const hasSpringBoot = Object.keys(deps).some(dep => dep.startsWith("@spring.io/") || dep.includes("spring-boot"));
+    if (hasSpringBoot && !frameworks.includes("Spring Boot")) {
+      frameworks.push("Spring Boot");
+    }
   } catch {}
   
   const frameworkIndicators: Record<string, string> = {
@@ -165,6 +177,38 @@ function detectFrameworks(files: FileInfo[], fileNames: Set<string>, rootDir: st
     }
   }
   
+  // Detect Spring Boot from pom.xml
+  try {
+    const pomPath = path.join(rootDir, "pom.xml");
+    if (fs.existsSync(pomPath)) {
+      const pomContent = readFile(pomPath);
+      if (pomContent.includes("spring-boot") && !frameworks.includes("Spring Boot")) {
+        frameworks.push("Spring Boot");
+      }
+      if (pomContent.includes("spring-boot-starter-parent") && !frameworks.includes("Spring Boot")) {
+        frameworks.push("Spring Boot");
+      }
+    }
+  } catch {}
+  
+  // Detect Spring Boot from build.gradle
+  try {
+    const gradlePath = path.join(rootDir, "build.gradle");
+    const gradleKtsPath = path.join(rootDir, "build.gradle.kts");
+    let gradleContent = "";
+    if (fs.existsSync(gradlePath)) {
+      gradleContent = readFile(gradlePath);
+    } else if (fs.existsSync(gradleKtsPath)) {
+      gradleContent = readFile(gradleKtsPath);
+    }
+    if (gradleContent.includes("spring-boot") && !frameworks.includes("Spring Boot")) {
+      frameworks.push("Spring Boot");
+    }
+    if (gradleContent.includes("org.springframework.boot") && !frameworks.includes("Spring Boot")) {
+      frameworks.push("Spring Boot");
+    }
+  } catch {}
+  
   // Detect SwiftUI from Swift files
   const swiftFiles = files.filter(f => f.extension === "swift");
   for (const swiftFile of swiftFiles) {

package/src/utils/fileUtils.ts

@@ -22,6 +22,11 @@ export const DEFAULT_EXCLUDE_PATTERNS = [
   "target",
   ".cache",
   ".DS_Store",
+  "test-projects",
+  ".ai-dev",
+  ".ai-dev-out",
+  "ai-context",
+  ".ai-first-ignore",
 ];
 
 /**