@lisa.ai/agent 1.0.0

package/README.md

@@ -0,0 +1,33 @@
+# @lisa.ai/agent
+
+The **Lisa.ai Worker Agent** is an autonomous CI/CD sidecar that hooks into your standard build and test scripts. Powered by a configurable OODA loop (Observe, Orient, Decide, Act), it detects compile failures and logic coverage gaps and acts on them.
+
+## Installation
+
+```bash
+npm install -g @lisa.ai/agent
+# or
+npm install --save-dev @lisa.ai/agent
+```
+
+## Quick Start
+
+### Auto-Heal a Failing Build
+Wrap your existing broken build script with `lisa-agent heal` and pass your Project ID. The agent will execute your script, pipe the runtime errors securely to an LLM provider (like Claude or Gemini), apply the patch, and recursively verify!
+
+```bash
+npx lisa-agent heal --command="npm run build" --model="claude" --project-id="demo-123"
+```
+
+### Continuous 100% Test Generation
+Wrap your testing script with `lisa-agent coverage` (assuming it generates Istanbul/Jest JSON summaries). The agent will query the AST of files lacking coverage and autonomously generate functioning unit tests.
+
+```bash
+npx lisa-agent coverage --command="npm run test" --model="gemini" --project-id="demo-123"
+```
+
+## Dashboard Telemetry
+This agent natively links to the Lisa.ai Control Plane and Telemetry UI via your `--project-id`.
+
+---
+*Created by the Lisa.ai Platform team.*

package/dist/commands/coverage.js

@@ -0,0 +1,105 @@
+"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.coverageCommand = coverageCommand;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const coverage_parser_1 = require("../utils/coverage.parser");
+const llm_service_1 = require("../services/llm.service");
+const heal_1 = require("./heal");
+const telemetry_service_1 = require("../services/telemetry.service");
+async function coverageCommand(command, modelProvider, attempt = 1, maxRetries = 3, projectId = 'local') {
+    console.log(`\n[Lisa.ai Coverage] ${command} (Attempt ${attempt}/${maxRetries}) Using Model: ${modelProvider}`);
+    let executionPassed = true;
+    try {
+        // 1. Run the test command which should ideally produce coverage-summary.json
+        const output = (0, child_process_1.execSync)(command, { encoding: 'utf-8', stdio: 'pipe' });
+        console.log(output);
+        console.log(`\n✅ [Lisa.ai Coverage] Tests passed successfully on attempt ${attempt}.`);
+    }
+    catch (error) {
+        console.log(`\n❌ [Lisa.ai Coverage] Tests failed. Delegating to Auto-Heal...`);
+        // If tests themselves fail to compile or run, we fallback exactly to auto-heal
+        // We intentionally don't loop here immediately, but await healCommand.
+        await (0, heal_1.healCommand)(command, modelProvider, attempt, null, maxRetries, projectId);
+        executionPassed = false;
+    }
+    // 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.`);
+                return;
+            }
+            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
+            }
+            if (attempt >= maxRetries) {
+                console.error(`\n🚨 [Lisa.ai Error] Max coverage retries (${maxRetries}) reached with remaining gaps. Auto-generation limits exceeded.`);
+                process.exit(1);
+            }
+            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);
+            // 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}`);
+            await (0, telemetry_service_1.reportTelemetry)({
+                projectId,
+                type: 'coverage',
+                filePath: targetFilePath,
+                modelUsed: modelProvider,
+                status: 'success'
+            });
+            // 4. Recursive iteration to verify newly written test and hunt for next gap
+            await coverageCommand(command, modelProvider, attempt + 1, maxRetries, projectId);
+        }
+        catch (e) {
+            console.error(`[Lisa.ai Coverage loop failure]:`, e.message);
+        }
+    }
+}

package/dist/commands/heal.js

