ai-first-cli 1.1.3 → 1.2.0

package/src/core/embeddings.ts

@@ -1,6 +1,5 @@
-import fs from "fs";
-import path from "path";
 import crypto from "crypto";
+import { Database } from "sql.js";
 import { Chunk } from "./chunker.js";
 
 export interface Embedding {
@@ -24,6 +23,26 @@ export interface EmbeddingsIndex {
   embeddings: Embedding[];
 }
 
+/**
+ * Create embeddings table in the database
+ */
+export function createEmbeddingsTable(db: Database): void {
+  db.run(`
+    CREATE TABLE IF NOT EXISTS embeddings (
+      id TEXT PRIMARY KEY,
+      vector TEXT NOT NULL,
+      metadata TEXT NOT NULL,
+      chunk_id TEXT,
+      file_path TEXT,
+      start_line INTEGER,
+      end_line INTEGER,
+      type TEXT,
+      language TEXT
+    )
+  `);
+  db.run("CREATE INDEX IF NOT EXISTS idx_embeddings_file_path ON embeddings(file_path)");
+}
+
 /**
  * Generate a simple hash-based embedding (for testing/fallback)
  * This creates a deterministic embedding based on content
@@ -86,40 +105,72 @@ export async function generateEmbeddings(
 }
 
 /**
- * Save embeddings to file
+ * Save embeddings to SQLite database
  */
 export function saveEmbeddings(
+  db: Database,
   embeddings: Embedding[],
-  aiDir: string,
   model: string,
   dimensions: number
 ): void {
-  const index: EmbeddingsIndex = {
-    version: "1.0.0",
-    model,
-    dimensions,
-    generated: new Date().toISOString(),
-    embeddings
-  };
+  db.run("DELETE FROM embeddings");
   
-  const embeddingsPath = path.join(aiDir, "embeddings.json");
-  fs.writeFileSync(embeddingsPath, JSON.stringify(index, null, 2));
-  console.log(`   ✅ Saved ${embeddings.length} embeddings to ${embeddingsPath}`);
+  for (const embedding of embeddings) {
+    const vectorJson = JSON.stringify(embedding.vector);
+    const metadataJson = JSON.stringify(embedding.metadata);
+    
+    db.run(
+      `INSERT INTO embeddings (id, vector, metadata, chunk_id, file_path, start_line, end_line, type, language) 
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      [
+        embedding.id,
+        vectorJson,
+        metadataJson,
+        embedding.metadata.chunkId,
+        embedding.metadata.filePath,
+        embedding.metadata.startLine,
+        embedding.metadata.endLine,
+        embedding.metadata.type,
+        embedding.metadata.language
+      ]
+    );
+  }
+  
+  console.log(`   ✅ Saved ${embeddings.length} embeddings to database`);
 }
 
 /**
- * Load embeddings from file
+ * Load embeddings from SQLite database
  */
-export function loadEmbeddings(aiDir: string): EmbeddingsIndex | null {
-  const embeddingsPath = path.join(aiDir, "embeddings.json");
-  
-  if (!fs.existsSync(embeddingsPath)) {
-    return null;
-  }
-  
+export function loadEmbeddings(db: Database): EmbeddingsIndex | null {
   try {
-    const data = fs.readFileSync(embeddingsPath, "utf-8");
-    return JSON.parse(data);
+    const result = db.exec("SELECT id, vector, metadata FROM embeddings");
+    
+    if (result.length === 0 || result[0].values.length === 0) {
+      return null;
+    }
+    
+    const embeddings: Embedding[] = [];
+    
+    for (const row of result[0].values) {
+      const id = row[0] as string;
+      const vectorJson = row[1] as string;
+      const metadataJson = row[2] as string;
+      
+      embeddings.push({
+        id,
+        vector: JSON.parse(vectorJson),
+        metadata: JSON.parse(metadataJson)
+      });
+    }
+    
+    return {
+      version: "1.0.0",
+      model: "simple-fallback",
+      dimensions: embeddings.length > 0 ? embeddings[0].vector.length : 384,
+      generated: new Date().toISOString(),
+      embeddings
+    };
   } catch {
     return null;
   }
@@ -143,30 +194,45 @@ function cosineSimilarity(a: number[], b: number[]): number {
 }
 
 /**
- * Search embeddings for similar chunks
+ * Search embeddings for similar chunks using SQLite database
  */
 export function searchEmbeddings(
+  db: Database,
   query: string,
-  embeddingsIndex: EmbeddingsIndex,
+  dimensions: number = 384,
   topK: number = 5
 ): { chunkId: string; filePath: string; score: number; content: string }[] {
-  // Generate embedding for query
-  const queryEmbedding = generateSimpleEmbedding(query, embeddingsIndex.dimensions);
+  const queryEmbedding = generateSimpleEmbedding(query, dimensions);
   
-  // Calculate similarities
-  const results = embeddingsIndex.embeddings.map(embedding => ({
-    chunkId: embedding.id,
-    filePath: embedding.metadata.filePath,
-    score: cosineSimilarity(queryEmbedding, embedding.vector),
-    startLine: embedding.metadata.startLine,
-    endLine: embedding.metadata.endLine,
-    type: embedding.metadata.type
-  }));
+  const result = db.exec("SELECT id, vector, metadata FROM embeddings");
+  
+  if (result.length === 0 || result[0].values.length === 0) {
+    return [];
+  }
+  
+  const searchResults: { chunkId: string; filePath: string; score: number; startLine: number; endLine: number; type: string }[] = [];
+  
+  for (const row of result[0].values) {
+    const id = row[0] as string;
+    const vectorJson = row[1] as string;
+    const metadataJson = row[2] as string;
+    
+    const vector = JSON.parse(vectorJson);
+    const metadata = JSON.parse(metadataJson);
+    
+    searchResults.push({
+      chunkId: id,
+      filePath: metadata.filePath,
+      score: cosineSimilarity(queryEmbedding, vector),
+      startLine: metadata.startLine,
+      endLine: metadata.endLine,
+      type: metadata.type
+    });
+  }
   
-  // Sort by score and return top K
-  results.sort((a, b) => b.score - a.score);
+  searchResults.sort((a, b) => b.score - a.score);
   
-  return results.slice(0, topK).map(r => ({
+  return searchResults.slice(0, topK).map(r => ({
     chunkId: r.chunkId,
     filePath: r.filePath,
     score: r.score,

package/src/core/gitAnalyzer.ts

@@ -240,7 +240,7 @@ function loadFlows(aiDir: string): Map<string, string[]> {
  * Map changed files to features
  */
 export function mapFilesToFeatures(rootDir: string, files: string[]): string[] {
-  const aiDir = path.join(rootDir, "ai");
+  const aiDir = path.join(rootDir, "ai-context");
   const featuresMap = loadFeatures(aiDir);
   
   const featureSet = new Set<string>();
@@ -267,7 +267,7 @@ export function mapFilesToFeatures(rootDir: string, files: string[]): string[] {
  * Map changed files to flows
  */
 export function mapFilesToFlows(rootDir: string, files: string[]): string[] {
-  const aiDir = path.join(rootDir, "ai");
+  const aiDir = path.join(rootDir, "ai-context");
   const flowsMap = loadFlows(aiDir);
   
   const flowSet = new Set<string>();
@@ -354,7 +354,7 @@ export function generateGitContext(rootDir: string, aiDir?: string): {
   recentFlows: string[];
   activity: GitActivity | null;
 } {
-  const targetAiDir = aiDir || path.join(rootDir, "ai");
+  const targetAiDir = aiDir || path.join(rootDir, "ai-context");
   const gitDir = path.join(targetAiDir, "git");
   
   ensureDir(gitDir);

package/src/core/incrementalAnalyzer.ts

@@ -86,7 +86,7 @@ function detectChangesWithGit(rootDir: string): ChangedFile[] {
 
 function detectChangesWithTimestamps(rootDir: string): ChangedFile[] {
   const changes: ChangedFile[] = [];
-  const aiDir = path.join(rootDir, "ai");
+  const aiDir = path.join(rootDir, "ai-context");
   const state = loadIndexState(aiDir);
   
   if (!state) return [];
@@ -114,18 +114,56 @@ function detectChangesWithTimestamps(rootDir: string): ChangedFile[] {
 
 export function updateSymbols(rootDir: string, changedFiles: ChangedFile[], aiDir: string): number {
   const symbolsPath = path.join(aiDir, "symbols.json");
-  let existingSymbols: Array<{name: string; file: string; type?: string}> = [];
+  
+  // Read existing symbols.json structure
+  interface SymbolsIndex {
+    [id: string]: { name: string; type: string; file: string; line?: number; module?: string; export?: boolean };
+  }
+  interface SymbolsData {
+    symbols: SymbolsIndex;
+    total: number;
+    byType: { [type: string]: Array<{ id: string; name: string; type: string; file: string; line?: number; export?: boolean }> };
+    byFile: { [file: string]: Array<{ id: string; name: string; type: string; file: string; line?: number; export?: boolean }> };
+    exported: Array<{ id: string; name: string; type: string; file: string; line?: number; export?: boolean }>;
+  }
+  
+  let symbolsData: SymbolsData | null = null;
   
   if (fs.existsSync(symbolsPath)) {
     try {
       const raw = readJsonFile(symbolsPath);
-      if (Array.isArray(raw)) existingSymbols = raw as typeof existingSymbols;
-    } catch { existingSymbols = []; }
+      if (!Array.isArray(raw) && raw && typeof raw === 'object') {
+        symbolsData = raw as unknown as SymbolsData;
+      }
+    } catch { }
+  }
+  
+  // If no valid symbols.json exists, nothing to update
+  if (!symbolsData) {
+    return 0;
   }
   
   const changedPaths = new Set(changedFiles.map(f => f.path));
-  existingSymbols = existingSymbols.filter(s => !changedPaths.has(s.file));
   
+  // Remove symbols from changed files
+  for (const filePath of changedPaths) {
+    delete symbolsData.byFile[filePath];
+    for (const type of Object.keys(symbolsData.byType)) {
+      symbolsData.byType[type] = symbolsData.byType[type].filter(
+        sym => sym.file !== filePath
+      );
+    }
+    symbolsData.exported = symbolsData.exported.filter(sym => sym.file !== filePath);
+    // Remove from symbols index
+    const keysToDelete = Object.keys(symbolsData.symbols).filter(
+      id => id.startsWith(filePath + '#')
+    );
+    for (const key of keysToDelete) {
+      delete symbolsData.symbols[key];
+    }
+  }
+  
+  // Extract and add new symbols from changed files
   for (const changed of changedFiles) {
     if (changed.status === "deleted") continue;
     const fullPath = path.join(rootDir, changed.path);
@@ -133,20 +171,72 @@ export function updateSymbols(rootDir: string, changedFiles: ChangedFile[], aiDi
     
     try {
       const fileInfo: FileInfo = {
-        path: changed.path,
+        path: fullPath,
         relativePath: changed.path,
         extension: path.extname(changed.path),
         name: path.basename(changed.path, path.extname(changed.path))
       };
       const symbols = extractSymbols([fileInfo]);
+      
       for (const symbol of symbols.symbols || []) {
-        existingSymbols.push({ name: symbol.name, file: changed.path, type: symbol.type });
+        const id = `${changed.path}#${symbol.name}`;
+        
+        // Add to symbols index
+        symbolsData.symbols[id] = {
+          name: symbol.name,
+          type: symbol.type,
+          file: changed.path,
+          line: symbol.line,
+          module: changed.path.split('/')[0],
+          export: symbol.export
+        };
+        
+        // Add to byFile
+        if (!symbolsData.byFile[changed.path]) {
+          symbolsData.byFile[changed.path] = [];
+        }
+        symbolsData.byFile[changed.path].push({
+          id,
+          name: symbol.name,
+          type: symbol.type,
+          file: changed.path,
+          line: symbol.line,
+          export: symbol.export
+        });
+        
+        // Add to byType
+        if (!symbolsData.byType[symbol.type]) {
+          symbolsData.byType[symbol.type] = [];
+        }
+        symbolsData.byType[symbol.type].push({
+          id,
+          name: symbol.name,
+          type: symbol.type,
+          file: changed.path,
+          line: symbol.line,
+          export: symbol.export
+        });
+        
+        // Add to exported if applicable
+        if (symbol.export) {
+          symbolsData.exported.push({
+            id,
+            name: symbol.name,
+            type: symbol.type,
+            file: changed.path,
+            line: symbol.line,
+            export: symbol.export
+          });
+        }
       }
     } catch { /* skip */ }
   }
   
-  writeFile(symbolsPath, JSON.stringify(existingSymbols, null, 2));
-  return existingSymbols.length;
+  // Update total
+  symbolsData.total = Object.keys(symbolsData.symbols).length;
+  
+  writeFile(symbolsPath, JSON.stringify(symbolsData, null, 2));
+  return symbolsData.total;
 }
 
 // ============================================================
