@lisa.ai/agent 1.1.6 → 1.1.7

package/dist/commands/coverage.js

@@ -76,29 +76,51 @@ async function coverageCommand(command, modelProvider, attempt = 1, maxRetries =
                 console.log(`✅ [Lisa.ai Coverage] 100% Logic Coverage Verified! No un-covered files remaining.`);
                 return; // We exit the loop
             }
-            if (attempt >= maxRetries) {
-                console.error(`\n🚨 [Lisa.ai Error] Max coverage retries (${maxRetries}) reached with remaining gaps. Auto-generation limits exceeded.`);
-                process.exit(1);
-            }
+            // [Lisa.ai V2 Infinite Loop]
+            // We consciously remove the global retry cutoff. Lisa natively runs infinitely in the background
+            // resolving testing issues continuously until the pipeline hits 100% green code organically.
             console.log(`[Lisa.ai Coverage] Found ${uncoveredFiles.length} file(s) below 100% threshold:`, uncoveredFiles);
             // 3. Address the first uncovered file
             const targetFilePath = uncoveredFiles[0];
             const absoluteTarget = path.resolve(process.cwd(), targetFilePath);
-            console.log(`[Lisa.ai Coverage] Requesting generated test suite for ${targetFilePath}...`);
-            const fileContent = fs.readFileSync(absoluteTarget, 'utf-8');
-            const testCode = await (0, llm_service_1.generateTestForFile)(targetFilePath, fileContent, modelProvider, apiKey);
-            // Derive spec name from original file name (e.g. app.component.ts -> app.component.spec.ts)
             const parsedPath = path.parse(absoluteTarget);
-            const specPath = path.join(parsedPath.dir, `${parsedPath.name}.spec${parsedPath.ext}`);
-            fs.writeFileSync(specPath, testCode, 'utf-8');
-            console.log(`[Lisa.ai Coverage] Generated and wrote Spec File to ${specPath}`);
+            // Dynamically detect existing Testing specs irrespective of framework
+            const possibleSpecs = [
+                path.join(parsedPath.dir, `${parsedPath.name}.spec${parsedPath.ext}`),
+                path.join(parsedPath.dir, `${parsedPath.name}.test${parsedPath.ext}`),
+                path.join(parsedPath.dir, `${parsedPath.name}.spec.js`),
+                path.join(parsedPath.dir, `${parsedPath.name}.test.js`),
+                path.join(parsedPath.dir, `${parsedPath.name}.spec.ts`),
+                path.join(parsedPath.dir, `${parsedPath.name}.test.ts`)
+            ];
+            let existingSpecContent = null;
+            let targetSpecPath = path.join(parsedPath.dir, `${parsedPath.name}.spec${parsedPath.ext}`); // Default
+            for (const p of possibleSpecs) {
+                if (fs.existsSync(p)) {
+                    targetSpecPath = p;
+                    existingSpecContent = fs.readFileSync(p, 'utf-8');
+                    break;
+                }
+            }
+            let testCode = '';
+            const fileContent = fs.readFileSync(absoluteTarget, 'utf-8');
+            if (existingSpecContent) {
+                console.log(`[Lisa.ai Coverage] Existing test suite discovered for ${targetFilePath}. Requesting single-pass logic coverage append...`);
+                testCode = await (0, llm_service_1.updateTestForFile)(targetFilePath, fileContent, path.relative(process.cwd(), targetSpecPath), existingSpecContent, modelProvider, apiKey);
+            }
+            else {
+                console.log(`[Lisa.ai Coverage] Requesting newly generated test suite for ${targetFilePath}...`);
+                testCode = await (0, llm_service_1.generateTestForFile)(targetFilePath, fileContent, modelProvider, apiKey);
+            }
+            fs.writeFileSync(targetSpecPath, testCode, 'utf-8');
+            console.log(`[Lisa.ai Coverage] Wrote Spec File to ${targetSpecPath}`);
             await (0, telemetry_service_1.reportTelemetry)({
                 projectId,
                 type: 'coverage',
-                filePath: targetFilePath, // Keeping original as the provided edit was syntactically incorrect for an object literal
+                filePath: targetFilePath,
                 modelUsed: modelProvider,
                 status: 'success',
-                details: `### Missing Logic Coverage Detected\n**Auto-Generated Specification Suite (${modelProvider}):**\n\`\`\`typescript\n${testCode}\n\`\`\``
+                details: `### Logic Coverage Action Detected\n**Auto-Generated Specification Append (${modelProvider}):**\n\`\`\`typescript\n${testCode}\n\`\`\``
             });
             // 4. Recursive iteration to verify newly written test and hunt for next gap
             await coverageCommand(command, modelProvider, attempt + 1, maxRetries, projectId, apiKey);