@@ -0,0 +1,97 @@
+"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.healCommand = healCommand;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+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");
+async function healCommand(command, modelProvider, attempt = 1, healedFilePath = null, maxRetries = 3, projectId = 'local') {
+    console.log(`\n[Lisa.ai Executing] ${command} (Attempt ${attempt}/${maxRetries}) 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
+        if (healedFilePath) {
+            await (0, telemetry_service_1.reportTelemetry)({
+                projectId,
+                type: 'heal',
+                filePath: healedFilePath,
+                modelUsed: modelProvider,
+                status: 'success'
+            });
+            await (0, git_service_1.createPullRequestForHeal)(healedFilePath);
+        }
+    }
+    catch (error) {
+        console.log(`\n❌ [Lisa.ai Failure] Command failed.`);
+        // Combine logs
+        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);
+        if (!filePath) {
+            console.error(`\n🚨 [Lisa.ai Error] Could not parse a valid failing file path from the logs.`);
+            process.exit(1);
+        }
+        const absolutePath = path.resolve(process.cwd(), filePath);
+        if (!fs.existsSync(absolutePath)) {
+            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');
+        // Call LLM for a fix
+        const fixedCode = await (0, llm_service_1.askLisaForFix)(filePath, fileContent, errorLog, modelProvider);
+        // Write the fix to the file
+        fs.writeFileSync(absolutePath, fixedCode, 'utf-8');
+        console.log(`[Lisa.ai Auto-Heal] Applied patch to ${filePath}`);
+        // Recursive retry, passing the healed file path state
+        await healCommand(command, modelProvider, attempt + 1, filePath, maxRetries, projectId);
+    }
+}

package/dist/index.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 program = new commander_1.Command();
+program
+    .name('lisa-agent')
+    .description('Lisa.ai - Autonomous CI/CD Platform Worker Agent')
+    .version('1.0.0');
+program
+    .command('heal')
+    .description('Run a command and autonomously heal errors')
+    .requiredOption('-c, --command <type>', 'Command to execute (e.g. "ng build")')
+    .option('-m, --model <provider>', 'LLM provider to use (gemini, claude, openai)', 'gemini')
+    .option('-p, --project-id <id>', 'Control Plane Project ID to fetch dynamic config')
+    .action(async (options) => {
+    let maxRetries = 3;
+    let model = options.model;
+    if (options.projectId) {
+        const config = await (0, config_service_1.fetchRemoteConfig)(options.projectId);
+        if (config) {
+            console.log(`[Lisa.ai Agent] Dynamic Config Loaded: Provider=${config.modelProvider}, MaxRetries=${config.maxRetries}`);
+            model = config.modelProvider;
+            maxRetries = config.maxRetries;
+            if (config.autoHealEnabled === false) {
+                console.log(`[Lisa.ai Agent] Auto-heal is disabled by Control Plane.`);
+                process.exit(1);
+            }
+        }
+    }
+    (0, heal_1.healCommand)(options.command, model, 1, null, maxRetries, options.projectId || 'local');
+});
+program
+    .command('coverage')
+    .description('Run test command dynamically generating missing specs for 100% coverage')
+    .requiredOption('-c, --command <type>', 'Test command to execute (e.g. "npm run test")')
+    .option('-m, --model <provider>', 'LLM provider to use (gemini, claude, openai)', 'gemini')
+    .option('-p, --project-id <id>', 'Control Plane Project ID to fetch dynamic config')
+    .action(async (options) => {
+    let maxRetries = 3;
+    let model = options.model;
+    if (options.projectId) {
+        const config = await (0, config_service_1.fetchRemoteConfig)(options.projectId);
+        if (config) {
+            console.log(`[Lisa.ai Agent] Dynamic Config Loaded: Provider=${config.modelProvider}, MaxRetries=${config.maxRetries}`);
+            model = config.modelProvider;
+            maxRetries = config.maxRetries;
+        }
+    }
+    (0, coverage_1.coverageCommand)(options.command, model, 1, maxRetries, options.projectId || 'local');
+});
+program.parse(process.argv);

package/dist/services/config.service.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchRemoteConfig = fetchRemoteConfig;
+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;
+        }
+        const config = await response.json();
+        return config;
+    }
+    catch (error) {
+        console.warn(`[Lisa.ai Agent Warning] Failed to reach Control Plane (${MASTER_CONTROL_URL}). Using local fallback configuration.`);
+        return null;
+    }
+}

package/dist/services/git.service.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPullRequestForHeal = createPullRequestForHeal;
+const simple_git_1 = __importDefault(require("simple-git"));
+const rest_1 = require("@octokit/rest");
+require("dotenv/config");
+async function createPullRequestForHeal(filePath) {
+    console.log(`\n[Lisa.ai PR Engine] Initializing Pull Request for ${filePath}...`);
+    const git = (0, simple_git_1.default)();
+    const timestamp = new Date().getTime();
+    const branchName = `lisa-fix/build-error-${timestamp}`;
+    const commitMsg = `fix: automated auto-heal by Lisa.ai for ${filePath}`;
+    try {
+        // 1. Git Config Setup
+        await git.addConfig('user.name', 'Lisa.ai');
+        await git.addConfig('user.email', 'lisa@lisa.ai');
+        // 2. Branch and Commit
+        await git.checkoutLocalBranch(branchName);
+        await git.add(filePath);
+        await git.commit(commitMsg);
+        console.log(`[Lisa.ai PR Engine] Committed changes to branch ${branchName}`);
+        // 3. Optional Push to origin. We need a remote to open a PR.
+        // If no remote exists, this will fail gracefully or we catch it.
+        console.log(`[Lisa.ai PR Engine] Pushing branch to remote origin...`);
+        await git.push('origin', branchName, { '--set-upstream': null });
+        // 4. Open PR via Octokit
+        const octokit = new rest_1.Octokit({ auth: process.env.GITHUB_TOKEN });
+        const repoInfoStr = process.env.GITHUB_REPOSITORY; // e.g., "owner/repo"
+        if (repoInfoStr && process.env.GITHUB_TOKEN) {
+            const [owner, repo] = repoInfoStr.split('/');
+            console.log(`[Lisa.ai PR Engine] Opening Pull Request against ${owner}/${repo}...`);
+            const pr = await octokit.rest.pulls.create({
+                owner,
+                repo,
+                title: commitMsg,
+                body: `### Lisa.ai Auto-Healed Pull Request
+This PR was automatically generated by Lisa.ai to resolve a failing compilation/build step.
+
+**Healed File:** \`${filePath}\`
+
+Please review the changes.`,
+                head: branchName,
+                base: 'main', // Hardcoding main, could be dynamic
+            });
+            console.log(`✅ [Lisa.ai PR Engine] Pull Request created successfully: ${pr.data.html_url}`);
+        }
+        else {
+            console.log(`⚠️ [Lisa.ai PR Engine] GITHUB_TOKEN or GITHUB_REPOSITORY not set. Skipping GitHub Pull Request creation.`);
+        }
+    }
+    catch (error) {
+        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
+        try {
+            await git.checkout('main'); // assumes main is the default, ideally parse current branch beforehand
+        }
+        catch (e) {
+            // Ignore checkout cleanup error
+        }
+    }
+}