@@ -282,7 +372,7 @@ export function updateKnowledgeGraph(rootDir: string, aiDir: string): boolean {
 // ============================================================
 
 export function runIncrementalUpdate(rootDir: string, aiDir?: string): IncrementalUpdateResult {
-  const targetAiDir = aiDir || path.join(rootDir, "ai");
+  const targetAiDir = aiDir || path.join(rootDir, "ai-context");
   const errors: string[] = [];
   
   if (!fs.existsSync(targetAiDir)) {
@@ -346,7 +436,7 @@ export function runIncrementalUpdate(rootDir: string, aiDir?: string): Increment
 }
 
 function updateIndexState(rootDir: string, changedFiles: ChangedFile[]): void {
-  const aiDir = path.join(rootDir, "ai");
+  const aiDir = path.join(rootDir, "ai-context");
   let state = loadIndexState(aiDir);
   
   if (!state) {

package/src/core/knowledgeGraphBuilder.ts

@@ -147,7 +147,7 @@ export function createEdges(aiDir: string): KnowledgeEdge[] {
 }
 
 export function buildKnowledgeGraph(rootDir: string, aiDir?: string): KnowledgeGraph {
-  const targetAiDir = aiDir || path.join(rootDir, "ai");
+  const targetAiDir = aiDir || path.join(rootDir, "ai-context");
   const graphDir = path.join(targetAiDir, "graph");
   ensureDir(graphDir);
   const nodes = createNodes(targetAiDir);

package/src/core/semanticContexts.ts

@@ -28,7 +28,11 @@ export interface SemanticContexts {
 // ============================================================
 
 // 1. Candidate roots - scan inside these directories
-const CANDIDATE_ROOTS = ["src", "app", "packages", "services", "modules", "features"];
+const CANDIDATE_ROOTS = [
+  "src", "app", "packages", "services", "modules", "features",
+  // MVC patterns - for projects without src/ prefix
+  "controllers", "routes", "handlers", "views", "pages"
+];
 
 // 2. Ignore folders - these are technical, not business features
 const IGNORED_FOLDERS = new Set([
@@ -39,7 +43,6 @@ const IGNORED_FOLDERS = new Set([
   "constants",
   "config",
   "dto",
-  "models",
   "common",
   "shared"
 ]);
@@ -54,7 +57,11 @@ const ENTRYPOINT_PATTERNS = [
 ];
 
 // 4. Flow-specific patterns
-const FLOW_ENTRY_PATTERNS = ["controller", "route", "handler", "command"];
+const FLOW_ENTRY_PATTERNS = [
+  "controller", "route", "handler", "command",
+  // Frontend patterns
+  "page", "screen", "view", "component"
+];
 
 // 5. Flow exclusion patterns
 const FLOW_EXCLUDE = new Set([
@@ -83,26 +90,44 @@ const MAX_FLOW_FILES = 30;
 
 // Supported source file extensions
 const SOURCE_EXTENSIONS = new Set([
-  ".ts", ".tsx", ".js", ".jsx", ".py", ".java", ".kt", ".go", ".rs", ".rb", ".php", ".cs", ".vue", ".svelte"
+  ".ts", ".tsx", ".js", ".jsx", ".py", ".java", ".kt", ".go", ".rs", ".rb", ".php", ".cs", ".vue", ".svelte",
+  // Salesforce/Apex
+  ".cls", ".trigger", ".apex", ".object"
 ]);
 
 // ============================================================
 // HELPER FUNCTIONS
 // ============================================================
 
+function sanitizeFlowName(name: string): string {
+  return name
+    .replace(/\.\.+/g, ".")
+    .replace(/_+$/g, "")
+    .replace(/[^\w\-]/g, "_")
+    .replace(/_+/g, "_")
+    .replace(/^_+|_+$/g, "") || "unnamed";
+}
+
 function isSourceFile(filePath: string): boolean {
   const ext = path.extname(filePath).toLowerCase();
   return SOURCE_EXTENSIONS.has(ext);
 }
 
 function isEntrypoint(filePath: string): boolean {
+  const lower = filePath.toLowerCase();
+  // Check both filename and directory path
   const basename = path.basename(filePath).toLowerCase();
-  return ENTRYPOINT_PATTERNS.some(pattern => basename.includes(pattern));
+  return ENTRYPOINT_PATTERNS.some(pattern => 
+    basename.includes(pattern) || lower.includes("/" + pattern + "s/")
+  );
 }
 
 function isFlowEntrypoint(filePath: string): boolean {
+  const lower = filePath.toLowerCase();
   const basename = path.basename(filePath).toLowerCase();
-  return FLOW_ENTRY_PATTERNS.some(pattern => basename.includes(pattern));
+  return FLOW_ENTRY_PATTERNS.some(pattern => 
+    basename.includes(pattern) || lower.includes("/" + pattern + "s/")
+  );
 }
 
 function isIgnoredFolder(folderName: string): boolean {
@@ -164,7 +189,20 @@ function findFeatureCandidates(files: string[]): Map<string, string[]> {
     
     if (rootIdx === -1) continue;
     
-    // Check depth 1: src/auth
+    // Check depth 0: controllers/ itself is a feature (when file is directly in root)
+    const depth0FeatureIdx = rootIdx;
+    if (depth0FeatureIdx < parts.length - 1) {
+      const featureName0 = parts[depth0FeatureIdx];
+      if (!isIgnoredFolder(featureName0) && !featureName0.includes(".")) {
+        const featurePath0 = parts.slice(0, depth0FeatureIdx + 1).join("/");
+        if (!candidates.has(featurePath0)) {
+          candidates.set(featurePath0, []);
+        }
+        candidates.get(featurePath0)!.push(file);
+      }
+    }
+    
+    // Check depth 1 and 2: src/auth, src/modules/auth
     for (let depth = 1; depth <= 2; depth++) {
       const featureIdx = rootIdx + depth;
       
@@ -249,36 +287,29 @@ export function generateFeatures(
     // Ignore errors, return empty
   }
 
-  // Get all files from modules
-  const allFiles = Object.values(modules).flatMap(m => m.files || []);
-  
-  // Find candidate features
-  const candidates = findFeatureCandidates(allFiles);
-
-  // Filter and validate candidates
-  for (const [featurePath, files] of candidates) {
+  // Use modules directly from modules.json
+  for (const [moduleName, mod] of Object.entries(modules)) {
+    const files = mod.files || [];
+    
     // Filter to source files only
     const sourceFiles = files.filter(isSourceFile);
     
-    // Must have at least 3 source files
-    if (sourceFiles.length < 3) continue;
+    // Must have at least 2 source files (relaxed from 3 for smaller projects)
+    if (sourceFiles.length < 2) continue;
     
     // Must have at least one entrypoint
     const entrypoints = sourceFiles.filter(isEntrypoint);
     if (entrypoints.length === 0) continue;
     
-    // Extract feature name from path
-    const featureName = featurePath.split("/").pop() || featurePath;
-    
-    // Get dependencies
-    const dependencies = getFeatureDependencies(featurePath, modules);
+    // Extract feature name from path - get the last segment
+    const featureName = mod.path.split("/").pop() || moduleName;
     
     features.push({
       name: featureName,
-      path: featurePath,
+      path: mod.path,
       files: sourceFiles.slice(0, 50),
       entrypoints: entrypoints.slice(0, 10),
-      dependencies
+      dependencies: []
     });
   }
 
@@ -348,7 +379,7 @@ function flowsFromGraph(graphData: any): Flow[] {
     // Must have at least 3 files and 2 layers
     if (fileSet.size >= 3 && layerSet.size >= 2) {
       flows.push({
-        name: path.basename(ep.file || ""),
+        name: sanitizeFlowName(path.basename(ep.file || "").replace(/\.[^.]+$/, "")),
         entrypoint: ep.file || "",
         files: Array.from(fileSet).slice(0, MAX_FLOW_FILES),
         depth: Math.min(MAX_FLOW_DEPTH, [...visited].length),
@@ -372,9 +403,9 @@ function flowsFromFolders(files: string[]): Flow[] {
   for (const file of files) {
     if (!isSourceFile(file)) continue;
     
-    const baseName = path.basename(file).replace(/\.(ts|js|tsx|jsx)$/, "");
-    // Extract feature: authController -> auth, userService -> user
-    const feature = baseName.replace(/(Controller|Service|Repository|Handler|Route|Model|Entity)$/i, "");
+    const baseName = path.basename(file).replace(/\.[^.]+$/, "");
+    // Extract feature: authController -> auth, userService -> user, LoginPage -> login, Dashboard -> dashboard
+    const feature = baseName.replace(/(Controller|Service|Repository|Handler|Route|Model|Entity|Command|Page|Screen|View|Component)$/i, "");
     const key = feature.toLowerCase();
     
     if (!byFeature.has(key)) {
@@ -384,10 +415,13 @@ function flowsFromFolders(files: string[]): Flow[] {
   }
   
   for (const [feature, featureFiles] of byFeature) {
-    if (featureFiles.length < 3) continue;
+    // Relaxed: allow flows with 2+ files OR files that match entrypoint patterns
+    const hasEntrypoint = featureFiles.some(f => isFlowEntrypoint(f));
+    if (featureFiles.length < 2 && !hasEntrypoint) continue;
     
     const layers = new Set(featureFiles.map(getLayer).filter(l => l !== "unknown"));
-    if (layers.size < 2) continue;
+    // Relaxed: allow single layer if files match entrypoint patterns
+    if (layers.size < 2 && !hasEntrypoint) continue;
     
     const sorted = [...featureFiles].sort((a, b) => 
       getLayerPriority(a) - getLayerPriority(b)
@@ -396,7 +430,7 @@ function flowsFromFolders(files: string[]): Flow[] {
     const entrypoint = sorted.find(isFlowEntrypoint) || sorted[0];
     
     flows.push({
-      name: feature,
+      name: sanitizeFlowName(feature),
       entrypoint,
       files: sorted.slice(0, MAX_FLOW_FILES),
       depth: layers.size,
@@ -461,7 +495,7 @@ function flowsFromImports(
     
     if (fileSet.size >= 3 && layerSet.size >= 2) {
       flows.push({
-        name: path.basename(ep, path.extname(ep)),
+        name: sanitizeFlowName(path.basename(ep, path.extname(ep))),
         entrypoint: ep,
         files: Array.from(fileSet),
         depth: Math.min(MAX_FLOW_DEPTH, [...visited].length),
@@ -567,7 +601,8 @@ export function generateSemanticContexts(aiDir: string): SemanticContexts {
   // Write flows
   ensureDir(flowsDir);
   for (const flow of flows) {
-    const filePath = path.join(flowsDir, `${flow.name}.json`);
+    const safeName = sanitizeFlowName(flow.name);
+    const filePath = path.join(flowsDir, `${safeName}.json`);
     writeFile(filePath, JSON.stringify(flow, null, 2));
   }
   

package/src/core/symbolGraph.ts

@@ -145,7 +145,7 @@ function buildSymbolRelationships(
   // 1. Process imports relationships
   for (const dep of depsAnalysis.dependencies) {
     const sourceSymbols = symbols.filter(s => s.file === dep.source);
-    let targetSymbol = findTargetSymbol(dep.target, symbolMap);
+    let targetSymbol = findTargetSymbol(dep.target, symbolMap, symbols);
 
     if (targetSymbol && sourceSymbols.length > 0) {
       for (const source of sourceSymbols) {
@@ -185,7 +185,7 @@ function buildSymbolRelationships(
 /**
  * Find target symbol from import path
  */
-function findTargetSymbol(targetPath: string, symbolMap: Map<string, Symbol>): Symbol | undefined {
+function findTargetSymbol(targetPath: string, symbolMap: Map<string, Symbol>, allSymbols?: Symbol[]): Symbol | undefined {
   // Try exact match
   let target = symbolMap.get(targetPath);
   
@@ -208,6 +208,20 @@ function findTargetSymbol(targetPath: string, symbolMap: Map<string, Symbol>): S
     }
   }
 
+  // Try to find any symbol in the target file
+  if (!target && allSymbols) {
+    const targetFile = targetPath.replace(/\.[^.]+$/, '');
+    const fileSymbols = allSymbols.filter(s => {
+      const symFile = s.file.replace(/\.[^.]+$/, '');
+      return symFile === targetFile || symFile.endsWith('/' + targetFile) || symFile.endsWith('/' + targetPath.replace(/\.[^.]+$/, ''));
+    });
+    
+    if (fileSymbols.length > 0) {
+      // Return the first exported symbol, or just the first one
+      target = fileSymbols.find(s => s.export) || fileSymbols[0];
+    }
+  }
+
   return target;
 }
 

package/src/utils/fileUtils.ts

@@ -51,6 +51,11 @@ export const DEFAULT_INCLUDE_EXTENSIONS = [
   ".yaml",
   ".yml",
   ".md",
+  // Salesforce
+  ".cls",
+  ".trigger",
+  ".apex",
+  ".object",
 ];
 
 /**