kynjal-cli 4.0.0 → 4.0.1

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

@@ -18,77 +18,6 @@
  * - 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';
@@ -99,7 +28,7 @@ import { join } from 'path';
 /**
  * Array of headless worker types for runtime checking
  */
-export var HEADLESS_WORKER_TYPES = [
+export const HEADLESS_WORKER_TYPES = [
     'audit',
     'optimize',
     'testgaps',
@@ -112,7 +41,7 @@ export var HEADLESS_WORKER_TYPES = [
 /**
  * Array of local worker types
  */
-export var LOCAL_WORKER_TYPES = [
+export const LOCAL_WORKER_TYPES = [
     'map',
     'consolidate',
     'benchmark',
@@ -121,15 +50,15 @@ export var LOCAL_WORKER_TYPES = [
 /**
  * Model ID mapping
  */
-var MODEL_IDS = {
+const 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 var HEADLESS_WORKER_CONFIGS = {
+export const HEADLESS_WORKER_CONFIGS = {
     audit: {
         type: 'audit',
         mode: 'headless',
@@ -138,13 +67,25 @@ export var HEADLESS_WORKER_CONFIGS = {
         description: 'AI-powered security analysis',
         enabled: true,
         headless: {
-            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}",
+            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": ["..."]
+}`,
             sandbox: 'strict',
             model: 'haiku',
             outputFormat: 'json',
             contextPatterns: ['**/*.ts', '**/*.js', '**/.env*', '**/package.json'],
-            timeoutMs: 5 * 60 * 1000
-        }
+            timeoutMs: 5 * 60 * 1000,
+        },
     },
     optimize: {
         type: 'optimize',
@@ -154,13 +95,20 @@ export var HEADLESS_WORKER_CONFIGS = {
         description: 'AI optimization suggestions',
         enabled: true,
         headless: {
-            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.",
+            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.`,
             sandbox: 'permissive',
             model: 'sonnet',
             outputFormat: 'markdown',
             contextPatterns: ['src/**/*.ts', 'src/**/*.tsx'],
-            timeoutMs: 10 * 60 * 1000
-        }
+            timeoutMs: 10 * 60 * 1000,
+        },
     },
     testgaps: {
         type: 'testgaps',
@@ -170,13 +118,20 @@ export var HEADLESS_WORKER_CONFIGS = {
         description: 'AI test gap analysis',
         enabled: true,
         headless: {
-            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.",
+            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.`,
             sandbox: 'permissive',
             model: 'sonnet',
             outputFormat: 'markdown',
             contextPatterns: ['src/**/*.ts', 'tests/**/*.ts', '__tests__/**/*.ts'],
-            timeoutMs: 10 * 60 * 1000
-        }
+            timeoutMs: 10 * 60 * 1000,
+        },
     },
     document: {
         type: 'document',
@@ -186,61 +141,95 @@ export var HEADLESS_WORKER_CONFIGS = {
         description: 'AI documentation generation',
         enabled: false,
         headless: {
-            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.",
+            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.`,
             sandbox: 'permissive',
             model: 'haiku',
             outputFormat: 'markdown',
             contextPatterns: ['src/**/*.ts'],
-            timeoutMs: 10 * 60 * 1000
-        }
+            timeoutMs: 10 * 60 * 1000,
+        },
     },
     ultralearn: {
         type: 'ultralearn',
         mode: 'headless',
-        intervalMs: 0,
+        intervalMs: 0, // Manual trigger only
         priority: 'normal',
         description: 'Deep knowledge acquisition',
         enabled: false,
         headless: {
-            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}",
+            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": ["..."]
+}`,
             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,
+        intervalMs: 0, // Manual trigger only
         priority: 'normal',
         description: 'AI refactoring suggestions',
         enabled: false,
         headless: {
-            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.",
+            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.`,
             sandbox: 'permissive',
             model: 'sonnet',
             outputFormat: 'markdown',
             contextPatterns: ['src/**/*.ts'],
-            timeoutMs: 10 * 60 * 1000
-        }
+            timeoutMs: 10 * 60 * 1000,
+        },
     },
     deepdive: {
         type: 'deepdive',
         mode: 'headless',
-        intervalMs: 0,
+        intervalMs: 0, // Manual trigger only
         priority: 'normal',
         description: 'Deep code analysis',
         enabled: false,
         headless: {
-            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.",
+            promptTemplate: `Perform deep analysis of this codebase:
+- Understand data flow
+- Map dependencies
+- Identify architectural issues
+- Find potential bugs
+- Analyze error handling
+
+Provide comprehensive report.`,
             sandbox: 'strict',
             model: 'opus',
             outputFormat: 'markdown',
             contextPatterns: ['src/**/*.ts'],
-            timeoutMs: 15 * 60 * 1000
-        }
+            timeoutMs: 15 * 60 * 1000,
+        },
     },
     predict: {
         type: 'predict',
@@ -250,26 +239,38 @@ export var HEADLESS_WORKER_CONFIGS = {
         description: 'Predictive preloading',
         enabled: false,
         headless: {
-            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}",
+            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
+}`,
             sandbox: 'strict',
             model: 'haiku',
             outputFormat: 'json',
             contextPatterns: ['.claude-flow/metrics/*.json'],
-            timeoutMs: 2 * 60 * 1000
-        }
-    }
+            timeoutMs: 2 * 60 * 1000,
+        },
+    },
 };
 /**
  * Local worker configurations
  */
-export var LOCAL_WORKER_CONFIGS = {
+export const LOCAL_WORKER_CONFIGS = {
     map: {
         type: 'map',
         mode: 'local',
         intervalMs: 15 * 60 * 1000,
         priority: 'normal',
         description: 'Codebase mapping',
-        enabled: true
+        enabled: true,
     },
     consolidate: {
         type: 'consolidate',
@@ -277,7 +278,7 @@ export var LOCAL_WORKER_CONFIGS = {
         intervalMs: 30 * 60 * 1000,
         priority: 'low',
         description: 'Memory consolidation',
-        enabled: true
+        enabled: true,
     },
     benchmark: {
         type: 'benchmark',
@@ -285,7 +286,7 @@ export var LOCAL_WORKER_CONFIGS = {
         intervalMs: 60 * 60 * 1000,
         priority: 'low',
         description: 'Performance benchmarking',
-        enabled: false
+        enabled: false,
     },
     preload: {
         type: 'preload',
@@ -293,13 +294,16 @@ export var LOCAL_WORKER_CONFIGS = {
         intervalMs: 5 * 60 * 1000,
         priority: 'low',
         description: 'Resource preloading',
-        enabled: false
-    }
+        enabled: false,
+    },
 };
 /**
  * Combined worker configurations
  */
-export var ALL_WORKER_CONFIGS = __spreadArray(__spreadArray([], Object.values(HEADLESS_WORKER_CONFIGS), true), Object.values(LOCAL_WORKER_CONFIGS), true);
+export const ALL_WORKER_CONFIGS = [
+    ...Object.values(HEADLESS_WORKER_CONFIGS),
+    ...Object.values(LOCAL_WORKER_CONFIGS),
+];
 // ============================================
 // Utility Functions
 // ============================================
@@ -347,30 +351,29 @@ export function getWorkerConfig(type) {
  * - Event emission for monitoring
  * - Graceful termination
  */
-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;
+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;
         // Merge with defaults
-        _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
+        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
         };
         // Ensure log directory exists
-        _this.ensureLogDir();
-        return _this;
+        this.ensureLogDir();
     }
     // ============================================
     // Public API
@@ -378,373 +381,333 @@ var HeadlessWorkerExecutor = /** @class */ (function (_super) {
     /**
      * Check if Claude Code CLI is available
      */
-    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*/];
+    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
             });
-        });
-    };
+            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
      */
-    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];
-                }
-            });
-        });
-    };
+    async getVersion() {
+        await this.isAvailable();
+        return this.claudeCodeVersion;
+    }
     /**
      * Execute a headless worker
      */
-    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)];
-                }
+    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,
+                });
             });
-        });
-    };
+        }
+        // Execute immediately
+        return this.executeInternal(workerType, configOverrides);
+    }
     /**
      * Get pool status
      */
-    HeadlessWorkerExecutor.prototype.getPoolStatus = function () {
-        var now = Date.now();
+    getPoolStatus() {
+        const now = Date.now();
         return {
             activeCount: this.processPool.size,
             queueLength: this.pendingQueue.length,
             maxConcurrent: this.config.maxConcurrent,
-            activeWorkers: Array.from(this.processPool.values()).map(function (entry) { return ({
+            activeWorkers: Array.from(this.processPool.values()).map((entry) => ({
                 executionId: entry.executionId,
                 workerType: entry.workerType,
                 startTime: entry.startTime,
-                elapsedMs: now - entry.startTime.getTime()
-            }); }),
-            queuedWorkers: this.pendingQueue.map(function (entry) { return ({
+                elapsedMs: now - entry.startTime.getTime(),
+            })),
+            queuedWorkers: this.pendingQueue.map((entry) => ({
                 workerType: entry.workerType,
                 queuedAt: entry.queuedAt,
-                waitingMs: now - entry.queuedAt.getTime()
-            }); })
+                waitingMs: now - entry.queuedAt.getTime(),
+            })),
         };
-    };
+    }
     /**
      * Get number of active executions
      */
-    HeadlessWorkerExecutor.prototype.getActiveCount = function () {
+    getActiveCount() {
         return this.processPool.size;
-    };
+    }
     /**
      * Cancel a running execution
      */
-    HeadlessWorkerExecutor.prototype.cancel = function (executionId) {
-        var entry = this.processPool.get(executionId);
+    cancel(executionId) {
+        const entry = this.processPool.get(executionId);
         if (!entry) {
             return false;
         }
         clearTimeout(entry.timeout);
         entry.process.kill('SIGTERM');
-        this.processPool["delete"](executionId);
-        this.emit('cancelled', { executionId: executionId });
+        this.processPool.delete(executionId);
+        this.emit('cancelled', { executionId });
         // Process next in queue
         this.processQueue();
         return true;
-    };
+    }
     /**
      * Cancel all running executions
      */
-    HeadlessWorkerExecutor.prototype.cancelAll = function () {
-        var cancelled = 0;
+    cancelAll() {
+        let cancelled = 0;
         // Cancel active processes (convert to array to avoid iterator issues)
-        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];
+        const entries = Array.from(this.processPool.entries());
+        for (const [executionId, entry] of entries) {
             clearTimeout(entry.timeout);
             entry.process.kill('SIGTERM');
-            this.emit('cancelled', { executionId: executionId });
+            this.emit('cancelled', { executionId });
             cancelled++;
         }
         this.processPool.clear();
         // Reject pending queue
-        for (var _b = 0, _c = this.pendingQueue; _b < _c.length; _b++) {
-            var entry = _c[_b];
+        for (const entry of this.pendingQueue) {
             entry.reject(new Error('Executor cancelled all executions'));
         }
         this.pendingQueue = [];
         this.emit('allCancelled', { count: cancelled });
         return cancelled;
-    };
+    }
     /**
      * Clear context cache
      */
-    HeadlessWorkerExecutor.prototype.clearContextCache = function () {
+    clearContextCache() {
         this.contextCache.clear();
         this.emit('cacheClear', {});
-    };
+    }
     /**
      * Get worker configuration
      */
-    HeadlessWorkerExecutor.prototype.getConfig = function (workerType) {
+    getConfig(workerType) {
         return HEADLESS_WORKER_CONFIGS[workerType];
-    };
+    }
     /**
      * Get all headless worker types
      */
-    HeadlessWorkerExecutor.prototype.getHeadlessWorkerTypes = function () {
-        return __spreadArray([], HEADLESS_WORKER_TYPES, true);
-    };
+    getHeadlessWorkerTypes() {
+        return [...HEADLESS_WORKER_TYPES];
+    }
     /**
      * Get all local worker types
      */
-    HeadlessWorkerExecutor.prototype.getLocalWorkerTypes = function () {
-        return __spreadArray([], LOCAL_WORKER_TYPES, true);
-    };
+    getLocalWorkerTypes() {
+        return [...LOCAL_WORKER_TYPES];
+    }
     // ============================================
     // Private Methods
     // ============================================
     /**
      * Ensure log directory exists
      */
-    HeadlessWorkerExecutor.prototype.ensureLogDir = function () {
+    ensureLogDir() {
         try {
             if (!existsSync(this.config.logDir)) {
                 mkdirSync(this.config.logDir, { recursive: true });
             }
         }
         catch (error) {
-            this.emit('warning', { message: 'Failed to create log directory', error: error });
+            this.emit('warning', { message: 'Failed to create log directory', error });
         }
-    };
+    }
     /**
      * Internal execution logic
      */
-    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*/];
-                }
+    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,
             });
-        });
-    };
+            // 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
      */
-    HeadlessWorkerExecutor.prototype.processQueue = function () {
+    processQueue() {
         while (this.pendingQueue.length > 0 &&
             this.processPool.size < this.config.maxConcurrent) {
-            var next = this.pendingQueue.shift();
+            const 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
      */
-    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];
+    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,
             });
-        });
-    };
+        }
+        return contextContent;
+    }
     /**
      * Simple glob implementation for file matching
      */
-    HeadlessWorkerExecutor.prototype.simpleGlob = function (pattern) {
-        var _this = this;
-        var results = [];
+    simpleGlob(pattern) {
+        const results = [];
         // Handle simple patterns (no wildcards)
         if (!pattern.includes('*')) {
-            var fullPath = join(this.projectRoot, pattern);
+            const fullPath = join(this.projectRoot, pattern);
             if (existsSync(fullPath)) {
                 results.push(pattern);
             }
             return results;
         }
         // Parse pattern parts
-        var parts = pattern.split('/');
-        var scanDir = function (dir, remainingParts) {
+        const parts = pattern.split('/');
+        const scanDir = (dir, remainingParts) => {
             if (remainingParts.length === 0)
                 return;
             if (results.length >= 100)
                 return; // Limit results
             try {
-                var fullDir = join(_this.projectRoot, dir);
+                const fullDir = join(this.projectRoot, dir);
                 if (!existsSync(fullDir))
                     return;
-                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];
+                const entries = readdirSync(fullDir, { withFileTypes: true });
+                const currentPart = remainingParts[0];
+                const isLastPart = remainingParts.length === 1;
+                for (const entry of entries) {
                     // Skip common non-code directories
                     if (entry.name === 'node_modules' ||
                         entry.name === '.git' ||
@@ -755,7 +718,7 @@ var HeadlessWorkerExecutor = /** @class */ (function (_super) {
                         entry.name === '.cache') {
                         continue;
                     }
-                    var entryPath = dir ? dir + "/" + entry.name : entry.name;
+                    const entryPath = dir ? `${dir}/${entry.name}` : entry.name;
                     if (currentPart === '**') {
                         // Recursive glob
                         if (entry.isDirectory()) {
@@ -764,13 +727,13 @@ var HeadlessWorkerExecutor = /** @class */ (function (_super) {
                         }
                         else if (entry.isFile() && remainingParts.length > 1) {
                             // Check if file matches next pattern part
-                            var nextPart = remainingParts[1];
-                            if (_this.matchesPattern(entry.name, nextPart)) {
+                            const 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);
                         }
@@ -780,17 +743,17 @@ var HeadlessWorkerExecutor = /** @class */ (function (_super) {
                     }
                 }
             }
-            catch (_a) {
+            catch {
                 // Skip unreadable directories
             }
         };
         scanDir('', parts);
         return results;
-    };
+    }
     /**
      * Match filename against a simple pattern
      */
-    HeadlessWorkerExecutor.prototype.matchesPattern = function (name, pattern) {
+    matchesPattern(name, pattern) {
         if (pattern === '*')
             return true;
         if (pattern === '**')
@@ -809,39 +772,53 @@ var HeadlessWorkerExecutor = /** @class */ (function (_super) {
         }
         // Exact match
         return name === pattern;
-    };
+    }
     /**
      * Build full prompt with context
      */
-    HeadlessWorkerExecutor.prototype.buildPrompt = function (template, context) {
+    buildPrompt(template, context) {
         if (!context) {
-            return template + "\n\n## Instructions\n\nAnalyze the codebase and provide your response following the format specified in the task.";
+            return `${template}
+
+## Instructions
+
+Analyze the codebase 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.";
-    };
+        return `${template}
+
+## Codebase Context
+
+${context}
+
+## Instructions
+
+Analyze the above codebase context and provide your response following the format specified in the task.`;
+    }
     /**
      * Execute Claude Code in headless mode
      */
-    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 });
+    executeClaudeCode(prompt, options) {
+        return new Promise((resolve) => {
+            const env = {
+                ...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
-            var child = spawn('claude', ['--print', prompt], {
-                cwd: _this.projectRoot,
-                env: env,
+            const child = spawn('claude', ['--print', prompt], {
+                cwd: this.projectRoot,
+                env,
                 stdio: ['pipe', 'pipe', 'pipe'],
-                windowsHide: true
+                windowsHide: true, // Prevent phantom console windows on Windows
             });
             // Setup timeout
-            var timeoutHandle = setTimeout(function () {
-                if (_this.processPool.has(options.executionId)) {
+            const timeoutHandle = setTimeout(() => {
+                if (this.processPool.has(options.executionId)) {
                     child.kill('SIGTERM');
                     // Give it a moment to terminate gracefully
-                    setTimeout(function () {
+                    setTimeout(() => {
                         if (!child.killed) {
                             child.kill('SIGKILL');
                         }
@@ -849,40 +826,40 @@ var HeadlessWorkerExecutor = /** @class */ (function (_super) {
                 }
             }, options.timeoutMs);
             // Track in process pool
-            var poolEntry = {
+            const poolEntry = {
                 process: child,
                 executionId: options.executionId,
                 workerType: options.workerType,
                 startTime: new Date(),
-                timeout: timeoutHandle
+                timeout: timeoutHandle,
             };
-            _this.processPool.set(options.executionId, poolEntry);
-            var stdout = '';
-            var stderr = '';
-            var resolved = false;
-            var cleanup = function () {
+            this.processPool.set(options.executionId, poolEntry);
+            let stdout = '';
+            let stderr = '';
+            let resolved = false;
+            const cleanup = () => {
                 clearTimeout(timeoutHandle);
-                _this.processPool["delete"](options.executionId);
+                this.processPool.delete(options.executionId);
             };
-            (_a = child.stdout) === null || _a === void 0 ? void 0 : _a.on('data', function (data) {
-                var chunk = data.toString();
+            child.stdout?.on('data', (data) => {
+                const chunk = data.toString();
                 stdout += chunk;
-                _this.emit('output', {
+                this.emit('output', {
                     executionId: options.executionId,
                     type: 'stdout',
-                    data: chunk
+                    data: chunk,
                 });
             });
-            (_b = child.stderr) === null || _b === void 0 ? void 0 : _b.on('data', function (data) {
-                var chunk = data.toString();
+            child.stderr?.on('data', (data) => {
+                const chunk = data.toString();
                 stderr += chunk;
-                _this.emit('output', {
+                this.emit('output', {
                     executionId: options.executionId,
                     type: 'stderr',
-                    data: chunk
+                    data: chunk,
                 });
             });
-            child.on('close', function (code) {
+            child.on('close', (code) => {
                 if (resolved)
                     return;
                 resolved = true;
@@ -890,10 +867,10 @@ var HeadlessWorkerExecutor = /** @class */ (function (_super) {
                 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', function (error) {
+            child.on('error', (error) => {
                 if (resolved)
                     return;
                 resolved = true;
@@ -901,14 +878,14 @@ var HeadlessWorkerExecutor = /** @class */ (function (_super) {
                 resolve({
                     success: false,
                     output: '',
-                    error: error.message
+                    error: error.message,
                 });
             });
             // Handle timeout
-            setTimeout(function () {
+            setTimeout(() => {
                 if (resolved)
                     return;
-                if (!_this.processPool.has(options.executionId))
+                if (!this.processPool.has(options.executionId))
                     return;
                 resolved = true;
                 child.kill('SIGTERM');
@@ -916,57 +893,56 @@ var HeadlessWorkerExecutor = /** @class */ (function (_super) {
                 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
      */
-    HeadlessWorkerExecutor.prototype.parseJsonOutput = function (output) {
+    parseJsonOutput(output) {
         try {
             // Try to find JSON in code blocks first
-            var codeBlockMatch = output.match(/```(?:json)?\s*([\s\S]*?)```/);
+            const codeBlockMatch = output.match(/```(?:json)?\s*([\s\S]*?)```/);
             if (codeBlockMatch) {
                 return JSON.parse(codeBlockMatch[1].trim());
             }
             // Try to find any JSON object
-            var jsonMatch = output.match(/\{[\s\S]*\}/);
+            const jsonMatch = output.match(/\{[\s\S]*\}/);
             if (jsonMatch) {
                 return JSON.parse(jsonMatch[0]);
             }
             // Try direct parse
             return JSON.parse(output.trim());
         }
-        catch (_a) {
+        catch {
             return {
                 parseError: true,
-                rawOutput: output
+                rawOutput: output,
             };
         }
-    };
+    }
     /**
      * Parse markdown output into sections
      */
-    HeadlessWorkerExecutor.prototype.parseMarkdownOutput = function (output) {
-        var sections = [];
-        var codeBlocks = [];
+    parseMarkdownOutput(output) {
+        const sections = [];
+        const codeBlocks = [];
         // Extract code blocks first
-        var codeBlockRegex = /```(\w*)\n([\s\S]*?)```/g;
-        var codeMatch;
+        const codeBlockRegex = /```(\w*)\n([\s\S]*?)```/g;
+        let codeMatch;
         while ((codeMatch = codeBlockRegex.exec(output)) !== null) {
             codeBlocks.push({
                 language: codeMatch[1] || 'text',
-                code: codeMatch[2].trim()
+                code: codeMatch[2].trim(),
             });
         }
         // Parse sections
-        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+(.+)$/);
+        const lines = output.split('\n');
+        let currentSection = null;
+        for (const line of lines) {
+            const headerMatch = line.match(/^(#{1,6})\s+(.+)$/);
             if (headerMatch) {
                 if (currentSection) {
                     sections.push(currentSection);
@@ -974,7 +950,7 @@ var HeadlessWorkerExecutor = /** @class */ (function (_super) {
                 currentSection = {
                     title: headerMatch[2].trim(),
                     content: '',
-                    level: headerMatch[1].length
+                    level: headerMatch[1].length,
                 };
             }
             else if (currentSection) {
@@ -985,41 +961,39 @@ var HeadlessWorkerExecutor = /** @class */ (function (_super) {
             currentSection.content = currentSection.content.trim();
             sections.push(currentSection);
         }
-        return { sections: sections, codeBlocks: codeBlocks };
-    };
+        return { sections, codeBlocks };
+    }
     /**
      * Create an error result
      */
-    HeadlessWorkerExecutor.prototype.createErrorResult = function (workerType, error) {
+    createErrorResult(workerType, error) {
         return {
             success: false,
             output: '',
             durationMs: 0,
             model: 'unknown',
             sandboxMode: 'strict',
-            workerType: workerType,
+            workerType,
             timestamp: new Date(),
-            executionId: "error_" + Date.now(),
-            error: error
+            executionId: `error_${Date.now()}`,
+            error,
         };
-    };
+    }
     /**
      * Log execution details for debugging
      */
-    HeadlessWorkerExecutor.prototype.logExecution = function (executionId, type, content) {
+    logExecution(executionId, type, content) {
         try {
-            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";
+            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`;
             writeFileSync(logFile, logContent);
         }
-        catch (_a) {
+        catch {
             // Ignore log write errors
         }
-    };
-    return HeadlessWorkerExecutor;
-}(EventEmitter));
-export { HeadlessWorkerExecutor };
+    }
+}
 // Export default
 export default HeadlessWorkerExecutor;
 //# sourceMappingURL=headless-worker-executor.js.map