ai-first-cli 1.3.5 → 1.3.8

package/src/analyzers/architecture.ts

@@ -27,7 +27,7 @@ export function analyzeArchitecture(
   const extensions = Array.from(groupByExtension(files).keys());
   
   // Detect patterns based on directory structure
-  const patterns = detectPatterns(directories, extensions);
+  const patterns = detectPatterns(directories, extensions, files);
   
   // Identify layers
   const layers = detectLayers(directories);
@@ -49,7 +49,7 @@ export function analyzeArchitecture(
 /**
  * Detect architecture patterns from directory structure
  */
-function detectPatterns(directories: string[], extensions: string[]): string[] {
+function detectPatterns(directories: string[], extensions: string[], files: FileInfo[]): string[] {
   const patterns: string[] = [];
   const dirs = directories.filter(d => d && d !== "root");
   
@@ -86,9 +86,38 @@ function detectPatterns(directories: string[], extensions: string[]): string[] {
     patterns.push("Monorepo");
   }
   
-  // Microservices
-  if (dirs.some(d => d.includes("services") || d.includes("api")) && dirs.length > 3) {
+  // Microservices - check for multiple service subdirectories
+  const serviceSubdirs = new Set<string>();
+  const apiSubdirs = new Set<string>();
+  const versionPattern = /^v?\d+$/i;
+  
+  for (const file of files) {
+    const parts = file.relativePath.split("/");
+    // Check for services/*/ pattern (must be an actual subdirectory, not a file)
+    const servicesIndex = parts.indexOf("services");
+    if (servicesIndex >= 0 && servicesIndex < parts.length - 2) {
+      // parts.length - 2 ensures there's at least one directory after 'services' before the file
+      const subdir = parts[servicesIndex + 1];
+      if (!versionPattern.test(subdir)) {
+        serviceSubdirs.add(subdir);
+      }
+    }
+    // Check for api/*/ pattern at root level (must be an actual subdirectory)
+    if (parts[0] === "api" && parts.length > 2) {
+      // parts.length > 2 ensures there's at least one directory after 'api' before the file
+      const subdir = parts[1];
+      if (!versionPattern.test(subdir)) {
+        apiSubdirs.add(subdir);
+      }
+    }
+  }
+  
+  if (serviceSubdirs.size >= 2 || apiSubdirs.size >= 2) {
     patterns.push("Microservices");
+  } else if (dirs.some(d => d === "services" || d === "api") ||
+             files.some(f => f.relativePath.includes("/services/") || f.relativePath.includes("/api/")) ||
+             serviceSubdirs.size === 1 || apiSubdirs.size === 1) {
+    patterns.push("API Server");
   }
   
   // Serverless / Functions
@@ -217,8 +246,48 @@ function inferModuleResponsibility(dir: string, extensions: string[]): string {
   if (name.includes("auth") || name.includes("security") || name.includes("login")) {
     return "Authentication and authorization";
   }
-  
-  return `Contains ${extensions.length} files`;
+
+  // Infer from file types
+  const uniqueExts = [...new Set(extensions)];
+  if (uniqueExts.includes("ts") || uniqueExts.includes("tsx") || uniqueExts.includes("js") || uniqueExts.includes("jsx")) {
+    if (uniqueExts.includes("css") || uniqueExts.includes("scss") || uniqueExts.includes("less")) {
+      return "Frontend components and styling";
+    }
+    return "JavaScript/TypeScript implementation";
+  }
+  if (uniqueExts.includes("py")) {
+    return "Python implementation";
+  }
+  if (uniqueExts.includes("java")) {
+    return "Java implementation";
+  }
+  if (uniqueExts.includes("go")) {
+    return "Go implementation";
+  }
+  if (uniqueExts.includes("rs")) {
+    return "Rust implementation";
+  }
+  if (uniqueExts.includes("php")) {
+    return "PHP implementation";
+  }
+  if (uniqueExts.includes("rb")) {
+    return "Ruby implementation";
+  }
+  if (uniqueExts.includes("swift")) {
+    return "Swift implementation";
+  }
+  if (uniqueExts.includes("kt")) {
+    return "Kotlin implementation";
+  }
+  if (uniqueExts.includes("cls") || uniqueExts.includes("trigger")) {
+    return "Apex/Salesforce implementation";
+  }
+
+  // Fallback based on file count
+  if (extensions.length === 1) {
+    return "Single file module";
+  }
+  return `Module with ${extensions.length} source files`;
 }
 
 /**

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,84 @@ 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 Python frameworks from requirements.txt, Pipfile, pyproject.toml
+  try {
+    const pythonFrameworkMap: Record<string, string[]> = {
+      "django": ["Django"],
+      "flask": ["Flask"],
+      "fastapi": ["FastAPI"],
+      "tornado": ["Tornado"],
+      "pyramid": ["Pyramid"],
+      "bottle": ["Bottle"],
+      "cherrypy": ["CherryPy"],
+    };
+    
+    // Check requirements.txt
+    const reqPath = path.join(rootDir, "requirements.txt");
+    if (fs.existsSync(reqPath)) {
+      const reqContent = readFile(reqPath);
+      for (const [dep, names] of Object.entries(pythonFrameworkMap)) {
+        if (reqContent.toLowerCase().includes(dep.toLowerCase()) && !frameworks.some(f => names.includes(f))) {
+          frameworks.push(...names);
+        }
+      }
+    }
+    
+    // Check Pipfile
+    const pipfilePath = path.join(rootDir, "Pipfile");
+    if (fs.existsSync(pipfilePath)) {
+      const pipfileContent = readFile(pipfilePath);
+      for (const [dep, names] of Object.entries(pythonFrameworkMap)) {
+        if (pipfileContent.toLowerCase().includes(dep.toLowerCase()) && !frameworks.some(f => names.includes(f))) {
+          frameworks.push(...names);
+        }
+      }
+    }
+    
+    // Check pyproject.toml
+    const pyprojectPath = path.join(rootDir, "pyproject.toml");
+    if (fs.existsSync(pyprojectPath)) {
+      const pyprojectContent = readFile(pyprojectPath);
+      for (const [dep, names] of Object.entries(pythonFrameworkMap)) {
+        if (pyprojectContent.toLowerCase().includes(dep.toLowerCase()) && !frameworks.some(f => names.includes(f))) {
+          frameworks.push(...names);
+        }
+      }
+    }
+  } catch {}
+   
   // Detect SwiftUI from Swift files
   const swiftFiles = files.filter(f => f.extension === "swift");
   for (const swiftFile of swiftFiles) {