package/dist/commands/heal.js

@@ -41,30 +41,37 @@ const parser_1 = require("../utils/parser");
 const llm_service_1 = require("../services/llm.service");
 const git_service_1 = require("../services/git.service");
 const telemetry_service_1 = require("../services/telemetry.service");
+function isolateTestCommand(globalCommand, targetFile) {
+    const cmd = globalCommand.toLowerCase();
+    // Angular/Karma
+    if (cmd.includes('ng test') || cmd.includes('karma')) {
+        return `${globalCommand} --include ${targetFile}`;
+    }
+    // Jest/Vitest/Playwright
+    if (cmd.includes('jest') || cmd.includes('vitest') || cmd.includes('playwright')) {
+        return `${globalCommand} ${targetFile}`;
+    }
+    // Cypress
+    if (cmd.includes('cypress')) {
+        return `${globalCommand} --spec ${targetFile}`;
+    }
+    return globalCommand;
+}
 async function healCommand(command, modelProvider, attempt = 1, healedFilePath = null, maxRetries = 3, projectId = 'local', lastFixDetails, apiKey, skipLedger = [], consecutiveFails = 0, failTracker = {}) {
-    console.log(`\n[Lisa.ai Executing] ${command} (Attempt ${attempt}/${maxRetries}) Using Model: ${modelProvider}`);
+    console.log(`\n[Lisa.ai Executing] ${command} (Global Engine) Using Model: ${modelProvider}`);
     try {
-        // Execute command synchronously
-        // stdio: 'pipe' captures stdout/stderr so they are thrown in error object on fail.
-        // However, to show stream we could use inherit, but we need the error log.
-        // For now, we capture and print it.
         const output = (0, child_process_1.execSync)(command, { encoding: 'utf-8', stdio: 'pipe' });
         console.log(output);
-        console.log(`\n✅ [Lisa.ai Success] Command executed successfully on attempt ${attempt}.`);
-        // If we successfully executed and had previously healed a file, PR it
+        console.log(`\n✅ [Lisa.ai Success] Global Command executed successfully.`);
         if (healedFilePath) {
             await (0, git_service_1.createPullRequestForHeal)(healedFilePath);
         }
+        return; // Successfully finished without throwing
     }
     catch (error) {
-        console.log(`\n❌ [Lisa.ai Failure] Command failed.`);
-        // Combine logs
+        console.log(`\n❌ [Lisa.ai Failure] Global Command failed.`);
         const errorLog = (error.stderr || '') + '\n' + (error.stdout || '') + '\n' + (error.message || '');
         console.error(errorLog);
-        if (attempt >= maxRetries) {
-            console.error(`\n🚨 [Lisa.ai Error] Max retries (${maxRetries}) reached. Auto-heal failed.`);
-            process.exit(1);
-        }
         console.log(`\n[Lisa.ai Auto-Heal] Analyzing errors...`);
         const filePath = (0, parser_1.extractFilePath)(errorLog, skipLedger, process.cwd());
         if (!filePath) {
@@ -76,51 +83,60 @@ async function healCommand(command, modelProvider, attempt = 1, healedFilePath =
             console.error(`\n🚨 [Lisa.ai Error] Extracted file path does not exist: ${absolutePath}`);
             process.exit(1);
         }
-        console.log(`[Lisa.ai Auto-Heal] Identified failing file: ${filePath}`);
-        // Read file contents to send to LLM
-        const fileContent = fs.readFileSync(absolutePath, 'utf-8');
-        // Increment global fail tracker for this specific file
-        failTracker[filePath] = (failTracker[filePath] || 0) + 1;
-        const totalFails = failTracker[filePath];
-        if (totalFails >= 3) {
-            console.warn(`\n[Lisa.ai Auto-Heal] ⚠️ Warning: Agent failed to heal ${filePath} after 3 overall attempts in this session. Marking as Skipped to avoid infinite Loop.`);
+        console.log(`[Lisa.ai Auto-Heal] Identified bleeding file: ${filePath}`);
+        // [Lisa.ai V2 Micro-Targeted Healing Loop]
+        // Instead of restarting the global CI engine (e.g. `npm run test`) and waiting for all 400 specs
+        // to run just to fetch the error for this one file, we trap it locally with its native CLI frame isolation arguments!
+        let localAttempt = 1;
+        let isFixed = false;
+        let currentErrorLog = errorLog;
+        let previousContext = undefined;
+        let generatedDetails = '';
+        const isolatedCommand = isolateTestCommand(command, filePath);
+        while (localAttempt <= maxRetries && !isFixed) {
+            console.log(`\n[Lisa.ai Micro-Heal] Isolating ${filePath} (Attempt ${localAttempt}/${maxRetries})`);
+            const fileContent = fs.readFileSync(absolutePath, 'utf-8');
+            const fixedCode = await (0, llm_service_1.askLisaForFix)(filePath, fileContent, currentErrorLog, modelProvider, apiKey, previousContext);
+            fs.writeFileSync(absolutePath, fixedCode, 'utf-8');
+            console.log(`[Lisa.ai Micro-Heal] Applied isolated patch to ${filePath}`);
+            generatedDetails = `### Auto-Heal Analysis Triggered\n**Caught Error:**\n\`\`\`bash\n${currentErrorLog}\n\`\`\`\n\n**Applied Fix (${modelProvider}):**\n\`\`\`typescript\n${fixedCode}\n\`\`\``;
+            // Dispatch telemetry instantly so the dashboard updates exactly when the file is patched natively
+            await (0, telemetry_service_1.reportTelemetry)({
+                projectId,
+                type: 'heal',
+                filePath: filePath,
+                modelUsed: modelProvider,
+                status: 'success',
+                details: generatedDetails
+            });
+            try {
+                // Verify the isolated file silently without exploding the Global terminal with 400 other spec errors
+                console.log(`[Lisa.ai Micro-Heal] Verifying fix with isolated command: ${isolatedCommand}`);
+                (0, child_process_1.execSync)(isolatedCommand, { encoding: 'utf-8', stdio: 'pipe' });
+                console.log(`✅ [Lisa.ai Micro-Heal] Isolated verification passed for ${filePath}!`);
+                isFixed = true;
+            }
+            catch (isolatedError) {
+                console.log(`❌ [Lisa.ai Micro-Heal] Isolated verification failed.`);
+                currentErrorLog = (isolatedError.stderr || '') + '\n' + (isolatedError.stdout || '') + '\n' + (isolatedError.message || '');
+                previousContext = `### Attempt ${localAttempt} Failed\n\`\`\`typescript\n${fixedCode}\n\`\`\`\n\n**New Error:**\n${currentErrorLog}`;
+                localAttempt++;
+            }
+        }
+        if (!isFixed) {
+            console.warn(`\n[Lisa.ai Auto-Heal] ⚠️ Agent failed to locally heal ${filePath} after ${maxRetries} isolated attempts. Marking as Skipped to avoid infinite Loop.`);
             skipLedger.push(filePath);
-            // [Lisa.ai Advanced Path Neutralization]
-            // If the LLM failed to heal a spec file 3 times, we MUST mathematically eliminate it from the glob path
-            // otherwise Karma will STILL execute the broken spec, exit with Code 1, and eventually trap the Agent 
-            // when the parser exhausts all files. We rename it to .broken to physically bypass the test runner.
-            if (filePath.endsWith('.spec.ts')) {
+            // Advanced Path Neutralization for generic JS tests across the V2 Ecosystem Architecture
+            if (filePath.match(/\.(spec|test)\.(ts|js|tsx|jsx|vue)$/)) {
                 const brokenPath = absolutePath + '.broken';
                 try {
                     fs.renameSync(absolutePath, brokenPath);
-                    console.log(`[Lisa.ai Auto-Heal] 🚨 Renamed unhealable spec to ${filePath}.broken to force the test runner to skip it!`);
-                }
-                catch (renameErr) {
-                    console.error(`[Lisa.ai Warning] Could not rename ${filePath}: ${renameErr.message}`);
+                    console.log(`[Lisa.ai Auto-Heal] 🚨 Renamed unhealable spec to ${filePath}.broken to force the test runner to bypass it!`);
                 }
+                catch (e) { }
             }
-            // Immediately retry the loop but force the parser to skip this broken file
-            await healCommand(command, modelProvider, attempt + 1, healedFilePath, maxRetries, projectId, lastFixDetails, apiKey, skipLedger, 0, failTracker);
-            return;
         }
-        // Pass previous attempted fix if we are stuck in a loop on the same file
-        const previousContext = (totalFails > 1) ? lastFixDetails : undefined;
-        // Call LLM for a fix
-        const fixedCode = await (0, llm_service_1.askLisaForFix)(filePath, fileContent, errorLog, modelProvider, apiKey, previousContext);
-        // Write the fix to the file
-        fs.writeFileSync(absolutePath, fixedCode, 'utf-8');
-        console.log(`[Lisa.ai Auto-Heal] Applied patch to ${filePath}`);
-        const generatedDetails = `### Auto-Heal Analysis Triggered\n**Caught Error:**\n\`\`\`bash\n${errorLog}\n\`\`\`\n\n**Applied Fix (${modelProvider}):**\n\`\`\`typescript\n${fixedCode}\n\`\`\``;
-        // Dispatch telemetry instantly so the dashboard updates in real-time exactly when the file is patched
-        await (0, telemetry_service_1.reportTelemetry)({
-            projectId,
-            type: 'heal',
-            filePath: filePath,
-            modelUsed: modelProvider,
-            status: 'success',
-            details: generatedDetails
-        });
-        // Recursive retry, passing the healed file path state and updated limits
-        await healCommand(command, modelProvider, attempt + 1, filePath, maxRetries, projectId, generatedDetails, apiKey, skipLedger, 0, failTracker);
+        // Return to the Global Macro CI Engine to find the next error implicitly or gracefully green-light
+        await healCommand(command, modelProvider, 1, isFixed ? filePath : null, maxRetries, projectId, undefined, apiKey, skipLedger, 0, failTracker);
     }
 }

package/dist/services/llm.service.js

@@ -35,6 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.askLisaForFix = askLisaForFix;
 exports.generateTestForFile = generateTestForFile;
+exports.updateTestForFile = updateTestForFile;
 const ai_1 = require("ai");
 const openai_1 = require("@ai-sdk/openai");
 const anthropic_1 = require("@ai-sdk/anthropic");
@@ -79,7 +80,7 @@ ${fileContent}
 2. Do not suppress TypeScript errors with @ts-ignore or any type assertions unless absolutely unavoidable.
 3. Fix the underlying type or logic issue.
 4. CRITICAL AGILE RULE: If the error is 'Cannot find module' or 'Property DOES NOT EXIST' and you do NOT know the correct import path or cannot resolve it from the context, you MUST silently comment out the failing import and completely comment out/stub the code that relies on it. Your ultimate goal is to make the file compile successfully so the Agent can proceed to the next file.
-5. ANGULAR TEST RULE: If fixing a ".spec.ts" file and the error is 'NullInjectorError: No provider for X', you MUST add X to the 'providers' array in 'TestBed.configureTestingModule' or import the required testing module (e.g., 'HttpClientTestingModule'). If the error is 'Unexpected "X" found in the "declarations" array...marked as standalone', you MUST move X from the 'declarations' array to the 'imports' array in 'TestBed.configureTestingModule'.
+5. FRAMEWORK TEST RULE: If fixing a testing file (\`.spec\` or \`.test\`) and an Angular error happens like 'NullInjectorError: No provider for X', you MUST add X to the 'providers' array in 'TestBed.configureTestingModule' or import the required testing module. If a React testing library error arises, fix the render context.
 6. Return the code wrapped in a markdown code block (\`\`\`typescript ... \`\`\`). Do not include any explanation or intro text.`;
     if (previousFixAttempt) {
         console.log(`[Lisa.ai Auto-Heal] Warning! Agent is looping on ${filePath}. Injecting previous failed context...`);
@@ -100,20 +101,44 @@ async function generateTestForFile(sourceFilePath, sourceFileContent, modelProvi
     console.log(`[Lisa.ai Coverage] Requesting test generation from ${modelProvider} for ${sourceFilePath}...`);
     const model = getProvider(modelProvider, apiKey);
     const prompt = `You are Lisa.ai, an autonomous CI/CD expert platform.
-A TypeScript/Angular file lacks 100% test coverage. Your task is to generate a comprehensive Jest unit test file (.spec.ts) covering all branches, lines, and functions.
+A source file lacks 100% test coverage. Your task is to generate a comprehensive testing suite covering all branches, lines, and functions.
 
 --- Target File Content (${sourceFilePath}) ---
 ${sourceFileContent}
 
 --- Constraints ---
-1. Return the generated TypeScript test code wrapped in a markdown code block (\`\`\`typescript ... \`\`\`).
+1. Return the generated test code wrapped in a markdown code block (\`\`\`typescript ... \`\`\`).
 2. Do not include any explanation or intro text.
-3. Include all necessary imports assuming Jest is available.
+3. Include all necessary imports assuming a standard testing framework (Jest/Karma/Vitest) is available.
 4. Aim for 100% logic coverage.`;
     const { text } = await (0, ai_1.generateText)({
         model,
         prompt,
     });
-    const match = text.match(/```(?:typescript|ts)?\n([\s\S]*?)```/);
+    const match = text.match(/```(?:typescript|ts|javascript|js)?\n([\s\S]*?)```/);
+    return match ? match[1].trim() : text.trim();
+}
+async function updateTestForFile(sourceFilePath, sourceFileContent, testFilePath, existingTestContent, modelProvider, apiKey) {
+    console.log(`[Lisa.ai Coverage] Requesting test update from ${modelProvider} for ${sourceFilePath}...`);
+    const model = getProvider(modelProvider, apiKey);
+    const prompt = `You are Lisa.ai, an autonomous CI/CD expert platform.
+A source file lacks 100% test coverage. You must update its existing test suite to achieve full coverage.
+
+--- Target File Content (${sourceFilePath}) ---
+${sourceFileContent}
+
+--- Existing Test Suite (${testFilePath}) ---
+${existingTestContent}
+
+--- Constraints ---
+1. Return the updated complete test code wrapped in a markdown code block (\`\`\`typescript ... \`\`\`).
+2. Do not include any explanation or intro text.
+3. Append missing tests to the existing suite. Do not delete existing passing tests unless they are fundamentally broken.
+4. Aim for 100% logic coverage across branches, lines, and functions.`;
+    const { text } = await (0, ai_1.generateText)({
+        model,
+        prompt,
+    });
+    const match = text.match(/```(?:typescript|ts|javascript|js)?\n([\s\S]*?)```/);
     return match ? match[1].trim() : text.trim();
 }

package/dist/utils/parser.js

@@ -41,21 +41,18 @@ function extractFilePath(errorLog, skipFiles = [], searchDir = process.cwd()) {
     const cleanLog = errorLog.replace(/\x1B\[[0-9;]*[a-zA-Z]/g, '');
     // Normalize skip files for reliable absolute path comparison
     const normalizedSkips = skipFiles.map(p => path.resolve(p));
-    // 1. First Pass: Try to match typical TS/Angular error patterns
-    // e.g., "src/app/app.component.ts:12:3 - error TS2322:"
-    const tsErrorRegex = /([a-zA-Z0-9_.\-\/\\]+\.ts)(?:[:(])/g;
+    // 1. First Pass: Try to match typical JS/TS/Vue error patterns with line numbers
+    // e.g., "src/components/Button.tsx:12:3 - error"
+    const exactErrorRegex = /([a-zA-Z0-9_.\-\/\\]+\.(?:ts|tsx|js|jsx|vue))(?:\s*[:(])/g;
     let match;
-    // Loop through all matches in the error log
-    while ((match = tsErrorRegex.exec(cleanLog)) !== null) {
+    while ((match = exactErrorRegex.exec(cleanLog)) !== null) {
         const foundPath = match[1];
-        // If this path is NOT in our skip ledger, we return it as the target
         if (foundPath && !normalizedSkips.includes(path.resolve(foundPath))) {
             return foundPath;
         }
     }
-    // 2. Second Pass (Fallback): Find anything that looks like a .ts file
-    // Note: We use the 'g' flag so we can iterate through multiple matches if the first is skipped
-    const fallbackRegex = /([a-zA-Z0-9_.\-\/\\]+\.ts)/g;
+    // 2. Second Pass (Fallback): Find anything that looks like a source file
+    const fallbackRegex = /([a-zA-Z0-9_.\-\/\\]+\.(?:ts|tsx|js|jsx|vue))/g;
     let fallbackMatch;
     while ((fallbackMatch = fallbackRegex.exec(cleanLog)) !== null) {
         const foundPath = fallbackMatch[1];
@@ -63,16 +60,19 @@ function extractFilePath(errorLog, skipFiles = [], searchDir = process.cwd()) {
             return foundPath;
         }
     }
-    // 3. Third Pass (Karma/Jasmine Abstract Fallback): Match Angular Class names
-    // Example: "Chrome 145.0.0.0 (Windows 10) ConfigureNotificationComponent should create FAILED"
-    // Example: "NullInjectorError: R3InjectorError(Standalone[RegisterComponent])"
-    const classRegex = /([A-Z][a-zA-Z0-9]+(?:Component|Service|Module|Directive|Pipe|Guard|Interceptor))/g;
-    let classMatch;
-    while ((classMatch = classRegex.exec(cleanLog)) !== null) {
-        const className = classMatch[1];
-        if (className) {
-            console.log(`[Lisa.ai Parser] Discovered abstract class failure: ${className}. Scanning 'src/' tree...`);
-            const matchedFile = findFileByClassName(className, path.join(searchDir, 'src'), normalizedSkips);
+    // 3. Third Pass (Abstract Testing Fallback): Match exported PascalCase symbols
+    // Framework-agnostic. Often testing tools say "Unexpected 'MyButton'" or "Chrome 120 MyService FAILED"
+    const symbolRegex = /\b([A-Z][a-zA-Z0-9]{3,})\b/g;
+    let symbolMatch;
+    const searchedSymbols = new Set();
+    // Filter out common JS/Browser built-ins and framework generics that are not user files
+    const ignoreList = ['Error', 'TypeError', 'SyntaxError', 'NullInjectorError', 'Object', 'Boolean', 'String', 'Number', 'Array', 'Chrome', 'Windows', 'Linux', 'Macintosh', 'UserContext', 'TestBed', 'Module'];
+    while ((symbolMatch = symbolRegex.exec(cleanLog)) !== null) {
+        const symbolName = symbolMatch[1];
+        if (symbolName && !ignoreList.includes(symbolName) && !searchedSymbols.has(symbolName)) {
+            searchedSymbols.add(symbolName);
+            console.log(`[Lisa.ai Parser] Discovered abstract symbol failure: ${symbolName}. Scanning 'src/' tree...`);
+            const matchedFile = findFileBySymbolName(symbolName, path.join(searchDir, 'src'), normalizedSkips);
             if (matchedFile) {
                 // Return path relative to project root
                 return path.relative(searchDir, matchedFile);
@@ -83,11 +83,11 @@ function extractFilePath(errorLog, skipFiles = [], searchDir = process.cwd()) {
     return null;
 }
 /**
- * Recursively walks a directory looking for a `.ts` file that exports the target class.
- * Designed to bypass Karma's frustrating habit of omitting absolute script paths in Spec exceptions.
- * We pass normalizedSkips to ensure we do not return a file that the Agent has explicitly blacklisted this session.
+ * Recursively walks a directory looking for a source file that strictly exports the target symbol.
+ * Designed to bypass test runners omitting absolute script paths in test exceptions.
+ * We pass normalizedSkips to ensure we do not return a file that the Agent has explicitly blacklisted.
  */
-function findFileByClassName(className, dir, skipLedgerAbs) {
+function findFileBySymbolName(symbolName, dir, skipLedgerAbs) {
     if (!fs.existsSync(dir))
         return null;
     const files = fs.readdirSync(dir);
@@ -95,29 +95,41 @@ function findFileByClassName(className, dir, skipLedgerAbs) {
         const fullPath = path.join(dir, file);
         const stat = fs.statSync(fullPath);
         if (stat.isDirectory()) {
-            // Recurse into subdirectories (ignore node_modules just in case)
-            if (file !== 'node_modules') {
-                const found = findFileByClassName(className, fullPath, skipLedgerAbs);
+            // Recurse into subdirectories
+            if (file !== 'node_modules' && file !== 'dist' && file !== 'build') {
+                const found = findFileBySymbolName(symbolName, fullPath, skipLedgerAbs);
                 if (found)
                     return found;
             }
         }
-        else if (file.endsWith('.ts')) {
-            // We ONLY care if the file natively exports the class declaration.
-            // We MUST NOT match files that merely `import` the class.
+        else if (file.match(/\.(ts|tsx|js|jsx|vue)$/)) {
+            // We ONLY care if the file natively exports/declares the symbol.
+            // We MUST NOT match files that merely `import` the symbol.
             const content = fs.readFileSync(fullPath, 'utf8');
-            if (content.includes(`class ${className}`)) {
-                // For tests, if a spec fails, we want to heal the spec file first!
-                // If the class is found in a non-spec file, and a spec file exists next to it, favor the spec.
+            if (content.includes(`class ${symbolName}`) ||
+                content.includes(`function ${symbolName}`) ||
+                content.includes(`const ${symbolName}`) ||
+                content.includes(`let ${symbolName}`)) {
                 let targetPath = fullPath;
-                if (!file.endsWith('.spec.ts')) {
-                    const hypotheticalSpec = fullPath.replace('.ts', '.spec.ts');
-                    if (fs.existsSync(hypotheticalSpec)) {
-                        targetPath = hypotheticalSpec;
+                // Find standard test extensions dynamically based on ecosystem
+                const ext = path.extname(fullPath);
+                const base = fullPath.slice(0, -ext.length);
+                // Check if a spec/test file already exists for this source code natively
+                if (!file.includes('.spec.') && !file.includes('.test.')) {
+                    const possibleSpecs = [
+                        `${base}.spec${ext}`,
+                        `${base}.test${ext}`,
+                        `${base}.spec.js`,
+                        `${base}.test.js`
+                    ];
+                    for (const p of possibleSpecs) {
+                        if (fs.existsSync(p)) {
+                            targetPath = p;
+                            break;
+                        }
                     }
                 }
                 // If the decided file is NOT in the skip ledger, return it.
-                // Otherwise, safely ignore it and keep looping for other matches in the directory tree.
                 if (!skipLedgerAbs.includes(path.resolve(targetPath))) {
                     return targetPath;
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lisa.ai/agent",
-  "version": "1.1.6",
+  "version": "1.1.7",
   "description": "Lisa.ai Autonomous CI/CD Worker Agent",
   "main": "dist/index.js",
   "bin": {