package/dist/services/llm.service.js

@@ -0,0 +1,124 @@
+"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.askLisaForFix = askLisaForFix;
+exports.generateTestForFile = generateTestForFile;
+const ai_1 = require("ai");
+const openai_1 = require("@ai-sdk/openai");
+const anthropic_1 = require("@ai-sdk/anthropic");
+const google_1 = require("@ai-sdk/google");
+const path = __importStar(require("path"));
+require("dotenv/config");
+async function askLisaForFix(filePath, fileContent, errorLog, modelProvider) {
+    console.log(`[Lisa.ai Auto-Heal] Requesting fix from ${modelProvider} for ${filePath}...`);
+    let model;
+    switch (modelProvider) {
+        case 'openai':
+            model = (0, openai_1.openai)('gpt-4o');
+            break;
+        case 'claude':
+            model = (0, anthropic_1.anthropic)('claude-3-haiku-20240307');
+            break;
+        case 'gemini':
+            model = (0, google_1.google)('gemini-1.5-pro-latest');
+            break;
+        default:
+            console.warn(`[Lisa.ai Warning] Unrecognized modelProvider '${modelProvider}', defaulting to 'gemini'`);
+            model = (0, google_1.google)('gemini-1.5-pro-latest');
+            break;
+    }
+    const prompt = `You are Lisa.ai, an autonomous CI/CD expert platform.
+A build/compilation error occurred. Your task is to fix the provided file so that the error resolves.
+
+--- Error Log ---
+${errorLog}
+
+--- Target File Content (${filePath}) ---
+${fileContent}
+
+--- Constraints ---
+1. Do not delete business logic.
+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. Return ONLY the raw, fixed code without markdown backticks. Do not include any explanation or intro text.`;
+    // Provide a mock bypass if keys are not present to test the Git loop
+    if (!process.env.GOOGLE_GENERATIVE_AI_API_KEY && !process.env.OPENAI_API_KEY && !process.env.ANTHROPIC_API_KEY) {
+        console.log(`[Lisa.ai Warning] No API keys found in environment. Using mock LLM fix for testing.`);
+        return `const missingImportStr: string = "42";\nconsole.log(missingImportStr);\n`;
+    }
+    const { text } = await (0, ai_1.generateText)({
+        model,
+        prompt,
+    });
+    return text.trim();
+}
+async function generateTestForFile(sourceFilePath, sourceFileContent, modelProvider) {
+    console.log(`[Lisa.ai Coverage] Requesting test generation from ${modelProvider} for ${sourceFilePath}...`);
+    let model;
+    switch (modelProvider) {
+        case 'openai':
+            model = (0, openai_1.openai)('gpt-4o');
+            break;
+        case 'claude':
+            model = (0, anthropic_1.anthropic)('claude-3-haiku-20240307');
+            break;
+        case 'gemini':
+            model = (0, google_1.google)('gemini-1.5-pro-latest');
+            break;
+        default:
+            model = (0, google_1.google)('gemini-1.5-pro-latest');
+            break;
+    }
+    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.
+
+--- Target File Content (${sourceFilePath}) ---
+${sourceFileContent}
+
+--- Constraints ---
+1. Return ONLY the raw, generated TypeScript test code.
+2. Do not include markdown formatting backticks \`\`\`.
+3. Include all necessary imports assuming Jest is available.
+4. Aim for 100% logic coverage.`;
+    // Provide a mock bypass if keys are not present
+    if (!process.env.GOOGLE_GENERATIVE_AI_API_KEY && !process.env.OPENAI_API_KEY && !process.env.ANTHROPIC_API_KEY) {
+        return `import { something } from './${path.basename(sourceFilePath, '.ts')}';\n\ndescribe('Auto-Generated Test', () => { \n  it('should pass dynamically', () => { \n    expect(true).toBe(true); \n  }); \n});\n`;
+    }
+    const { text } = await (0, ai_1.generateText)({
+        model,
+        prompt,
+    });
+    return text.trim();
+}

