ai-first-cli 1.3.1 → 1.3.6

package/src/analyzers/entrypoints.ts

@@ -79,6 +79,50 @@ export function discoverEntrypoints(files: FileInfo[], rootDir: string): Entrypo
     } catch {}
   }
   
+  const sfdxFiles = files.filter(f => f.name === "sfdx-project.json");
+  if (sfdxFiles.length > 0) {
+    try {
+      const salesforceEntrypoints = discoverSalesforceEntrypoints(files, rootDir);
+      entrypoints.push(...salesforceEntrypoints);
+    } catch {}
+  }
+  
+  // Detect iOS/SwiftUI entrypoints from Swift files
+  const swiftFiles = files.filter(f => f.extension === "swift");
+  if (swiftFiles.length > 0) {
+    try {
+      const swiftEntrypoints = discoverSwiftUIEntrypoints(swiftFiles, rootDir);
+      entrypoints.push(...swiftEntrypoints);
+    } 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;
 }
 
@@ -151,6 +195,104 @@ function parseAndroidManifest(content: string, manifestPath: string): Entrypoint
   return entrypoints;
 }
 
+function discoverSalesforceEntrypoints(files: FileInfo[], rootDir: string): Entrypoint[] {
+  const entrypoints: Entrypoint[] = [];
+  
+  const apexFiles = files.filter(f => f.extension === "cls" || f.extension === "trigger");
+  
+  for (const apexFile of apexFiles) {
+    try {
+      const content = readFile(path.join(rootDir, apexFile.relativePath));
+      
+      if (apexFile.extension === "trigger") {
+        const triggerMatch = content.match(/^trigger\s+(\w+)\s+on\s+(\w+)/i);
+        if (triggerMatch) {
+          entrypoints.push({
+            name: triggerMatch[1],
+            path: apexFile.relativePath,
+            type: "api",
+            description: `Trigger on ${triggerMatch[2]} SObject`,
+          });
+        }
+      } else {
+        const classMatch = content.match(/^(?:\s*(?:public|private|global)(?:\s+(?:with|without|inherited)\s+sharing)?\s+)?class\s+(\w+)/i);
+        if (classMatch) {
+          const className = classMatch[1];
+          const methods = extractApexMethods(content);
+          
+          const auraEnabled = methods.filter(m => m.includes("@AuraEnabled"));
+          const restResource = methods.some(m => m.includes("@RestResource"));
+          const webservice = methods.some(m => m.includes("@webservice"));
+          
+          let description = "Apex Class";
+          if (restResource) description += " (REST Resource)";
+          else if (auraEnabled.length > 0) description += ` (${auraEnabled.length} @AuraEnabled methods)`;
+          else if (webservice) description += " (WebService)";
+          
+          entrypoints.push({
+            name: className,
+            path: apexFile.relativePath,
+            type: "api",
+            description,
+          });
+        }
+      }
+    } catch {}
+  }
+  
+  return entrypoints;
+}
+
+function extractApexMethods(content: string): string[] {
+  const methods: string[] = [];
+  const methodRegex = /@(?:AuraEnabled|RestResource|webservice|InvocableMethod)\s*(?:public|private|protected|global)?\s*(?:static)?\s*\w+\s+(\w+)\s*\(/g;
+  let match;
+  while ((match = methodRegex.exec(content)) !== null) {
+    methods.push(match[0]);
+  }
+  return methods;
+}
+
+function discoverSwiftUIEntrypoints(swiftFiles: FileInfo[], rootDir: string): Entrypoint[] {
+  const entrypoints: Entrypoint[] = [];
+  
+  for (const swiftFile of swiftFiles) {
+    try {
+      const content = readFile(path.join(rootDir, swiftFile.relativePath));
+      
+      if (!content.includes("import SwiftUI")) {
+        continue;
+      }
+      
+      const structRegex = /struct\s+(\w+)\s*:\s*View/g;
+      let match;
+      while ((match = structRegex.exec(content)) !== null) {
+        const viewName = match[1];
+        const isContentView = viewName === "ContentView";
+        
+        entrypoints.push({
+          name: viewName,
+          path: swiftFile.relativePath,
+          type: "client",
+          description: isContentView ? "Main SwiftUI View" : `SwiftUI View: ${viewName}`,
+        });
+      }
+      
+      const appRegex = /@main\s*\n\s*struct\s+(\w+)/g;
+      while ((match = appRegex.exec(content)) !== null) {
+        entrypoints.push({
+          name: match[1],
+          path: swiftFile.relativePath,
+          type: "client",
+          description: `SwiftUI App Entry Point: ${match[1]}`,
+        });
+      }
+    } catch {}
+  }
+  
+  return entrypoints;
+}
+
 function getScriptType(name: string): Entrypoint["type"] | null {
   const l = name.toLowerCase();
   if (l.includes("start") || l.includes("dev") || l.includes("serve")) return "server";
@@ -161,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

@@ -89,6 +89,8 @@ function parseFileForSymbols(file: FileInfo): Symbol[] {
       parsePHP(file, content, lines, symbols);
     } else if (file.extension === "rb") {
       parseRuby(file, content, lines, symbols);
+    } else if (file.extension === "swift") {
+      parseSwift(file, content, lines, symbols);
     }
   } catch {}
 
@@ -453,15 +455,105 @@ function parseRuby(file: FileInfo, content: string, lines: string[], symbols: Sy
   }
 }
 
