ai-first-cli 1.3.1 → 1.3.6

package/src/analyzers/techStack.ts

@@ -20,6 +20,14 @@ export interface TechStack {
     gradleVersion?: string;
     kotlinVersion?: string;
   };
+  salesforce?: {
+    apiVersion?: string;
+    packageDirectories?: string[];
+    namespace?: string;
+    sObjects?: string[];
+    apexClasses?: number;
+    triggers?: number;
+  };
 }
 
 /**
@@ -43,6 +51,7 @@ export function detectTechStack(files: FileInfo[], rootDir: string): TechStack {
   );
   
   const android = detectAndroidSDK(files, rootDir);
+  const salesforce = detectSalesforceInfo(files, rootDir);
   
   return {
     languages,
@@ -55,6 +64,7 @@ export function detectTechStack(files: FileInfo[], rootDir: string): TechStack {
     formatters,
     description,
     android,
+    salesforce,
   };
 }
 
@@ -71,6 +81,7 @@ function detectLanguages(extensions: Set<string>): string[] {
     yaml: "YAML", yml: "YAML", toml: "TOML", xml: "XML", json: "JSON",
     md: "Markdown", tex: "LaTeX", r: "R", lua: "Lua", pl: "Perl",
     hs: "Haskell", ex: "Elixir", erl: "Erlang", clj: "Clojure", dart: "Dart",
+    cls: "Apex", trigger: "Apex Trigger",
   };
   
   const detected: string[] = [];
@@ -123,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> = {
@@ -142,6 +165,8 @@ function detectFrameworks(files: FileInfo[], fileNames: Set<string>, rootDir: st
     "build.gradle.kts": "Android",
     "settings.gradle": "Android",
     "AndroidManifest.xml": "Android",
+    "sfdx-project.json": "Salesforce DX",
+    "force-app": "Salesforce",
   };
   
   for (const [indicator, framework] of Object.entries(frameworkIndicators)) {
@@ -152,6 +177,55 @@ 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) {
+    try {
+      const content = readFile(path.join(rootDir, swiftFile.relativePath));
+      if (content.includes("import SwiftUI")) {
+        if (!frameworks.includes("SwiftUI")) {
+          frameworks.push("SwiftUI");
+        }
+        if (!frameworks.includes("iOS")) {
+          frameworks.push("iOS");
+        }
+        break;
+      }
+    } catch {}
+  }
+  
   return [...new Set(frameworks)];
 }
 
@@ -586,6 +660,55 @@ function detectLibraries(files: FileInfo[], rootDir: string): string[] {
   return [...new Set(libraries)];
 }
 
+/**
+ * Detect Salesforce project information
+ */
+function detectSalesforceInfo(files: FileInfo[], rootDir: string): TechStack["salesforce"] {
+  const sfdxPath = path.join(rootDir, "sfdx-project.json");
+  
+  if (!fs.existsSync(sfdxPath)) {
+    return undefined;
+  }
+  
+  try {
+    const sfdxConfig = readJsonFile(sfdxPath) as {
+      sourceApiVersion?: string;
+      packageDirectories?: Array<{ path: string; default?: boolean }>;
+      namespace?: string;
+    };
+    
+    // Count Apex files
+    const apexFiles = files.filter(f => f.extension === "cls" || f.extension === "trigger");
+    const apexClasses = files.filter(f => f.extension === "cls").length;
+    const triggers = files.filter(f => f.extension === "trigger").length;
+    
+    // Detect SObjects from trigger files
+    const sObjects = new Set<string>();
+    for (const file of files) {
+      if (file.extension === "trigger") {
+        try {
+          const content = readFile(file.path);
+          const match = content.match(/trigger\s+\w+\s+on\s+(\w+)/i);
+          if (match) {
+            sObjects.add(match[1]);
+          }
+        } catch {}
+      }
+    }
+    
+    return {
+      apiVersion: sfdxConfig.sourceApiVersion,
+      packageDirectories: sfdxConfig.packageDirectories?.map(p => p.path),
+      namespace: sfdxConfig.namespace,
+      sObjects: Array.from(sObjects),
+      apexClasses,
+      triggers,
+    };
+  } catch {
+    return undefined;
+  }
+}
+
 /**
  * Generate tech_stack.md content
  */