package/dist/services/telemetry.service.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reportTelemetry = reportTelemetry;
+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) {
+        // 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/coverage.parser.js

@@ -0,0 +1,59 @@
+"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.parseCoverageSummary = parseCoverageSummary;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function parseCoverageSummary(coverageFilePath) {
+    const absolutePath = path.resolve(process.cwd(), coverageFilePath);
+    if (!fs.existsSync(absolutePath)) {
+        throw new Error(`[Lisa.ai Coverage Error] Coverage file not found at ${absolutePath}`);
+    }
+    const rawData = fs.readFileSync(absolutePath, 'utf-8');
+    const summary = JSON.parse(rawData);
+    const uncoveredFiles = [];
+    for (const [file, metrics] of Object.entries(summary)) {
+        if (file === 'total')
+            continue;
+        // Check if any metric is below 100%
+        if (metrics.lines.pct < 100 ||
+            metrics.statements.pct < 100 ||
+            metrics.functions.pct < 100 ||
+            metrics.branches.pct < 100) {
+            uncoveredFiles.push(file);
+        }
+    }
+    return uncoveredFiles;
+}

package/dist/utils/math.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MathUtils = void 0;
+class MathUtils {
+    static add(a, b) {
+        return a + b;
+    }
+}
+exports.MathUtils = MathUtils;

package/dist/utils/math.spec.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const math_1 = require("./math");
+describe('MathUtils', () => {
+    describe('add', () => {
+        it('should add two positive numbers', () => {
+            expect(math_1.MathUtils.add(2, 3)).toBe(5);
+        });
+        it('should add two negative numbers', () => {
+            expect(math_1.MathUtils.add(-2, -3)).toBe(-5);
+        });
+        it('should add a positive and a negative number', () => {
+            expect(math_1.MathUtils.add(2, -3)).toBe(-1);
+        });
+        it('should add zero to a number', () => {
+            expect(math_1.MathUtils.add(2, 0)).toBe(2);
+        });
+    });
+});

package/dist/utils/parser.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractFilePath = extractFilePath;
+function extractFilePath(errorLog) {
+    // Matches typical TS/Angular error patterns:
+    // e.g., "src/app/app.component.ts:12:3 - error TS2322:"
+    // e.g., "Error: src/app/app.component.ts:12:3"
+    // Try to match path near an error
+    const tsErrorRegex = /([a-zA-Z0-9_.\-\/\\]+\.ts)(?:[:(])/;
+    const match = tsErrorRegex.exec(errorLog);
+    if (match && match[1]) {
+        return match[1];
+    }
+    // Fallback: Just try to find anything that looks like a .ts file path
+    const fallbackRegex = /([a-zA-Z0-9_.\-\/\\]+\.ts)/;
+    const fallbackMatch = fallbackRegex.exec(errorLog);
+    return fallbackMatch ? fallbackMatch[1] : null;
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@lisa.ai/agent",
+  "version": "1.0.0",
+  "description": "Lisa.ai Autonomous CI/CD Worker Agent",
+  "main": "dist/index.js",
+  "bin": {
+    "lisa-agent": "dist/index.js"
+  },
+  "files": [
+    "dist/"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "ts-node src/index.ts"
+  },
+  "keywords": [
+    "lisa",
+    "ci",
+    "cd",
+    "agent"
+  ],
+  "author": "Lisa.ai",
+  "license": "ISC",
+  "dependencies": {
+    "@ai-sdk/anthropic": "^3.0.46",
+    "@ai-sdk/google": "^3.0.30",
+    "@ai-sdk/openai": "^3.0.30",
+    "@octokit/rest": "^22.0.1",
+    "ai": "^6.0.94",
+    "commander": "^11.1.0",
+    "dotenv": "^17.3.1",
+    "simple-git": "^3.31.1"
+  },
+  "devDependencies": {
+    "@types/jest": "^30.0.0",
+    "@types/node": "^20.0.0",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.0.0"
+  }
+}