+/**
+ * Parse Swift files
+ */
+function parseSwift(file: FileInfo, content: string, lines: string[], symbols: Symbol[]): void {
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    
+    // Classes/Structs: struct ViewName, class ClassName
+    const structMatch = line.match(/^(?:struct|class)\s+(\w+)/);
+    if (structMatch) {
+      symbols.push({
+        id: generateSymbolId(file.relativePath, structMatch[1]),
+        name: structMatch[1],
+        type: "class",
+        file: file.relativePath,
+        line: i + 1,
+        export: line.startsWith("struct") || line.startsWith("class"),
+      });
+    }
+    
+    // Functions: func functionName
+    const funcMatch = line.match(/^func\s+(\w+)/);
+    if (funcMatch) {
+      symbols.push({
+        id: generateSymbolId(file.relativePath, funcMatch[1]),
+        name: funcMatch[1],
+        type: "function",
+        file: file.relativePath,
+        line: i + 1,
+        export: true,
+      });
+    }
+    
+    // Enums: enum EnumName
+    const enumMatch = line.match(/^enum\s+(\w+)/);
+    if (enumMatch) {
+      symbols.push({
+        id: generateSymbolId(file.relativePath, enumMatch[1]),
+        name: enumMatch[1],
+        type: "enum",
+        file: file.relativePath,
+        line: i + 1,
+        export: true,
+      });
+    }
+    
+    // Protocols: protocol ProtocolName
+    const protocolMatch = line.match(/^protocol\s+(\w+)/);
+    if (protocolMatch) {
+      symbols.push({
+        id: generateSymbolId(file.relativePath, protocolMatch[1]),
+        name: protocolMatch[1],
+        type: "interface",
+        file: file.relativePath,
+        line: i + 1,
+        export: true,
+      });
+    }
+    
+    // Constants: let CONST_NAME or var CONST_NAME
+    const constMatch = line.match(/^(?:let|var)\s+([A-Z][A-Z0-9_]*)/);
+    if (constMatch) {
+      symbols.push({
+        id: generateSymbolId(file.relativePath, constMatch[1]),
+        name: constMatch[1],
+        type: "const",
+        file: file.relativePath,
+        line: i + 1,
+        export: true,
+      });
+    }
+  }
+}
+
 /**
  * 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(/^(?:public\s+(?:with\s+sharing|without\s+sharing|inherited\s+sharing)\s+)?class\s+(\w+)/);
+    const classMatch = line.match(/^(?:\s*(?:public|private|global)(?:\s+(?:with|without|inherited)\s+sharing)?\s+)?class\s+(\w+)/);
     if (classMatch) {
       symbols.push({
         id: generateSymbolId(file.relativePath, classMatch[1]),
@@ -471,6 +563,8 @@ function parseApex(file: FileInfo, content: string, lines: string[], symbols: Sy
         line: i + 1,
         export: true,
       });
+      pendingAnnotations = [];
+      continue;
     }
 
     // Interfaces
@@ -484,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]),
@@ -496,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
@@ -511,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 = [];
     }
   }
 }