@lisa.ai/agent 2.1.3 → 2.2.0

package/dist/commands/coverage.js

@@ -45,16 +45,21 @@ const discovery_service_1 = require("../services/discovery.service");
 const installer_service_1 = require("../services/installer.service");
 const generator_service_1 = require("../services/generator.service");
 async function coverageCommand(command, modelProvider, attempt = 1, maxRetries = 3, projectId = 'local', apiKey) {
-    // [Lisa.ai V2 Zero-Config Engine] 
+    // Bug 8 fix: Always run scanRepository() so we have a framework fingerprint regardless of
+    // whether the user passed --command explicitly. scanRepository() is cheap (reads package.json)
+    // and the framework string is critical for generating syntactically correct tests (Bug 3).
+    const fingerprint = discovery_service_1.AutoDiscoveryService.scanRepository();
+    const detectedFramework = fingerprint.testingFramework !== 'none' ? fingerprint.testingFramework : undefined;
+    // [Lisa.ai V2 Zero-Config Engine]
     if (!command) {
         console.log(`\n[Lisa.ai Auto-Discovery] No explicit --command provided. Initiating Autonomous Framework Fingerprinting...`);
-        let fingerprint = discovery_service_1.AutoDiscoveryService.scanRepository();
-        if (fingerprint.testingFramework === 'none') {
-            fingerprint = await installer_service_1.AutoInstallerService.installMissingFramework(fingerprint);
-            await generator_service_1.AutoGeneratorService.provisionConfigurationFiles(fingerprint, modelProvider, apiKey);
+        let mutableFingerprint = fingerprint;
+        if (mutableFingerprint.testingFramework === 'none') {
+            mutableFingerprint = await installer_service_1.AutoInstallerService.installMissingFramework(mutableFingerprint);
+            await generator_service_1.AutoGeneratorService.provisionConfigurationFiles(mutableFingerprint, modelProvider, apiKey);
         }
-        if (fingerprint.suggestedTestCommand) {
-            command = fingerprint.suggestedTestCommand;
+        if (mutableFingerprint.suggestedTestCommand) {
+            command = mutableFingerprint.suggestedTestCommand;
             console.log(`[Lisa.ai Auto-Discovery] Bootstrapping execution with natively discovered command: ${command}`);
         }
         else {
@@ -63,7 +68,6 @@ async function coverageCommand(command, modelProvider, attempt = 1, maxRetries =
         }
     }
     console.log(`\n[Lisa.ai Coverage] ${command} (Attempt ${attempt}/${maxRetries}) Using Model: ${modelProvider}`);
-    let executionPassed = true;
     await (0, telemetry_service_1.reportTelemetry)({
         projectId,
         type: 'coverage',
@@ -74,7 +78,7 @@ async function coverageCommand(command, modelProvider, attempt = 1, maxRetries =
     });
     const runSilentlyAndIntercept = (cmd, printProgress = false) => {
         return new Promise((resolve, reject) => {
-            // Node 21+ Deprecation Fix: When shell is true, pass the entire raw command string 
+            // Node 21+ Deprecation Fix: When shell is true, pass the entire raw command string
             // rather than explicitly escaping array arguments to bypass DEP0190.
             const child = (0, child_process_1.spawn)(cmd, { shell: true, stdio: ['ignore', 'pipe', 'pipe'] });
             let stdoutData = '';
@@ -125,72 +129,97 @@ async function coverageCommand(command, modelProvider, attempt = 1, maxRetries =
         await coverageCommand(command, modelProvider, attempt + 1, maxRetries, projectId, apiKey);
         return;
     }
-    // 2. If it passed without compile/runtime errors, evaluate coverage
-    if (executionPassed) {
-        try {
-            // Find JSON summary expecting standard output paths
-            const coveragePath = path.resolve(process.cwd(), 'coverage/coverage-summary.json');
-            if (!fs.existsSync(coveragePath)) {
-                console.warn(`[Lisa.ai Coverage Warning] No coverage-summary.json found at ${coveragePath}. Cannot evaluate logic constraints.`);
+    // 2. Tests passed — evaluate coverage.
+    // Bug 5 fix: removed dead `executionPassed` variable. It was set to `true` on line 42
+    // and never changed, making `if (executionPassed)` an always-true guard that added
+    // misleading nesting. The try block above returns/recursed-and-returned on failure,
+    // so reaching here already implies execution passed.
+    try {
+        // Find JSON summary expecting standard output paths
+        const coveragePath = path.resolve(process.cwd(), 'coverage/coverage-summary.json');
+        let uncoveredFiles = [];
+        if (!fs.existsSync(coveragePath)) {
+            console.log(`\n[Lisa.ai Coverage] No coverage-summary.json found. Initiating Cold-Start Project Crawler...`);
+            // [Lisa.ai Phase 8] Cold-Start Discovery
+            uncoveredFiles = discovery_service_1.AutoDiscoveryService.findUntestedFiles(process.cwd());
+            if (uncoveredFiles.length === 0) {
+                console.log(`✅ [Lisa.ai Coverage] Zero-Test scan complete. No untested source files discovered.`);
                 return;
             }
+            console.log(`[Lisa.ai Coverage] Discovered ${uncoveredFiles.length} untested file(s). Seeding first test suite...`);
+        }
+        else {
             console.log(`[Lisa.ai Coverage] Evaluating summary...`);
-            const uncoveredFiles = (0, coverage_parser_1.parseCoverageSummary)('coverage/coverage-summary.json');
-            if (uncoveredFiles.length === 0) {
-                console.log(`✅ [Lisa.ai Coverage] 100% Logic Coverage Verified! No un-covered files remaining.`);
-                return; // We exit the loop
-            }
-            // [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);
-            const parsedPath = path.parse(absoluteTarget);
-            // 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);
+            uncoveredFiles = (0, coverage_parser_1.parseCoverageSummary)('coverage/coverage-summary.json');
+        }
+        if (uncoveredFiles.length === 0) {
+            console.log(`✅ [Lisa.ai Coverage] 100% Logic Coverage Verified! No un-covered files remaining.`);
+            return; // We exit the loop
+        }
+        // [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);
+        const parsedPath = path.parse(absoluteTarget);
+        // 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;
             }
-            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,
-                modelUsed: modelProvider,
-                status: 'success',
-                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);
         }
-        catch (e) {
-            console.error(`[Lisa.ai Coverage loop failure]:`, e.message);
+        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...`);
+            // Bug 8 fix: pass detectedFramework so the LLM generates correct syntax for the project's framework.
+            testCode = await (0, llm_service_1.updateTestForFile)(targetFilePath, fileContent, path.relative(process.cwd(), targetSpecPath), existingSpecContent, modelProvider, apiKey, detectedFramework);
+        }
+        else {
+            console.log(`[Lisa.ai Coverage] Requesting newly generated test suite for ${targetFilePath}...`);
+            // Bug 8 fix: pass detectedFramework so the LLM generates correct syntax for the project's framework.
+            testCode = await (0, llm_service_1.generateTestForFile)(targetFilePath, fileContent, modelProvider, apiKey, detectedFramework);
         }
+        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,
+            modelUsed: modelProvider,
+            status: 'success',
+            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);
+    }
+    catch (e) {
+        console.error(`[Lisa.ai Coverage loop failure]:`, e.message);
+        // Telemetry Bug 2 fix: send an error event so the control plane dashboard doesn't
+        // show a run that started (status: 'running') but never resolved. Previously any
+        // exception thrown inside the coverage loop — LLM timeout, unreadable file, bad JSON —
+        // would be caught here and silently disappear from the dashboard.
+        await (0, telemetry_service_1.reportTelemetry)({
+            projectId,
+            type: 'coverage',
+            filePath: 'coverage-loop',
+            modelUsed: modelProvider,
+            status: 'error',
+            details: `Coverage loop encountered an unrecoverable error: ${e.message}`
+        });
     }
 }

package/dist/commands/heal.js

@@ -44,6 +44,10 @@ const telemetry_service_1 = require("../services/telemetry.service");
 const discovery_service_1 = require("../services/discovery.service");
 const installer_service_1 = require("../services/installer.service");
 const generator_service_1 = require("../services/generator.service");
+// Bug 6 fix: threshold for the failTracker — how many times a file is allowed to exhaust
+// all local retries across the entire global run before being permanently abandoned.
+// This is the "3-strike skip" described in the context architecture doc.
+const GLOBAL_FAIL_THRESHOLD = 3;
 function fetchSiblingContext(specPath) {
     // Drop the .spec or .test extensions to find the actual Component / Service logic
     const baseSiblingPath = specPath.replace(/\.(spec|test)\.(ts|js|jsx|tsx)$/, '.$2');
@@ -128,7 +132,7 @@ async function healCommand(command, modelProvider, attempt = 1, healedFilePath =
     console.log(`\n[Lisa.ai Executing] ${command} (Global Engine) Using Model: ${modelProvider}`);
     const runSilentlyAndIntercept = (cmd, printProgress = false) => {
         return new Promise((resolve, reject) => {
-            // Node 21+ Deprecation Fix: When shell is true, pass the entire raw command string 
+            // Node 21+ Deprecation Fix: When shell is true, pass the entire raw command string
             // rather than explicitly escaping array arguments to bypass DEP0190.
             const child = (0, child_process_1.spawn)(cmd, { shell: true, stdio: ['ignore', 'pipe', 'pipe'] });
             let stdoutData = '';
@@ -137,7 +141,7 @@ async function healCommand(command, modelProvider, attempt = 1, healedFilePath =
                 const text = data.toString();
                 stdoutData += text;
                 // [Lisa.ai Stream Interceptor]
-                // The user explicitly requested to see a single clean loading line instead of 
+                // The user explicitly requested to see a single clean loading line instead of
                 // thousands of milliseconds of Redundant 'Executed' loops.
                 // Output is fully swallowed, and instead we log a spinner on boot.
             });
@@ -155,8 +159,7 @@ async function healCommand(command, modelProvider, attempt = 1, healedFilePath =
         });
     };
     try {
-        if (true)
-            console.log(`⏳ [Lisa.ai Testing] Booting Headless Test Suite in background...`);
+        console.log(`⏳ [Lisa.ai Testing] Booting Headless Test Suite in background...`);
         await runSilentlyAndIntercept(command, false); // False = output is suppressed natively
         console.log(`\n✅ [Lisa.ai Success] Global Command executed successfully.`);
         if (healedFilePath) {
@@ -179,7 +182,18 @@ 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 bleeding file: ${filePath}`);
+        // Bug 6 fix: implement the "3-strike global skip" described in the architecture doc.
+        // If this file has already exhausted all local retries GLOBAL_FAIL_THRESHOLD times
+        // across the entire run, it is a persistently broken file. Skip it immediately
+        // instead of wasting more LLM calls on it.
+        const globalFailCount = failTracker[filePath] || 0;
+        if (globalFailCount >= GLOBAL_FAIL_THRESHOLD) {
+            console.warn(`\n[Lisa.ai Auto-Heal] ⚠️ ${filePath} has failed globally ${globalFailCount} time(s) — exceeds threshold of ${GLOBAL_FAIL_THRESHOLD}. Permanently skipping.`);
+            skipLedger.push(filePath);
+            await healCommand(command, modelProvider, 1, null, maxRetries, projectId, undefined, apiKey, skipLedger, 0, failTracker);
+            return;
+        }
+        console.log(`[Lisa.ai Auto-Heal] Identified bleeding file: ${filePath} (global fail count: ${globalFailCount}/${GLOBAL_FAIL_THRESHOLD})`);
         // [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!
@@ -242,6 +256,10 @@ async function healCommand(command, modelProvider, attempt = 1, healedFilePath =
                 status: 'error',
                 details: `Agent exhausted all ${maxRetries} attempts without success.\n\n` + generatedDetails
             });
+            // Bug 6 fix: increment the global fail counter for this file so the 3-strike
+            // check at the top of the next iteration can catch it and skip it early.
+            failTracker[filePath] = (failTracker[filePath] || 0) + 1;
+            console.log(`[Lisa.ai Auto-Heal] Global fail counter for ${filePath}: ${failTracker[filePath]}/${GLOBAL_FAIL_THRESHOLD}`);
             skipLedger.push(filePath);
             // Advanced Path Neutralization for generic JS tests across the V2 Ecosystem Architecture
             if (filePath.match(/\.(spec|test)\.(ts|js|tsx|jsx|vue)$/)) {

package/dist/index.js

@@ -5,8 +5,8 @@ const commander_1 = require("commander");
 const config_service_1 = require("./services/config.service");
 const heal_1 = require("./commands/heal");
 const coverage_1 = require("./commands/coverage");
+const pkg = require('../package.json');
 function printBanner() {
-    const pkg = require('../package.json');
     console.log(`\n======================================================`);
     console.log(`✨ Lisa.ai Agent v${pkg.version} Running... `);
     console.log(`   Where pure magic happens! 🪄`);
@@ -16,7 +16,9 @@ const program = new commander_1.Command();
 program
     .name('lisa-agent')
     .description('Lisa.ai - Autonomous CI/CD Platform Worker Agent')
-    .version('1.0.0');
+    // CP Bug 2 fix: was hardcoded as '1.0.0' while package.json (and the banner) show 2.1.x.
+    // `lisa-agent --version` now reports the real package version.
+    .version(pkg.version);
 program
     .command('heal')
     .description('Run a command and autonomously heal errors')
@@ -29,21 +31,34 @@ program
     let model = options.model;
     let apiKey = undefined;
     if (options.projectId) {
-        const config = await (0, config_service_1.fetchRemoteConfig)(options.projectId);
-        if (!config) {
-            console.error(`\n🚨 [Lisa.ai Agent Error] Project '${options.projectId}' does not exist on the Control Plane. Please create it in the Dashboard first or run locally without a project ID.`);
-            process.exit(1);
+        // CP Bug 4 fix: fetchRemoteConfig now returns a discriminated union so we can
+        // tell the difference between "project not found" (→ hard exit, user must create
+        // the project in the Dashboard) and "control plane unreachable" (→ warn and fall
+        // back to local CLI defaults so the agent can still do its job offline).
+        const result = await (0, config_service_1.fetchRemoteConfig)(options.projectId);
+        if (!result.ok) {
+            if (result.reason === 'not_found') {
+                console.error(`\n🚨 [Lisa.ai Agent Error] Project '${options.projectId}' does not exist on the Control Plane. Please create it in the Dashboard first or run locally without a project ID.`);
+                process.exit(1);
+            }
+            else {
+                // 'unreachable' — control plane is temporarily down; continue with local defaults
+                console.warn(`\n⚠️ [Lisa.ai Warning] Control Plane is unreachable. Continuing with local CLI defaults (model=${model}, maxRetries=${maxRetries}).`);
+            }
         }
-        console.log(`[Lisa.ai Agent] Dynamic Config Loaded: Provider=${config.modelProvider}, MaxRetries=${config.maxRetries}`);
-        if (config.maxRetries < 5) {
-            console.warn(`\n⚠️ [Lisa.ai Warning] Your Dashboard Analytics Config has maxRetries set to ${config.maxRetries}. Consider increasing this to 5+ in the WEB UI for complex Angular Healing!`);
-        }
-        model = config.modelProvider;
-        maxRetries = config.maxRetries;
-        apiKey = config.apiKey;
-        if (config.autoHealEnabled === false) {
-            console.log(`[Lisa.ai Agent] Auto-heal is disabled by Control Plane.`);
-            process.exit(1);
+        else {
+            const config = result.config;
+            console.log(`[Lisa.ai Agent] Dynamic Config Loaded: Provider=${config.modelProvider}, MaxRetries=${config.maxRetries}`);
+            if (config.maxRetries < 5) {
+                console.warn(`\n⚠️ [Lisa.ai Warning] Your Dashboard Analytics Config has maxRetries set to ${config.maxRetries}. Consider increasing this to 5+ in the WEB UI for complex Angular Healing!`);
+            }
+            model = config.modelProvider;
+            maxRetries = config.maxRetries;
+            apiKey = config.apiKey;
+            if (config.autoHealEnabled === false) {
+                console.log(`[Lisa.ai Agent] Auto-heal is disabled by Control Plane.`);
+                process.exit(1);
+            }
         }
     }
     await (0, heal_1.healCommand)(options.command, model, 1, null, maxRetries, options.projectId || 'local', undefined, apiKey);
@@ -60,18 +75,35 @@ program
     let model = options.model;
     let apiKey = undefined;
     if (options.projectId) {
-        const config = await (0, config_service_1.fetchRemoteConfig)(options.projectId);
-        if (!config) {
-            console.error(`\n🚨 [Lisa.ai Agent Error] Project '${options.projectId}' does not exist on the Control Plane. Please create it in the Dashboard first or run locally without a project ID.`);
-            process.exit(1);
+        // CP Bug 4 fix: same discriminated-union handling as the heal command above.
+        const result = await (0, config_service_1.fetchRemoteConfig)(options.projectId);
+        if (!result.ok) {
+            if (result.reason === 'not_found') {
+                console.error(`\n🚨 [Lisa.ai Agent Error] Project '${options.projectId}' does not exist on the Control Plane. Please create it in the Dashboard first or run locally without a project ID.`);
+                process.exit(1);
+            }
+            else {
+                console.warn(`\n⚠️ [Lisa.ai Warning] Control Plane is unreachable. Continuing with local CLI defaults (model=${model}, maxRetries=${maxRetries}).`);
+            }
         }
-        console.log(`[Lisa.ai Agent] Dynamic Config Loaded: Provider=${config.modelProvider}, MaxRetries=${config.maxRetries}`);
-        if (config.maxRetries < 5) {
-            console.warn(`\n⚠️ [Lisa.ai Warning] Your Dashboard Analytics Config has maxRetries set to ${config.maxRetries}. Consider increasing this to 5+ in the WEB UI for complex Angular Healing!`);
+        else {
+            const config = result.config;
+            console.log(`[Lisa.ai Agent] Dynamic Config Loaded: Provider=${config.modelProvider}, MaxRetries=${config.maxRetries}`);
+            if (config.maxRetries < 5) {
+                console.warn(`\n⚠️ [Lisa.ai Warning] Your Dashboard Analytics Config has maxRetries set to ${config.maxRetries}. Consider increasing this to 5+ in the WEB UI for complex Angular Healing!`);
+            }
+            model = config.modelProvider;
+            maxRetries = config.maxRetries;
+            apiKey = config.apiKey;
+            // CP Bug 1 fix: the coverage command was missing the autoHealEnabled check.
+            // Without this, a user who disables auto-heal on the control plane dashboard
+            // would still have their tests auto-healed internally via coverageCommand's
+            // fallback to healCommand when tests fail to compile.
+            if (config.autoHealEnabled === false) {
+                console.log(`[Lisa.ai Agent] Auto-heal is disabled by Control Plane.`);
+                process.exit(1);
+            }
         }
-        model = config.modelProvider;
-        maxRetries = config.maxRetries;
-        apiKey = config.apiKey;
     }
     await (0, coverage_1.coverageCommand)(options.command, model, 1, maxRetries, options.projectId || 'local', apiKey);
 });

package/dist/services/config.service.js

@@ -1,22 +1,69 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fetchRemoteConfig = fetchRemoteConfig;
+const path = __importStar(require("path"));
+const dotenv = __importStar(require("dotenv"));
+// CP Bug 3 fix: load .env explicitly so LISA_CONTROL_PLANE_URL is always available
+// regardless of module import order. Previously this relied on llm.service.ts being
+// imported first (a fragile side-effect dependency).
+dotenv.config({ path: path.resolve(__dirname, '../../.env'), quiet: true });
 async function fetchRemoteConfig(projectId) {
     const MASTER_CONTROL_URL = process.env.LISA_CONTROL_PLANE_URL || 'http://localhost:3000';
     try {
         const url = `${MASTER_CONTROL_URL}/api/config/${projectId}`;
         console.log(`[Lisa.ai Agent] Fetching dynamic configuration from ${url}...`);
-        // Using native Node Fetch API available in Node 18+
         const response = await fetch(url);
         if (!response.ok) {
-            console.warn(`[Lisa.ai Agent Warning] Control Plane returned ${response.status}. Falling back to default settings.`);
-            return null;
+            // 404 means the project was never created on the control plane.
+            // Other 4xx/5xx errors are treated as unreachable so the agent can fallback.
+            const reason = response.status === 404 ? 'not_found' : 'unreachable';
+            if (reason === 'not_found') {
+                console.warn(`[Lisa.ai Agent Warning] Control Plane returned 404. Project '${projectId}' not found.`);
+            }
+            else {
+                console.warn(`[Lisa.ai Agent Warning] Control Plane returned ${response.status}. Falling back to local defaults.`);
+            }
+            return { ok: false, reason };
         }
         const config = await response.json();
-        return config;
+        return { ok: true, config };
     }
     catch (error) {
+        // Network-level failure — the control plane is unreachable, not "project not found".
         console.warn(`[Lisa.ai Agent Warning] Failed to reach Control Plane (${MASTER_CONTROL_URL}). Using local fallback configuration.`);
-        return null;
+        return { ok: false, reason: 'unreachable' };
     }
 }

package/dist/services/discovery.service.js

@@ -89,5 +89,53 @@ class AutoDiscoveryService {
         }
         return result;
     }
+    /**
+     * Recursively crawls the project to find source files that lack any corresponding test/spec files.
+     */
+    static findUntestedFiles(dir, skipList = []) {
+        const untested = [];
+        if (!fs.existsSync(dir))
+            return untested;
+        const files = fs.readdirSync(dir);
+        const ignoreDirs = ['node_modules', 'dist', 'build', '.git', '.angular', 'coverage', 'public', 'assets'];
+        const ignoreFiles = ['main.ts', 'index.ts', 'app.config.ts', 'app.routes.ts', 'styles.css', 'styles.scss', 'tailwind.config.js', 'eslint.config.js'];
+        for (const file of files) {
+            const fullPath = path.join(dir, file);
+            if (ignoreDirs.includes(file))
+                continue;
+            let stat;
+            try {
+                stat = fs.statSync(fullPath);
+            }
+            catch (e) {
+                continue;
+            }
+            if (stat.isDirectory()) {
+                untested.push(...this.findUntestedFiles(fullPath, skipList));
+            }
+            else if (file.match(/\.(ts|tsx|js|jsx|vue)$/) && !file.includes('.spec.') && !file.includes('.test.')) {
+                if (ignoreFiles.includes(file))
+                    continue;
+                const ext = path.extname(file);
+                const base = file.slice(0, -ext.length);
+                const possibleSpecs = [
+                    path.join(dir, `${base}.spec${ext}`),
+                    path.join(dir, `${base}.test${ext}`),
+                    path.join(dir, `${base}.spec.js`),
+                    path.join(dir, `${base}.test.js`),
+                    path.join(dir, `${base}.spec.ts`),
+                    path.join(dir, `${base}.test.ts`)
+                ];
+                const hasTest = possibleSpecs.some(p => fs.existsSync(p));
+                if (!hasTest) {
+                    const relativePath = path.relative(process.cwd(), fullPath);
+                    if (!skipList.includes(relativePath)) {
+                        untested.push(relativePath);
+                    }
+                }
+            }
+        }
+        return untested;
+    }
 }
 exports.AutoDiscoveryService = AutoDiscoveryService;

package/dist/services/git.service.js

@@ -13,6 +13,16 @@ async function createPullRequestForHeal(filePath) {
     const timestamp = new Date().getTime();
     const branchName = `lisa-fix/build-error-${timestamp}`;
     const commitMsg = `fix: automated auto-heal by Lisa.ai for ${filePath}`;
+    // Bug 7 fix: capture the current branch BEFORE making any changes so we can reliably
+    // restore it in the finally block. Hardcoding 'main' would leave the repo stuck on a
+    // lisa-fix/ branch for any project that uses 'master' or a custom default branch.
+    let originalBranch = 'main'; // safe fallback
+    try {
+        originalBranch = (await git.revparse(['--abbrev-ref', 'HEAD'])).trim();
+    }
+    catch (e) {
+        // If we can't determine the branch (e.g. detached HEAD), keep the fallback
+    }
     try {
         // 1. Git Config Setup
         await git.addConfig('user.name', 'Lisa.ai');
@@ -43,7 +53,9 @@ This PR was automatically generated by Lisa.ai to resolve a failing compilation/
 
 Please review the changes.`,
                 head: branchName,
-                base: 'main', // Hardcoding main, could be dynamic
+                // Bug 7 fix: use the branch that was active before we created the heal branch
+                // rather than the hardcoded 'main' string.
+                base: originalBranch,
             });
             console.log(`✅ [Lisa.ai PR Engine] Pull Request created successfully: ${pr.data.html_url}`);
         }
@@ -55,9 +67,9 @@ Please review the changes.`,
         console.error(`\n🚨 [Lisa.ai PR Engine Error] Failed to create Pull Request:`, error.message);
     }
     finally {
-        // Switch back to original branch so we don't leave the user in a detached state locally
+        // Bug 7 fix: restore to the originally detected branch, not a hardcoded 'main'.
         try {
-            await git.checkout('main'); // assumes main is the default, ideally parse current branch beforehand
+            await git.checkout(originalBranch);
         }
         catch (e) {
             // Ignore checkout cleanup error

package/dist/services/llm.service.js

@@ -43,19 +43,22 @@ const anthropic_1 = require("@ai-sdk/anthropic");
 const google_1 = require("@ai-sdk/google");
 const path = __importStar(require("path"));
 const dotenv = __importStar(require("dotenv"));
-dotenv.config({ path: path.resolve(__dirname, '../../.env') });
+dotenv.config({ path: path.resolve(__dirname, '../../.env'), quiet: true });
 function getProvider(provider, apiKey) {
     if (provider === 'claude') {
         const key = apiKey || process.env.ANTHROPIC_API_KEY;
         if (!key)
             throw new Error('No Anthropic API key provided by local ENV or Control Plane');
-        return (0, anthropic_1.createAnthropic)({ apiKey: key })('claude-3-haiku-20240307');
+        // Bug 2 fix: claude-3-haiku is too weak for complex DI/module fixes.
+        // claude-3-5-sonnet is significantly better at understanding Angular/React test scaffolding.
+        return (0, anthropic_1.createAnthropic)({ apiKey: key })('claude-3-5-sonnet-20241022');
     }
     if (provider === 'openai') {
         const key = apiKey || process.env.OPENAI_API_KEY;
         if (!key)
             throw new Error('No OpenAI API key provided by local ENV or Control Plane');
-        return (0, openai_1.createOpenAI)({ apiKey: key })('gpt-3.5-turbo');
+        // Bug 2 fix: gpt-3.5-turbo is deprecated and produces low-quality code fixes.
+        return (0, openai_1.createOpenAI)({ apiKey: key })('gpt-4o-mini');
     }
     const key = apiKey || process.env.GOOGLE_GENERATIVE_AI_API_KEY;
     if (!key)
@@ -105,19 +108,28 @@ async function askLisaForFix(filePath, fileContent, errorLog, modelProvider, api
         model,
         prompt,
     });
-    const match = text.match(/```(?:typescript|ts)?\n([\s\S]*?)```/);
+    // Bug 1 fix: handle javascript/js code blocks in addition to typescript/ts.
+    // Without this, JS file fixes from the LLM using ```javascript blocks are not extracted —
+    // the raw markdown (including ``` markers) gets written to disk, permanently corrupting the file.
+    const match = text.match(/```(?:typescript|ts|javascript|js)?\n([\s\S]*?)```/);
     return match ? match[1].trim() : text.trim();
 }
-async function generateTestForFile(sourceFilePath, sourceFileContent, modelProvider, apiKey) {
+async function generateTestForFile(sourceFilePath, sourceFileContent, modelProvider, apiKey, framework) {
     console.log(`[Lisa.ai Coverage] Requesting test generation from ${modelProvider} for ${sourceFilePath}...`);
     const model = getProvider(modelProvider, apiKey);
+    // Bug 3 fix: include the detected testing framework in the prompt so the LLM doesn't
+    // randomly pick Jest syntax for a Karma project (or vice-versa), causing immediate
+    // compile failures that trigger an unnecessary heal loop.
+    const frameworkInstruction = framework
+        ? `3. You MUST use the '${framework}' testing framework exclusively. All imports, describe/it/test blocks, and mock utilities must follow '${framework}' conventions.\n`
+        : "3. Include all necessary imports assuming a standard testing framework (Jest/Karma/Vitest) is available.\n";
     const prompt = "You are Lisa.ai, an autonomous CI/CD expert platform.\n" +
         "A source file lacks 100% test coverage. Your task is to generate a comprehensive testing suite covering all branches, lines, and functions.\n\n" +
         "--- Target File Content (" + sourceFilePath + ") ---\n" + sourceFileContent + "\n\n" +
         "--- Constraints ---\n" +
         "1. Return the generated test code wrapped in a markdown code block (```typescript ... ```).\n" +
         "2. Do not include any explanation or intro text.\n" +
-        "3. Include all necessary imports assuming a standard testing framework (Jest/Karma/Vitest) is available.\n" +
+        frameworkInstruction +
         "4. Aim for 100% logic coverage.";
     const { text } = await (0, ai_1.generateText)({
         model,
@@ -126,9 +138,14 @@ async function generateTestForFile(sourceFilePath, sourceFileContent, modelProvi
     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) {
+async function updateTestForFile(sourceFilePath, sourceFileContent, testFilePath, existingTestContent, modelProvider, apiKey, framework) {
     console.log(`[Lisa.ai Coverage] Requesting test update from ${modelProvider} for ${sourceFilePath}...`);
     const model = getProvider(modelProvider, apiKey);
+    // Bug 3 fix: same as generateTestForFile — specify the framework so updates
+    // don't introduce incompatible syntax into an existing test suite.
+    const frameworkInstruction = framework
+        ? `3. You MUST use the '${framework}' testing framework exclusively. All new tests must follow '${framework}' conventions and integrate cleanly with the existing suite.\n`
+        : "3. Append missing tests to the existing suite. Do not delete existing passing tests unless they are fundamentally broken.\n";
     const prompt = "You are Lisa.ai, an autonomous CI/CD expert platform.\n" +
         "A source file lacks 100% test coverage. You must update its existing test suite to achieve full coverage.\n\n" +
         "--- Target File Content (" + sourceFilePath + ") ---\n" + sourceFileContent + "\n\n" +
@@ -136,7 +153,7 @@ async function updateTestForFile(sourceFilePath, sourceFileContent, testFilePath
         "--- Constraints ---\n" +
         "1. Return the updated complete test code wrapped in a markdown code block (```typescript ... ```).\n" +
         "2. Do not include any explanation or intro text.\n" +
-        "3. Append missing tests to the existing suite. Do not delete existing passing tests unless they are fundamentally broken.\n" +
+        frameworkInstruction +
         "4. Aim for 100% logic coverage across branches, lines, and functions.";
     const { text } = await (0, ai_1.generateText)({
         model,

package/dist/services/telemetry.service.js

@@ -1,21 +1,60 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.reportTelemetry = reportTelemetry;
+const path = __importStar(require("path"));
+const dotenv = __importStar(require("dotenv"));
+// CP Bug 3 fix: load .env explicitly so LISA_CONTROL_PLANE_URL is always available.
+dotenv.config({ path: path.resolve(__dirname, '../../.env'), quiet: true });
 async function reportTelemetry(event) {
     const MASTER_CONTROL_URL = process.env.LISA_CONTROL_PLANE_URL || 'http://localhost:3000';
-    try {
-        const url = `${MASTER_CONTROL_URL}/api/telemetry`;
-        // Fire and forget, don't block the compilation thread heavily
-        await fetch(url, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json'
-            },
-            body: JSON.stringify(event)
-        });
-    }
-    catch (error) {
+    const url = `${MASTER_CONTROL_URL}/api/telemetry`;
+    // Telemetry Bug 1 fix: true fire-and-forget — attach a .catch() handler and return immediately.
+    // The previous `await fetch(...)` contradicted the "don't block" comment: with 3 telemetry
+    // calls per file and 50+ files in a large project, the heal loop was silently waiting for
+    // 150+ network round-trips before doing any actual work.
+    // Keeping the function signature as async+Promise<void> means existing `await reportTelemetry()`
+    // callsites continue to compile without change — they just resolve instantly now.
+    fetch(url, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json'
+        },
+        body: JSON.stringify(event)
+    }).catch((error) => {
         // Silently fail if control plane is down so agent can still work detached
         console.debug(`[Lisa.ai Agent Debug] Failed to report telemetry: ${error.message}`);
-    }
+    });
 }

package/dist/utils/parser.js

@@ -49,6 +49,11 @@ function extractFilePath(errorLog, skipFiles = [], searchDir = process.cwd()) {
     while ((match = exactErrorRegex.exec(cleanLog)) !== null) {
         const foundPath = match[1];
         if (foundPath) {
+            // Bug 4 fix: skip paths that live inside node_modules or build output directories.
+            // Without this check a non-scoped package path (e.g. node_modules/jest-config/build/index.js)
+            // satisfies the regex AND exists on disk, so Lisa would attempt to "heal" a library file.
+            if (/[/\\](node_modules|dist|build)[/\\]/.test(foundPath))
+                continue;
             const absoluteFoundPath = path.isAbsolute(foundPath) ? foundPath : path.resolve(searchDir, foundPath);
             if (!normalizedSkips.includes(absoluteFoundPath) && fs.existsSync(absoluteFoundPath)) {
                 return foundPath;
@@ -72,6 +77,9 @@ function extractFilePath(errorLog, skipFiles = [], searchDir = process.cwd()) {
     while ((fallbackMatch = fallbackRegex.exec(cleanLog)) !== null) {
         const foundPath = fallbackMatch[1];
         if (foundPath) {
+            // Bug 4 fix: same node_modules/dist guard as pass 1.
+            if (/[/\\](node_modules|dist|build)[/\\]/.test(foundPath))
+                continue;
             const absoluteFoundPath = path.isAbsolute(foundPath) ? foundPath : path.resolve(searchDir, foundPath);
             if (!normalizedSkips.includes(absoluteFoundPath) && fs.existsSync(absoluteFoundPath)) {
                 return foundPath;

package/package.json

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