@@ -601,6 +724,20 @@ export function generateTechStackFile(stack: TechStack): string {
   content += "## Testing\n" + (stack.testing.map(t => `- ${t}`).join("\n") || "- None detected") + "\n\n";
   content += "## Linters\n" + (stack.linters.map(l => `- ${l}`).join("\n") || "- None detected") + "\n\n";
   content += "## Formatters\n" + (stack.formatters.map(f => `- ${f}`).join("\n") || "- None detected") + "\n\n";
+  
+  // Add Salesforce section if applicable
+  if (stack.salesforce) {
+    content += "## Salesforce\n";
+    content += `- **API Version**: ${stack.salesforce.apiVersion || "N/A"}\n`;
+    content += `- **Apex Classes**: ${stack.salesforce.apexClasses}\n`;
+    content += `- **Triggers**: ${stack.salesforce.triggers}\n`;
+    content += `- **SObjects**: ${stack.salesforce.sObjects?.join(", ") || "N/A"}\n`;
+    if (stack.salesforce.namespace) {
+      content += `- **Namespace**: ${stack.salesforce.namespace}\n`;
+    }
+    content += "\n";
+  }
+  
   content += "---\n*Generated by ai-first*\n";
   
   return content;

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",
 ];
 
 /**

package/tests/apex-parser.test.ts

@@ -0,0 +1,193 @@
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import { extractSymbols } from "../src/analyzers/symbols";
+import { FileInfo } from "../src/core/repoScanner";
+import fs from "fs";
+import path from "path";
+import os from "os";
+
+describe("Apex Parser", () => {
+  let tempDir: string;
+
+  beforeAll(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "apex-test-"));
+  });
+
+  afterAll(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  const createFileInfo = (filePath: string, extension: string, content: string): FileInfo => {
+    const fullPath = path.join(tempDir, filePath);
+    fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+    fs.writeFileSync(fullPath, content);
+    
+    return {
+      path: fullPath,
+      relativePath: filePath,
+      extension,
+      name: filePath.split("/").pop()?.replace(`.${extension}`, "") || "",
+    };
+  };
+
+  describe("Class parsing", () => {
+    it("should parse public class", () => {
+      const content = `public class AccountController {
+  public static List getAccounts() {
+    return [SELECT Id, Name FROM Account];
+  }
+}`;
+      const file = createFileInfo("force-app/main/default/classes/AccountController.cls", "cls", content);
+      const result = extractSymbols([file]);
+      
+      expect(result.symbols.length).toBeGreaterThanOrEqual(1);
+      const classSymbol = result.symbols.find(s => s.type === "class");
+      expect(classSymbol).toBeDefined();
+      expect(classSymbol?.name).toBe("AccountController");
+      expect(classSymbol?.export).toBe(true);
+    });
+
+    it("should parse class with sharing", () => {
+      const content = `public with sharing class ContactService {
+        public static void updateContact(Contact c) {
+          update c;
+        }
+      }`;
+      const file = createFileInfo("ContactService.cls", "cls", content);
+      const result = extractSymbols([file]);
+      
+      expect(result.symbols[0].name).toBe("ContactService");
+      expect(result.symbols[0].type).toBe("class");
+    });
+
+    it("should parse class without sharing", () => {
+      const content = `public without sharing class AdminController {
+        public static void deleteAll() {
+          delete [SELECT Id FROM Account];
+        }
+      }`;
+      const file = createFileInfo("AdminController.cls", "cls", content);
+      const result = extractSymbols([file]);
+      
+      expect(result.symbols[0].name).toBe("AdminController");
+    });
+
+    it("should parse inherited sharing class", () => {
+      const content = `public inherited sharing class BaseService {
+        public virtual void process() {}
+      }`;
+      const file = createFileInfo("BaseService.cls", "cls", content);
+      const result = extractSymbols([file]);
+      
+      expect(result.symbols[0].name).toBe("BaseService");
+    });
+  });
+
+  describe("Interface parsing", () => {
+    it("should parse public interface", () => {
+      const content = `public interface IAccountService {
+        Account getAccountById(Id accountId);
+        void updateAccount(Account acc);
+      }`;
+      const file = createFileInfo("IAccountService.cls", "cls", content);
+      const result = extractSymbols([file]);
+      
+      expect(result.symbols[0].name).toBe("IAccountService");
+      expect(result.symbols[0].type).toBe("interface");
+    });
+  });
+
+  describe("Method parsing", () => {
+    it("should parse public static methods", () => {
+      const content = `public class Utils {
+        public static String formatPhone(String phone) {
+          return phone.replaceAll('[^0-9]', '');
+        }
+      }`;
+      const file = createFileInfo("Utils.cls", "cls", content);
+      const result = extractSymbols([file]);
+      
+      const method = result.symbols.find(s => s.name === "formatPhone");
+      expect(method).toBeDefined();
+      expect(method?.type).toBe("function");
+      expect(method?.export).toBe(true);
+    });
+
+    it("should parse @AuraEnabled methods", () => {
+      const content = `public class AccountController {
+        @AuraEnabled
+        public static List getAccounts() {
+          return [SELECT Id, Name FROM Account];
+        }
+      }`;
+      const file = createFileInfo("AccountController.cls", "cls", content);
+      const result = extractSymbols([file]);
+      
+      const method = result.symbols.find(s => s.name === "getAccounts");
+      expect(method).toBeDefined();
+      expect(method?.export).toBe(true);
+    });
+
+    it("should parse webservice methods", () => {
+      const content = `global class WebServiceAPI {
+        public static String createAccount(String name) {
+          Account acc = new Account(Name = name);
+          insert acc;
+          return acc.Id;
+        }
+      }`;
+      const file = createFileInfo("WebServiceAPI.cls", "cls", content);
+      const result = extractSymbols([file]);
+      
+      const method = result.symbols.find(s => s.name === "createAccount");
+      expect(method).toBeDefined();
+      expect(method?.export).toBe(true);
+    });
+  });
+
+  describe("Trigger parsing", () => {
+    it("should parse trigger", () => {
+      const content = `trigger AccountTrigger on Account (before insert, before update) {
+        for(Account acc : Trigger.new) {
+          acc.Name = acc.Name.toUpperCase();
+        }
+      }`;
+      const file = createFileInfo("AccountTrigger.trigger", "trigger", content);
+      const result = extractSymbols([file]);
+      
+      expect(result.symbols[0].name).toBe("AccountTrigger");
+      expect(result.symbols[0].type).toBe("function");
+      expect(result.symbols[0].export).toBe(true);
+    });
+
+    it("should parse trigger with multiple events", () => {
+      const content = `trigger ContactTrigger on Contact (before insert, before update, after insert, after update, before delete, after delete) {
+        ContactTriggerHandler.handle(Trigger.operationType);
+      }`;
+      const file = createFileInfo("ContactTrigger.trigger", "trigger", content);
+      const result = extractSymbols([file]);
+      
+      expect(result.symbols[0].name).toBe("ContactTrigger");
+    });
+  });
+
+  describe("Salesforce TechStack Detection", () => {
+    it("should detect Apex language", () => {
+      const files: FileInfo[] = [
+        createFileInfo("AccountController.cls", "cls", ""),
+        createFileInfo("ContactService.cls", "cls", ""),
+      ];
+      
+      // This would be tested via detectTechStack, but we verify the extension mapping
+      expect(files[0].extension).toBe("cls");
+      expect(files[1].extension).toBe("cls");
+    });
+
+    it("should detect trigger files", () => {
+      const files: FileInfo[] = [
+        createFileInfo("AccountTrigger.trigger", "trigger", ""),
+      ];
+      
+      expect(files[0].extension).toBe("trigger");
+    });
+  });
+});