kynjal-cli 3.1.3 → 4.0.0

package/dist/src/services/headless-worker-executor.js

@@ -18,6 +18,77 @@
  * - Execution logging for debugging
  * - Event emission for monitoring
  */
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 import { spawn, execSync } from 'child_process';
 import { EventEmitter } from 'events';
 import { existsSync, readFileSync, readdirSync, mkdirSync, writeFileSync } from 'fs';
@@ -28,7 +99,7 @@ import { join } from 'path';
 /**
  * Array of headless worker types for runtime checking
  */
-export const HEADLESS_WORKER_TYPES = [
+export var HEADLESS_WORKER_TYPES = [
     'audit',
     'optimize',
     'testgaps',
@@ -41,7 +112,7 @@ export const HEADLESS_WORKER_TYPES = [
 /**
  * Array of local worker types
  */
-export const LOCAL_WORKER_TYPES = [
+export var LOCAL_WORKER_TYPES = [
     'map',
     'consolidate',
     'benchmark',
@@ -50,15 +121,15 @@ export const LOCAL_WORKER_TYPES = [
 /**
  * Model ID mapping
  */
-const MODEL_IDS = {
+var MODEL_IDS = {
     sonnet: 'claude-sonnet-4-5-20250929',
     opus: 'claude-opus-4-6',
-    haiku: 'claude-haiku-4-5-20251001',
+    haiku: 'claude-haiku-4-5-20251001'
 };
 /**
  * Default headless worker configurations based on ADR-020
  */
-export const HEADLESS_WORKER_CONFIGS = {
+export var HEADLESS_WORKER_CONFIGS = {
     audit: {
         type: 'audit',
         mode: 'headless',
@@ -67,25 +138,13 @@ export const HEADLESS_WORKER_CONFIGS = {
         description: 'AI-powered security analysis',
         enabled: true,
         headless: {
-            promptTemplate: `Analyze this codebase for security vulnerabilities:
-- Check for hardcoded secrets (API keys, passwords)
-- Identify SQL injection risks
-- Find XSS vulnerabilities
-- Check for insecure dependencies
-- Identify authentication/authorization issues
-
-Provide a JSON report with:
-{
-  "vulnerabilities": [{ "severity": "high|medium|low", "file": "...", "line": N, "description": "..." }],
-  "riskScore": 0-100,
-  "recommendations": ["..."]
-}`,
+            promptTemplate: "Analyze this codebase for security vulnerabilities:\n- Check for hardcoded secrets (API keys, passwords)\n- Identify SQL injection risks\n- Find XSS vulnerabilities\n- Check for insecure dependencies\n- Identify authentication/authorization issues\n\nProvide a JSON report with:\n{\n  \"vulnerabilities\": [{ \"severity\": \"high|medium|low\", \"file\": \"...\", \"line\": N, \"description\": \"...\" }],\n  \"riskScore\": 0-100,\n  \"recommendations\": [\"...\"]\n}",
             sandbox: 'strict',
             model: 'haiku',
             outputFormat: 'json',
             contextPatterns: ['**/*.ts', '**/*.js', '**/.env*', '**/package.json'],
-            timeoutMs: 5 * 60 * 1000,
-        },
+            timeoutMs: 5 * 60 * 1000
+        }
     },
     optimize: {
         type: 'optimize',
@@ -95,20 +154,13 @@ Provide a JSON report with:
         description: 'AI optimization suggestions',
         enabled: true,
         headless: {
-            promptTemplate: `Analyze this codebase for performance optimizations:
-- Identify N+1 query patterns
-- Find unnecessary re-renders in React
-- Suggest caching opportunities
-- Identify memory leaks
-- Find redundant computations
-
-Provide actionable suggestions with code examples.`,
+            promptTemplate: "Analyze this codebase for performance optimizations:\n- Identify N+1 query patterns\n- Find unnecessary re-renders in React\n- Suggest caching opportunities\n- Identify memory leaks\n- Find redundant computations\n\nProvide actionable suggestions with code examples.",
             sandbox: 'permissive',
             model: 'sonnet',
             outputFormat: 'markdown',
             contextPatterns: ['src/**/*.ts', 'src/**/*.tsx'],
-            timeoutMs: 10 * 60 * 1000,
-        },
+            timeoutMs: 10 * 60 * 1000
+        }
     },
     testgaps: {
         type: 'testgaps',
@@ -118,20 +170,13 @@ Provide actionable suggestions with code examples.`,
         description: 'AI test gap analysis',
         enabled: true,
         headless: {
-            promptTemplate: `Analyze test coverage and identify gaps:
-- Find untested functions and classes
-- Identify edge cases not covered
-- Suggest new test scenarios
-- Check for missing error handling tests
-- Identify integration test gaps
-
-For each gap, provide a test skeleton.`,
+            promptTemplate: "Analyze test coverage and identify gaps:\n- Find untested functions and classes\n- Identify edge cases not covered\n- Suggest new test scenarios\n- Check for missing error handling tests\n- Identify integration test gaps\n\nFor each gap, provide a test skeleton.",
             sandbox: 'permissive',
             model: 'sonnet',
             outputFormat: 'markdown',
             contextPatterns: ['src/**/*.ts', 'tests/**/*.ts', '__tests__/**/*.ts'],
-            timeoutMs: 10 * 60 * 1000,
-        },
+            timeoutMs: 10 * 60 * 1000
+        }
     },
     document: {
         type: 'document',
@@ -141,95 +186,61 @@ For each gap, provide a test skeleton.`,
         description: 'AI documentation generation',
         enabled: false,
         headless: {
-            promptTemplate: `Generate documentation for undocumented code:
-- Add JSDoc comments to functions
-- Create README sections for modules
-- Document API endpoints
-- Add inline comments for complex logic
-- Generate usage examples
-
-Focus on public APIs and exported functions.`,
+            promptTemplate: "Generate documentation for undocumented code:\n- Add JSDoc comments to functions\n- Create README sections for modules\n- Document API endpoints\n- Add inline comments for complex logic\n- Generate usage examples\n\nFocus on public APIs and exported functions.",
             sandbox: 'permissive',
             model: 'haiku',
             outputFormat: 'markdown',
             contextPatterns: ['src/**/*.ts'],
-            timeoutMs: 10 * 60 * 1000,
-        },
+            timeoutMs: 10 * 60 * 1000
+        }
     },
     ultralearn: {
         type: 'ultralearn',
         mode: 'headless',
-        intervalMs: 0, // Manual trigger only
+        intervalMs: 0,
         priority: 'normal',
         description: 'Deep knowledge acquisition',
         enabled: false,
         headless: {
-            promptTemplate: `Deeply analyze this codebase to learn:
-- Architectural patterns used
-- Coding conventions
-- Domain-specific terminology
-- Common patterns and idioms
-- Team preferences
-
-Provide insights as JSON:
-{
-  "architecture": { "patterns": [...], "style": "..." },
-  "conventions": { "naming": "...", "formatting": "..." },
-  "domains": ["..."],
-  "insights": ["..."]
-}`,
+            promptTemplate: "Deeply analyze this codebase to learn:\n- Architectural patterns used\n- Coding conventions\n- Domain-specific terminology\n- Common patterns and idioms\n- Team preferences\n\nProvide insights as JSON:\n{\n  \"architecture\": { \"patterns\": [...], \"style\": \"...\" },\n  \"conventions\": { \"naming\": \"...\", \"formatting\": \"...\" },\n  \"domains\": [\"...\"],\n  \"insights\": [\"...\"]\n}",
             sandbox: 'strict',
             model: 'opus',
             outputFormat: 'json',
             contextPatterns: ['**/*.ts', '**/CLAUDE.md', '**/README.md'],
-            timeoutMs: 15 * 60 * 1000,
-        },
+            timeoutMs: 15 * 60 * 1000
+        }
     },
     refactor: {
         type: 'refactor',
         mode: 'headless',
-        intervalMs: 0, // Manual trigger only
+        intervalMs: 0,
         priority: 'normal',
         description: 'AI refactoring suggestions',
         enabled: false,
         headless: {
-            promptTemplate: `Suggest refactoring opportunities:
-- Identify code duplication
-- Suggest better abstractions
-- Find opportunities for design patterns
-- Identify overly complex functions
-- Suggest module reorganization
-
-Provide before/after code examples.`,
+            promptTemplate: "Suggest refactoring opportunities:\n- Identify code duplication\n- Suggest better abstractions\n- Find opportunities for design patterns\n- Identify overly complex functions\n- Suggest module reorganization\n\nProvide before/after code examples.",
             sandbox: 'permissive',
             model: 'sonnet',
             outputFormat: 'markdown',
             contextPatterns: ['src/**/*.ts'],
-            timeoutMs: 10 * 60 * 1000,
-        },
+            timeoutMs: 10 * 60 * 1000
+        }
     },
     deepdive: {
         type: 'deepdive',
         mode: 'headless',
-        intervalMs: 0, // Manual trigger only
+        intervalMs: 0,
         priority: 'normal',
         description: 'Deep code analysis',
         enabled: false,
         headless: {
-            promptTemplate: `Perform deep analysis of this codebase:
-- Understand data flow
-- Map dependencies
-- Identify architectural issues
-- Find potential bugs
-- Analyze error handling
-
-Provide comprehensive report.`,
+            promptTemplate: "Perform deep analysis of this codebase:\n- Understand data flow\n- Map dependencies\n- Identify architectural issues\n- Find potential bugs\n- Analyze error handling\n\nProvide comprehensive report.",
             sandbox: 'strict',
             model: 'opus',
             outputFormat: 'markdown',
             contextPatterns: ['src/**/*.ts'],
-            timeoutMs: 15 * 60 * 1000,
-        },
+            timeoutMs: 15 * 60 * 1000
+        }
     },
     predict: {
         type: 'predict',
@@ -239,38 +250,26 @@ Provide comprehensive report.`,
         description: 'Predictive preloading',
         enabled: false,
         headless: {
-            promptTemplate: `Based on recent activity, predict what the developer needs:
-- Files likely to be edited next
-- Tests that should be run
-- Documentation to reference
-- Dependencies to check
-
-Provide preload suggestions as JSON:
-{
-  "filesToPreload": ["..."],
-  "testsToRun": ["..."],
-  "docsToReference": ["..."],
-  "confidence": 0.0-1.0
-}`,
+            promptTemplate: "Based on recent activity, predict what the developer needs:\n- Files likely to be edited next\n- Tests that should be run\n- Documentation to reference\n- Dependencies to check\n\nProvide preload suggestions as JSON:\n{\n  \"filesToPreload\": [\"...\"],\n  \"testsToRun\": [\"...\"],\n  \"docsToReference\": [\"...\"],\n  \"confidence\": 0.0-1.0\n}",
             sandbox: 'strict',
             model: 'haiku',
             outputFormat: 'json',
             contextPatterns: ['.claude-flow/metrics/*.json'],
-            timeoutMs: 2 * 60 * 1000,
-        },
-    },
+            timeoutMs: 2 * 60 * 1000
+        }
+    }
 };
 /**
  * Local worker configurations
  */
-export const LOCAL_WORKER_CONFIGS = {
+export var LOCAL_WORKER_CONFIGS = {
     map: {
         type: 'map',
         mode: 'local',
         intervalMs: 15 * 60 * 1000,
         priority: 'normal',
         description: 'Codebase mapping',
-        enabled: true,
+        enabled: true
     },
     consolidate: {
         type: 'consolidate',
@@ -278,7 +277,7 @@ export const LOCAL_WORKER_CONFIGS = {
         intervalMs: 30 * 60 * 1000,
         priority: 'low',
         description: 'Memory consolidation',
-        enabled: true,
+        enabled: true
     },
     benchmark: {
         type: 'benchmark',
@@ -286,7 +285,7 @@ export const LOCAL_WORKER_CONFIGS = {
         intervalMs: 60 * 60 * 1000,
         priority: 'low',
         description: 'Performance benchmarking',
-        enabled: false,
+        enabled: false
     },
     preload: {
         type: 'preload',
@@ -294,16 +293,13 @@ export const LOCAL_WORKER_CONFIGS = {
         intervalMs: 5 * 60 * 1000,
         priority: 'low',
         description: 'Resource preloading',
-        enabled: false,
-    },
+        enabled: false
+    }
 };
 /**
  * Combined worker configurations
  */
-export const ALL_WORKER_CONFIGS = [
-    ...Object.values(HEADLESS_WORKER_CONFIGS),
-    ...Object.values(LOCAL_WORKER_CONFIGS),
-];
+export var ALL_WORKER_CONFIGS = __spreadArray(__spreadArray([], Object.values(HEADLESS_WORKER_CONFIGS), true), Object.values(LOCAL_WORKER_CONFIGS), true);
 // ============================================
 // Utility Functions
 // ============================================
@@ -351,29 +347,30 @@ export function getWorkerConfig(type) {
  * - Event emission for monitoring
  * - Graceful termination
  */
-export class HeadlessWorkerExecutor extends EventEmitter {
-    projectRoot;
-    config;
-    processPool = new Map();
-    pendingQueue = [];
-    contextCache = new Map();
-    claudeCodeAvailable = null;
-    claudeCodeVersion = null;
-    constructor(projectRoot, options) {
-        super();
-        this.projectRoot = projectRoot;
+var HeadlessWorkerExecutor = /** @class */ (function (_super) {
+    __extends(HeadlessWorkerExecutor, _super);
+    function HeadlessWorkerExecutor(projectRoot, options) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        var _this = _super.call(this) || this;
+        _this.processPool = new Map();
+        _this.pendingQueue = [];
+        _this.contextCache = new Map();
+        _this.claudeCodeAvailable = null;
+        _this.claudeCodeVersion = null;
+        _this.projectRoot = projectRoot;
         // Merge with defaults
-        this.config = {
-            maxConcurrent: options?.maxConcurrent ?? 2,
-            defaultTimeoutMs: options?.defaultTimeoutMs ?? 5 * 60 * 1000,
-            maxContextFiles: options?.maxContextFiles ?? 20,
-            maxCharsPerFile: options?.maxCharsPerFile ?? 5000,
-            logDir: options?.logDir ?? join(projectRoot, '.claude-flow', 'logs', 'headless'),
-            cacheContext: options?.cacheContext ?? true,
-            cacheTtlMs: options?.cacheTtlMs ?? 60000, // 1 minute default
+        _this.config = {
+            maxConcurrent: (_a = options === null || options === void 0 ? void 0 : options.maxConcurrent) !== null && _a !== void 0 ? _a : 2,
+            defaultTimeoutMs: (_b = options === null || options === void 0 ? void 0 : options.defaultTimeoutMs) !== null && _b !== void 0 ? _b : 5 * 60 * 1000,
+            maxContextFiles: (_c = options === null || options === void 0 ? void 0 : options.maxContextFiles) !== null && _c !== void 0 ? _c : 20,
+            maxCharsPerFile: (_d = options === null || options === void 0 ? void 0 : options.maxCharsPerFile) !== null && _d !== void 0 ? _d : 5000,
+            logDir: (_e = options === null || options === void 0 ? void 0 : options.logDir) !== null && _e !== void 0 ? _e : join(projectRoot, '.claude-flow', 'logs', 'headless'),
+            cacheContext: (_f = options === null || options === void 0 ? void 0 : options.cacheContext) !== null && _f !== void 0 ? _f : true,
+            cacheTtlMs: (_g = options === null || options === void 0 ? void 0 : options.cacheTtlMs) !== null && _g !== void 0 ? _g : 60000
         };
         // Ensure log directory exists
-        this.ensureLogDir();
+        _this.ensureLogDir();
+        return _this;
     }
     // ============================================
     // Public API
@@ -381,333 +378,373 @@ export class HeadlessWorkerExecutor extends EventEmitter {
     /**
      * Check if Claude Code CLI is available
      */
-    async isAvailable() {
-        if (this.claudeCodeAvailable !== null) {
-            return this.claudeCodeAvailable;
-        }
-        try {
-            const output = execSync('claude --version', {
-                encoding: 'utf-8',
-                stdio: 'pipe',
-                timeout: 5000,
-                windowsHide: true, // Prevent phantom console windows on Windows
+    HeadlessWorkerExecutor.prototype.isAvailable = function () {
+        return __awaiter(this, void 0, Promise, function () {
+            var output;
+            return __generator(this, function (_a) {
+                if (this.claudeCodeAvailable !== null) {
+                    return [2 /*return*/, this.claudeCodeAvailable];
+                }
+                try {
+                    output = execSync('claude --version', {
+                        encoding: 'utf-8',
+                        stdio: 'pipe',
+                        timeout: 5000,
+                        windowsHide: true
+                    });
+                    this.claudeCodeAvailable = true;
+                    this.claudeCodeVersion = output.trim();
+                    this.emit('status', { available: true, version: this.claudeCodeVersion });
+                    return [2 /*return*/, true];
+                }
+                catch (_b) {
+                    this.claudeCodeAvailable = false;
+                    this.emit('status', { available: false });
+                    return [2 /*return*/, false];
+                }
+                return [2 /*return*/];
             });
-            this.claudeCodeAvailable = true;
-            this.claudeCodeVersion = output.trim();
-            this.emit('status', { available: true, version: this.claudeCodeVersion });
-            return true;
-        }
-        catch {
-            this.claudeCodeAvailable = false;
-            this.emit('status', { available: false });
-            return false;
-        }
-    }
+        });
+    };
     /**
      * Get Claude Code version
      */
-    async getVersion() {
-        await this.isAvailable();
-        return this.claudeCodeVersion;
-    }
+    HeadlessWorkerExecutor.prototype.getVersion = function () {
+        return __awaiter(this, void 0, Promise, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.isAvailable()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/, this.claudeCodeVersion];
+                }
+            });
+        });
+    };
     /**
      * Execute a headless worker
      */
-    async execute(workerType, configOverrides) {
-        const baseConfig = HEADLESS_WORKER_CONFIGS[workerType];
-        if (!baseConfig) {
-            throw new Error(`Unknown headless worker type: ${workerType}`);
-        }
-        // Check availability
-        const available = await this.isAvailable();
-        if (!available) {
-            const result = this.createErrorResult(workerType, 'Claude Code CLI not available. Install with: npm install -g @anthropic-ai/claude-code');
-            this.emit('error', result);
-            return result;
-        }
-        // Check concurrent limit
-        if (this.processPool.size >= this.config.maxConcurrent) {
-            // Queue the request
-            return new Promise((resolve, reject) => {
-                const entry = {
-                    workerType,
-                    config: configOverrides,
-                    resolve,
-                    reject,
-                    queuedAt: new Date(),
-                };
-                this.pendingQueue.push(entry);
-                this.emit('queued', {
-                    workerType,
-                    queuePosition: this.pendingQueue.length,
-                });
+    HeadlessWorkerExecutor.prototype.execute = function (workerType, configOverrides) {
+        return __awaiter(this, void 0, Promise, function () {
+            var baseConfig, available, result;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        baseConfig = HEADLESS_WORKER_CONFIGS[workerType];
+                        if (!baseConfig) {
+                            throw new Error("Unknown headless worker type: " + workerType);
+                        }
+                        return [4 /*yield*/, this.isAvailable()];
+                    case 1:
+                        available = _a.sent();
+                        if (!available) {
+                            result = this.createErrorResult(workerType, 'Claude Code CLI not available. Install with: npm install -g @anthropic-ai/claude-code');
+                            this.emit('error', result);
+                            return [2 /*return*/, result];
+                        }
+                        // Check concurrent limit
+                        if (this.processPool.size >= this.config.maxConcurrent) {
+                            // Queue the request
+                            return [2 /*return*/, new Promise(function (resolve, reject) {
+                                    var entry = {
+                                        workerType: workerType,
+                                        config: configOverrides,
+                                        resolve: resolve,
+                                        reject: reject,
+                                        queuedAt: new Date()
+                                    };
+                                    _this.pendingQueue.push(entry);
+                                    _this.emit('queued', {
+                                        workerType: workerType,
+                                        queuePosition: _this.pendingQueue.length
+                                    });
+                                })];
+                        }
+                        // Execute immediately
+                        return [2 /*return*/, this.executeInternal(workerType, configOverrides)];
+                }
             });
-        }
-        // Execute immediately
-        return this.executeInternal(workerType, configOverrides);
-    }
+        });
+    };
     /**
      * Get pool status
      */
-    getPoolStatus() {
-        const now = Date.now();
+    HeadlessWorkerExecutor.prototype.getPoolStatus = function () {
+        var now = Date.now();
         return {
             activeCount: this.processPool.size,
             queueLength: this.pendingQueue.length,
             maxConcurrent: this.config.maxConcurrent,
-            activeWorkers: Array.from(this.processPool.values()).map((entry) => ({
+            activeWorkers: Array.from(this.processPool.values()).map(function (entry) { return ({
                 executionId: entry.executionId,
                 workerType: entry.workerType,
                 startTime: entry.startTime,
-                elapsedMs: now - entry.startTime.getTime(),
-            })),
-            queuedWorkers: this.pendingQueue.map((entry) => ({
+                elapsedMs: now - entry.startTime.getTime()
+            }); }),
+            queuedWorkers: this.pendingQueue.map(function (entry) { return ({
                 workerType: entry.workerType,
                 queuedAt: entry.queuedAt,
-                waitingMs: now - entry.queuedAt.getTime(),
-            })),
+                waitingMs: now - entry.queuedAt.getTime()
+            }); })
         };
-    }
+    };
     /**
      * Get number of active executions
      */
-    getActiveCount() {
+    HeadlessWorkerExecutor.prototype.getActiveCount = function () {
         return this.processPool.size;
-    }
+    };
     /**
      * Cancel a running execution
      */
-    cancel(executionId) {
-        const entry = this.processPool.get(executionId);
+    HeadlessWorkerExecutor.prototype.cancel = function (executionId) {
+        var entry = this.processPool.get(executionId);
         if (!entry) {
             return false;
         }
         clearTimeout(entry.timeout);
         entry.process.kill('SIGTERM');
-        this.processPool.delete(executionId);
-        this.emit('cancelled', { executionId });
+        this.processPool["delete"](executionId);
+        this.emit('cancelled', { executionId: executionId });
         // Process next in queue
         this.processQueue();
         return true;
-    }
+    };
     /**
      * Cancel all running executions
      */
-    cancelAll() {
-        let cancelled = 0;
+    HeadlessWorkerExecutor.prototype.cancelAll = function () {
+        var cancelled = 0;
         // Cancel active processes (convert to array to avoid iterator issues)
-        const entries = Array.from(this.processPool.entries());
-        for (const [executionId, entry] of entries) {
+        var entries = Array.from(this.processPool.entries());
+        for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) {
+            var _a = entries_1[_i], executionId = _a[0], entry = _a[1];
             clearTimeout(entry.timeout);
             entry.process.kill('SIGTERM');
-            this.emit('cancelled', { executionId });
+            this.emit('cancelled', { executionId: executionId });
             cancelled++;
         }
         this.processPool.clear();
         // Reject pending queue
-        for (const entry of this.pendingQueue) {
+        for (var _b = 0, _c = this.pendingQueue; _b < _c.length; _b++) {
+            var entry = _c[_b];
             entry.reject(new Error('Executor cancelled all executions'));
         }
         this.pendingQueue = [];
         this.emit('allCancelled', { count: cancelled });
         return cancelled;
-    }
+    };
     /**
      * Clear context cache
      */
-    clearContextCache() {
+    HeadlessWorkerExecutor.prototype.clearContextCache = function () {
         this.contextCache.clear();
         this.emit('cacheClear', {});
-    }
+    };
     /**
      * Get worker configuration
      */
-    getConfig(workerType) {
+    HeadlessWorkerExecutor.prototype.getConfig = function (workerType) {
         return HEADLESS_WORKER_CONFIGS[workerType];
-    }
+    };
     /**
      * Get all headless worker types
      */
-    getHeadlessWorkerTypes() {
-        return [...HEADLESS_WORKER_TYPES];
-    }
+    HeadlessWorkerExecutor.prototype.getHeadlessWorkerTypes = function () {
+        return __spreadArray([], HEADLESS_WORKER_TYPES, true);
+    };
     /**
      * Get all local worker types
      */
-    getLocalWorkerTypes() {
-        return [...LOCAL_WORKER_TYPES];
-    }
+    HeadlessWorkerExecutor.prototype.getLocalWorkerTypes = function () {
+        return __spreadArray([], LOCAL_WORKER_TYPES, true);
+    };
     // ============================================
     // Private Methods
     // ============================================
     /**
      * Ensure log directory exists
      */
-    ensureLogDir() {
+    HeadlessWorkerExecutor.prototype.ensureLogDir = function () {
         try {
             if (!existsSync(this.config.logDir)) {
                 mkdirSync(this.config.logDir, { recursive: true });
             }
         }
         catch (error) {
-            this.emit('warning', { message: 'Failed to create log directory', error });
+            this.emit('warning', { message: 'Failed to create log directory', error: error });
         }
-    }
+    };
     /**
      * Internal execution logic
      */
-    async executeInternal(workerType, configOverrides) {
-        const baseConfig = HEADLESS_WORKER_CONFIGS[workerType];
-        const headless = { ...baseConfig.headless, ...configOverrides };
-        const startTime = Date.now();
-        const executionId = `${workerType}_${startTime}_${Math.random().toString(36).slice(2, 8)}`;
-        this.emit('start', { executionId, workerType, config: headless });
-        try {
-            // Build context from file patterns
-            const context = await this.buildContext(headless.contextPatterns || []);
-            // Build the full prompt
-            const fullPrompt = this.buildPrompt(headless.promptTemplate, context);
-            // Log prompt for debugging
-            this.logExecution(executionId, 'prompt', fullPrompt);
-            // Execute Claude Code headlessly
-            const result = await this.executeClaudeCode(fullPrompt, {
-                sandbox: headless.sandbox,
-                model: headless.model || 'sonnet',
-                timeoutMs: headless.timeoutMs || this.config.defaultTimeoutMs,
-                executionId,
-                workerType,
+    HeadlessWorkerExecutor.prototype.executeInternal = function (workerType, configOverrides) {
+        return __awaiter(this, void 0, Promise, function () {
+            var baseConfig, headless, startTime, executionId, context, fullPrompt, result, parsedOutput, executionResult, error_1, errorMessage, executionResult;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        baseConfig = HEADLESS_WORKER_CONFIGS[workerType];
+                        headless = __assign(__assign({}, baseConfig.headless), configOverrides);
+                        startTime = Date.now();
+                        executionId = workerType + "_" + startTime + "_" + Math.random().toString(36).slice(2, 8);
+                        this.emit('start', { executionId: executionId, workerType: workerType, config: headless });
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 4, 5, 6]);
+                        return [4 /*yield*/, this.buildContext(headless.contextPatterns || [])];
+                    case 2:
+                        context = _a.sent();
+                        fullPrompt = this.buildPrompt(headless.promptTemplate, context);
+                        // Log prompt for debugging
+                        this.logExecution(executionId, 'prompt', fullPrompt);
+                        return [4 /*yield*/, this.executeClaudeCode(fullPrompt, {
+                                sandbox: headless.sandbox,
+                                model: headless.model || 'sonnet',
+                                timeoutMs: headless.timeoutMs || this.config.defaultTimeoutMs,
+                                executionId: executionId,
+                                workerType: workerType
+                            })];
+                    case 3:
+                        result = _a.sent();
+                        parsedOutput = void 0;
+                        if (headless.outputFormat === 'json' && result.output) {
+                            parsedOutput = this.parseJsonOutput(result.output);
+                        }
+                        else if (headless.outputFormat === 'markdown' && result.output) {
+                            parsedOutput = this.parseMarkdownOutput(result.output);
+                        }
+                        executionResult = {
+                            success: result.success,
+                            output: result.output,
+                            parsedOutput: parsedOutput,
+                            durationMs: Date.now() - startTime,
+                            tokensUsed: result.tokensUsed,
+                            model: headless.model || 'sonnet',
+                            sandboxMode: headless.sandbox,
+                            workerType: workerType,
+                            timestamp: new Date(),
+                            executionId: executionId,
+                            error: result.error
+                        };
+                        // Log result
+                        this.logExecution(executionId, 'result', JSON.stringify(executionResult, null, 2));
+                        this.emit('complete', executionResult);
+                        return [2 /*return*/, executionResult];
+                    case 4:
+                        error_1 = _a.sent();
+                        errorMessage = error_1 instanceof Error ? error_1.message : String(error_1);
+                        executionResult = this.createErrorResult(workerType, errorMessage);
+                        executionResult.executionId = executionId;
+                        executionResult.durationMs = Date.now() - startTime;
+                        this.logExecution(executionId, 'error', errorMessage);
+                        this.emit('error', executionResult);
+                        return [2 /*return*/, executionResult];
+                    case 5:
+                        // Process next in queue
+                        this.processQueue();
+                        return [7 /*endfinally*/];
+                    case 6: return [2 /*return*/];
+                }
             });
-            // Parse output based on format
-            let parsedOutput;
-            if (headless.outputFormat === 'json' && result.output) {
-                parsedOutput = this.parseJsonOutput(result.output);
-            }
-            else if (headless.outputFormat === 'markdown' && result.output) {
-                parsedOutput = this.parseMarkdownOutput(result.output);
-            }
-            const executionResult = {
-                success: result.success,
-                output: result.output,
-                parsedOutput,
-                durationMs: Date.now() - startTime,
-                tokensUsed: result.tokensUsed,
-                model: headless.model || 'sonnet',
-                sandboxMode: headless.sandbox,
-                workerType,
-                timestamp: new Date(),
-                executionId,
-                error: result.error,
-            };
-            // Log result
-            this.logExecution(executionId, 'result', JSON.stringify(executionResult, null, 2));
-            this.emit('complete', executionResult);
-            return executionResult;
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            const executionResult = this.createErrorResult(workerType, errorMessage);
-            executionResult.executionId = executionId;
-            executionResult.durationMs = Date.now() - startTime;
-            this.logExecution(executionId, 'error', errorMessage);
-            this.emit('error', executionResult);
-            return executionResult;
-        }
-        finally {
-            // Process next in queue
-            this.processQueue();
-        }
-    }
+        });
+    };
     /**
      * Process the pending queue
      */
-    processQueue() {
+    HeadlessWorkerExecutor.prototype.processQueue = function () {
         while (this.pendingQueue.length > 0 &&
             this.processPool.size < this.config.maxConcurrent) {
-            const next = this.pendingQueue.shift();
+            var next = this.pendingQueue.shift();
             if (!next)
                 break;
             this.executeInternal(next.workerType, next.config)
-                .then(next.resolve)
-                .catch(next.reject);
+                .then(next.resolve)["catch"](next.reject);
         }
-    }
+    };
     /**
      * Build context from file patterns
      */
-    async buildContext(patterns) {
-        if (patterns.length === 0)
-            return '';
-        // Check cache
-        const cacheKey = patterns.sort().join('|');
-        if (this.config.cacheContext) {
-            const cached = this.contextCache.get(cacheKey);
-            if (cached && Date.now() - cached.timestamp < this.config.cacheTtlMs) {
-                return cached.content;
-            }
-        }
-        // Collect files matching patterns
-        const files = [];
-        for (const pattern of patterns) {
-            const matches = this.simpleGlob(pattern);
-            files.push(...matches);
-        }
-        // Deduplicate and limit
-        const uniqueFiles = Array.from(new Set(files)).slice(0, this.config.maxContextFiles);
-        // Build context
-        const contextParts = [];
-        for (const file of uniqueFiles) {
-            try {
-                const fullPath = join(this.projectRoot, file);
-                if (!existsSync(fullPath))
-                    continue;
-                const content = readFileSync(fullPath, 'utf-8');
-                const truncated = content.slice(0, this.config.maxCharsPerFile);
-                const wasTruncated = content.length > this.config.maxCharsPerFile;
-                contextParts.push(`--- ${file}${wasTruncated ? ' (truncated)' : ''} ---\n${truncated}`);
-            }
-            catch {
-                // Skip unreadable files
-            }
-        }
-        const contextContent = contextParts.join('\n\n');
-        // Cache the result
-        if (this.config.cacheContext) {
-            this.contextCache.set(cacheKey, {
-                content: contextContent,
-                timestamp: Date.now(),
-                patterns,
+    HeadlessWorkerExecutor.prototype.buildContext = function (patterns) {
+        return __awaiter(this, void 0, Promise, function () {
+            var cacheKey, cached, files, _i, patterns_1, pattern, matches, uniqueFiles, contextParts, _a, uniqueFiles_1, file, fullPath, content, truncated, wasTruncated, contextContent;
+            return __generator(this, function (_b) {
+                if (patterns.length === 0)
+                    return [2 /*return*/, ''];
+                cacheKey = patterns.sort().join('|');
+                if (this.config.cacheContext) {
+                    cached = this.contextCache.get(cacheKey);
+                    if (cached && Date.now() - cached.timestamp < this.config.cacheTtlMs) {
+                        return [2 /*return*/, cached.content];
+                    }
+                }
+                files = [];
+                for (_i = 0, patterns_1 = patterns; _i < patterns_1.length; _i++) {
+                    pattern = patterns_1[_i];
+                    matches = this.simpleGlob(pattern);
+                    files.push.apply(files, matches);
+                }
+                uniqueFiles = Array.from(new Set(files)).slice(0, this.config.maxContextFiles);
+                contextParts = [];
+                for (_a = 0, uniqueFiles_1 = uniqueFiles; _a < uniqueFiles_1.length; _a++) {
+                    file = uniqueFiles_1[_a];
+                    try {
+                        fullPath = join(this.projectRoot, file);
+                        if (!existsSync(fullPath))
+                            continue;
+                        content = readFileSync(fullPath, 'utf-8');
+                        truncated = content.slice(0, this.config.maxCharsPerFile);
+                        wasTruncated = content.length > this.config.maxCharsPerFile;
+                        contextParts.push("--- " + file + (wasTruncated ? ' (truncated)' : '') + " ---\n" + truncated);
+                    }
+                    catch (_c) {
+                        // Skip unreadable files
+                    }
+                }
+                contextContent = contextParts.join('\n\n');
+                // Cache the result
+                if (this.config.cacheContext) {
+                    this.contextCache.set(cacheKey, {
+                        content: contextContent,
+                        timestamp: Date.now(),
+                        patterns: patterns
+                    });
+                }
+                return [2 /*return*/, contextContent];
             });
-        }
-        return contextContent;
-    }
+        });
+    };
     /**
      * Simple glob implementation for file matching
      */
-    simpleGlob(pattern) {
-        const results = [];
+    HeadlessWorkerExecutor.prototype.simpleGlob = function (pattern) {
+        var _this = this;
+        var results = [];
         // Handle simple patterns (no wildcards)
         if (!pattern.includes('*')) {
-            const fullPath = join(this.projectRoot, pattern);
+            var fullPath = join(this.projectRoot, pattern);
             if (existsSync(fullPath)) {
                 results.push(pattern);
             }
             return results;
         }
         // Parse pattern parts
-        const parts = pattern.split('/');
-        const scanDir = (dir, remainingParts) => {
+        var parts = pattern.split('/');
+        var scanDir = function (dir, remainingParts) {
             if (remainingParts.length === 0)
                 return;
             if (results.length >= 100)
                 return; // Limit results
             try {
-                const fullDir = join(this.projectRoot, dir);
+                var fullDir = join(_this.projectRoot, dir);
                 if (!existsSync(fullDir))
                     return;
-                const entries = readdirSync(fullDir, { withFileTypes: true });
-                const currentPart = remainingParts[0];
-                const isLastPart = remainingParts.length === 1;
-                for (const entry of entries) {
+                var entries = readdirSync(fullDir, { withFileTypes: true });
+                var currentPart = remainingParts[0];
+                var isLastPart = remainingParts.length === 1;
+                for (var _i = 0, entries_2 = entries; _i < entries_2.length; _i++) {
+                    var entry = entries_2[_i];
                     // Skip common non-code directories
                     if (entry.name === 'node_modules' ||
                         entry.name === '.git' ||
@@ -718,7 +755,7 @@ export class HeadlessWorkerExecutor extends EventEmitter {
                         entry.name === '.cache') {
                         continue;
                     }
-                    const entryPath = dir ? `${dir}/${entry.name}` : entry.name;
+                    var entryPath = dir ? dir + "/" + entry.name : entry.name;
                     if (currentPart === '**') {
                         // Recursive glob
                         if (entry.isDirectory()) {
@@ -727,13 +764,13 @@ export class HeadlessWorkerExecutor extends EventEmitter {
                         }
                         else if (entry.isFile() && remainingParts.length > 1) {
                             // Check if file matches next pattern part
-                            const nextPart = remainingParts[1];
-                            if (this.matchesPattern(entry.name, nextPart)) {
+                            var nextPart = remainingParts[1];
+                            if (_this.matchesPattern(entry.name, nextPart)) {
                                 results.push(entryPath);
                             }
                         }
                     }
-                    else if (this.matchesPattern(entry.name, currentPart)) {
+                    else if (_this.matchesPattern(entry.name, currentPart)) {
                         if (isLastPart && entry.isFile()) {
                             results.push(entryPath);
                         }
@@ -743,17 +780,17 @@ export class HeadlessWorkerExecutor extends EventEmitter {
                     }
                 }
             }
-            catch {
+            catch (_a) {
                 // Skip unreadable directories
             }
         };
         scanDir('', parts);
         return results;
-    }
+    };
     /**
      * Match filename against a simple pattern
      */
-    matchesPattern(name, pattern) {
+    HeadlessWorkerExecutor.prototype.matchesPattern = function (name, pattern) {
         if (pattern === '*')
             return true;
         if (pattern === '**')
@@ -772,53 +809,39 @@ export class HeadlessWorkerExecutor extends EventEmitter {
         }
         // Exact match
         return name === pattern;
-    }
+    };
     /**
      * Build full prompt with context
      */
-    buildPrompt(template, context) {
+    HeadlessWorkerExecutor.prototype.buildPrompt = function (template, context) {
         if (!context) {
-            return `${template}
-
-## Instructions
-
-Analyze the codebase and provide your response following the format specified in the task.`;
+            return template + "\n\n## Instructions\n\nAnalyze the codebase and provide your response following the format specified in the task.";
         }
-        return `${template}
-
-## Codebase Context
-
-${context}
-
-## Instructions
-
-Analyze the above codebase context and provide your response following the format specified in the task.`;
-    }
+        return template + "\n\n## Codebase Context\n\n" + context + "\n\n## Instructions\n\nAnalyze the above codebase context and provide your response following the format specified in the task.";
+    };
     /**
      * Execute Claude Code in headless mode
      */
-    executeClaudeCode(prompt, options) {
-        return new Promise((resolve) => {
-            const env = {
-                ...process.env,
-                CLAUDE_CODE_HEADLESS: 'true',
-                CLAUDE_CODE_SANDBOX_MODE: options.sandbox,
-            };
+    HeadlessWorkerExecutor.prototype.executeClaudeCode = function (prompt, options) {
+        var _this = this;
+        return new Promise(function (resolve) {
+            var _a, _b;
+            var env = __assign(__assign({}, process.env), { CLAUDE_CODE_HEADLESS: 'true', CLAUDE_CODE_SANDBOX_MODE: options.sandbox });
             // Set model
             env.ANTHROPIC_MODEL = MODEL_IDS[options.model];
             // Spawn claude CLI process
-            const child = spawn('claude', ['--print', prompt], {
-                cwd: this.projectRoot,
-                env,
+            var child = spawn('claude', ['--print', prompt], {
+                cwd: _this.projectRoot,
+                env: env,
                 stdio: ['pipe', 'pipe', 'pipe'],
-                windowsHide: true, // Prevent phantom console windows on Windows
+                windowsHide: true
             });
             // Setup timeout
-            const timeoutHandle = setTimeout(() => {
-                if (this.processPool.has(options.executionId)) {
+            var timeoutHandle = setTimeout(function () {
+                if (_this.processPool.has(options.executionId)) {
                     child.kill('SIGTERM');
                     // Give it a moment to terminate gracefully
-                    setTimeout(() => {
+                    setTimeout(function () {
                         if (!child.killed) {
                             child.kill('SIGKILL');
                         }
@@ -826,40 +849,40 @@ Analyze the above codebase context and provide your response following the forma
                 }
             }, options.timeoutMs);
             // Track in process pool
-            const poolEntry = {
+            var poolEntry = {
                 process: child,
                 executionId: options.executionId,
                 workerType: options.workerType,
                 startTime: new Date(),
-                timeout: timeoutHandle,
+                timeout: timeoutHandle
             };
-            this.processPool.set(options.executionId, poolEntry);
-            let stdout = '';
-            let stderr = '';
-            let resolved = false;
-            const cleanup = () => {
+            _this.processPool.set(options.executionId, poolEntry);
+            var stdout = '';
+            var stderr = '';
+            var resolved = false;
+            var cleanup = function () {
                 clearTimeout(timeoutHandle);
-                this.processPool.delete(options.executionId);
+                _this.processPool["delete"](options.executionId);
             };
-            child.stdout?.on('data', (data) => {
-                const chunk = data.toString();
+            (_a = child.stdout) === null || _a === void 0 ? void 0 : _a.on('data', function (data) {
+                var chunk = data.toString();
                 stdout += chunk;
-                this.emit('output', {
+                _this.emit('output', {
                     executionId: options.executionId,
                     type: 'stdout',
-                    data: chunk,
+                    data: chunk
                 });
             });
-            child.stderr?.on('data', (data) => {
-                const chunk = data.toString();
+            (_b = child.stderr) === null || _b === void 0 ? void 0 : _b.on('data', function (data) {
+                var chunk = data.toString();
                 stderr += chunk;
-                this.emit('output', {
+                _this.emit('output', {
                     executionId: options.executionId,
                     type: 'stderr',
-                    data: chunk,
+                    data: chunk
                 });
             });
-            child.on('close', (code) => {
+            child.on('close', function (code) {
                 if (resolved)
                     return;
                 resolved = true;
@@ -867,10 +890,10 @@ Analyze the above codebase context and provide your response following the forma
                 resolve({
                     success: code === 0,
                     output: stdout || stderr,
-                    error: code !== 0 ? stderr || `Process exited with code ${code}` : undefined,
+                    error: code !== 0 ? stderr || "Process exited with code " + code : undefined
                 });
             });
-            child.on('error', (error) => {
+            child.on('error', function (error) {
                 if (resolved)
                     return;
                 resolved = true;
@@ -878,14 +901,14 @@ Analyze the above codebase context and provide your response following the forma
                 resolve({
                     success: false,
                     output: '',
-                    error: error.message,
+                    error: error.message
                 });
             });
             // Handle timeout
-            setTimeout(() => {
+            setTimeout(function () {
                 if (resolved)
                     return;
-                if (!this.processPool.has(options.executionId))
+                if (!_this.processPool.has(options.executionId))
                     return;
                 resolved = true;
                 child.kill('SIGTERM');
@@ -893,56 +916,57 @@ Analyze the above codebase context and provide your response following the forma
                 resolve({
                     success: false,
                     output: stdout || stderr,
-                    error: `Execution timed out after ${options.timeoutMs}ms`,
+                    error: "Execution timed out after " + options.timeoutMs + "ms"
                 });
             }, options.timeoutMs + 100); // Slightly after the kill timeout
         });
-    }
+    };
     /**
      * Parse JSON output from Claude Code
      */
-    parseJsonOutput(output) {
+    HeadlessWorkerExecutor.prototype.parseJsonOutput = function (output) {
         try {
             // Try to find JSON in code blocks first
-            const codeBlockMatch = output.match(/```(?:json)?\s*([\s\S]*?)```/);
+            var codeBlockMatch = output.match(/```(?:json)?\s*([\s\S]*?)```/);
             if (codeBlockMatch) {
                 return JSON.parse(codeBlockMatch[1].trim());
             }
             // Try to find any JSON object
-            const jsonMatch = output.match(/\{[\s\S]*\}/);
+            var jsonMatch = output.match(/\{[\s\S]*\}/);
             if (jsonMatch) {
                 return JSON.parse(jsonMatch[0]);
             }
             // Try direct parse
             return JSON.parse(output.trim());
         }
-        catch {
+        catch (_a) {
             return {
                 parseError: true,
-                rawOutput: output,
+                rawOutput: output
             };
         }
-    }
+    };
     /**
      * Parse markdown output into sections
      */
-    parseMarkdownOutput(output) {
-        const sections = [];
-        const codeBlocks = [];
+    HeadlessWorkerExecutor.prototype.parseMarkdownOutput = function (output) {
+        var sections = [];
+        var codeBlocks = [];
         // Extract code blocks first
-        const codeBlockRegex = /```(\w*)\n([\s\S]*?)```/g;
-        let codeMatch;
+        var codeBlockRegex = /```(\w*)\n([\s\S]*?)```/g;
+        var codeMatch;
         while ((codeMatch = codeBlockRegex.exec(output)) !== null) {
             codeBlocks.push({
                 language: codeMatch[1] || 'text',
-                code: codeMatch[2].trim(),
+                code: codeMatch[2].trim()
             });
         }
         // Parse sections
-        const lines = output.split('\n');
-        let currentSection = null;
-        for (const line of lines) {
-            const headerMatch = line.match(/^(#{1,6})\s+(.+)$/);
+        var lines = output.split('\n');
+        var currentSection = null;
+        for (var _i = 0, lines_1 = lines; _i < lines_1.length; _i++) {
+            var line = lines_1[_i];
+            var headerMatch = line.match(/^(#{1,6})\s+(.+)$/);
             if (headerMatch) {
                 if (currentSection) {
                     sections.push(currentSection);
@@ -950,7 +974,7 @@ Analyze the above codebase context and provide your response following the forma
                 currentSection = {
                     title: headerMatch[2].trim(),
                     content: '',
-                    level: headerMatch[1].length,
+                    level: headerMatch[1].length
                 };
             }
             else if (currentSection) {
@@ -961,39 +985,41 @@ Analyze the above codebase context and provide your response following the forma
             currentSection.content = currentSection.content.trim();
             sections.push(currentSection);
         }
-        return { sections, codeBlocks };
-    }
+        return { sections: sections, codeBlocks: codeBlocks };
+    };
     /**
      * Create an error result
      */
-    createErrorResult(workerType, error) {
+    HeadlessWorkerExecutor.prototype.createErrorResult = function (workerType, error) {
         return {
             success: false,
             output: '',
             durationMs: 0,
             model: 'unknown',
             sandboxMode: 'strict',
-            workerType,
+            workerType: workerType,
             timestamp: new Date(),
-            executionId: `error_${Date.now()}`,
-            error,
+            executionId: "error_" + Date.now(),
+            error: error
         };
-    }
+    };
     /**
      * Log execution details for debugging
      */
-    logExecution(executionId, type, content) {
+    HeadlessWorkerExecutor.prototype.logExecution = function (executionId, type, content) {
         try {
-            const timestamp = new Date().toISOString();
-            const logFile = join(this.config.logDir, `${executionId}_${type}.log`);
-            const logContent = `[${timestamp}] ${type.toUpperCase()}\n${'='.repeat(60)}\n${content}\n`;
+            var timestamp = new Date().toISOString();
+            var logFile = join(this.config.logDir, executionId + "_" + type + ".log");
+            var logContent = "[" + timestamp + "] " + type.toUpperCase() + "\n" + '='.repeat(60) + "\n" + content + "\n";
             writeFileSync(logFile, logContent);
         }
-        catch {
+        catch (_a) {
             // Ignore log write errors
         }
-    }
-}
+    };
+    return HeadlessWorkerExecutor;
+}(EventEmitter));
+export { HeadlessWorkerExecutor };
 // Export default
 export default HeadlessWorkerExecutor;
 //# sourceMappingURL=headless-worker-executor.js.map