@mohantn/gate-keeper 2.2.0 → 2.2.2

package/dist/quality-loop/orchestrator.js

@@ -1,894 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.QualityOrchestrator = void 0;
-exports.loadQualityConfig = loadQualityConfig;
-exports.saveQualityConfig = saveQualityConfig;
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const os = __importStar(require("os"));
-const child_process_1 = require("child_process");
-const queue_manager_1 = require("./queue-manager");
-const file_lock_1 = require("./file-lock");
-const fix_worker_1 = require("./fix-worker");
-const QUALITY_CONFIG_PATH = path.join(process.env.HOME ?? '/tmp', '.gate-keeper', 'quality-config.json');
-class QualityOrchestrator {
-    config;
-    cache;
-    queue;
-    locks;
-    callbacks;
-    /** Tracks auto-scheduled workers (orchestrator-driven) */
-    activeWorkers = new Map();
-    /** Tracks manual executions triggered from the dashboard */
-    manualExecutions = new Map();
-    paused = false;
-    stopped = false;
-    checkpointTimer = null;
-    heartbeatTimer = null;
-    loopPromise = null;
-    filesFixed = 0;
-    workerCounter = 0;
-    constructor(config, cache, callbacks) {
-        this.config = config;
-        this.cache = cache;
-        this.queue = new queue_manager_1.QueueManager(cache);
-        this.locks = new file_lock_1.FileLockManager(cache);
-        this.callbacks = callbacks;
-    }
-    get isRunning() {
-        return this.loopPromise !== null && !this.stopped;
-    }
-    get isPaused() {
-        return this.paused;
-    }
-    get stats() {
-        return this.queue.getStats();
-    }
-    start() {
-        if (this.loopPromise) {
-            console.error('[quality-loop] Already running');
-            return;
-        }
-        this.stopped = false;
-        this.paused = false;
-        this.loopPromise = this.run();
-        this.loopPromise.catch(err => {
-            console.error('[quality-loop] Fatal loop error:', err);
-            this.stop();
-        });
-        console.error('[quality-loop] Orchestrator started');
-    }
-    stop() {
-        this.stopped = true;
-        console.error('[quality-loop] Stopping...');
-    }
-    pause() {
-        this.paused = true;
-        console.error('[quality-loop] Paused');
-    }
-    resume() {
-        this.paused = false;
-        console.error('[quality-loop] Resumed');
-    }
-    enqueueRepos() {
-        return this.buildQueue();
-    }
-    resetFailed() {
-        return this.queue.resetFailed();
-    }
-    getQueueItems() {
-        return this.queue.getAllItems();
-    }
-    getAttempts(queueId) {
-        return this.cache.quality.getAttemptLogWithOutput(queueId);
-    }
-    getTrends() {
-        const rows = this.cache.quality.getTrends();
-        return rows.map(r => ({
-            id: r.id,
-            repo: r.repo,
-            overallRating: r.overall_rating,
-            filesTotal: r.files_total,
-            filesPassed: r.files_passed,
-            filesFailed: r.files_failed,
-            filesPending: r.files_pending,
-            recordedAt: r.recorded_at,
-        }));
-    }
-    updateConfig(partial) {
-        if (partial.threshold != null)
-            this.config.threshold = partial.threshold;
-        if (partial.maxWorkers != null)
-            this.config.maxWorkers = partial.maxWorkers;
-        if (partial.maxAttemptsPerFile != null)
-            this.config.maxAttemptsPerFile = partial.maxAttemptsPerFile;
-        if (partial.workerMode != null)
-            this.config.workerMode = partial.workerMode;
-        if (partial.repos != null)
-            this.config.repos = partial.repos;
-        if (partial.checkpointIntervalSec != null)
-            this.config.checkpointIntervalSec = partial.checkpointIntervalSec;
-        if (partial.heartbeatIntervalSec != null)
-            this.config.heartbeatIntervalSec = partial.heartbeatIntervalSec;
-        // Persist to disk
-        try {
-            fs.writeFileSync(QUALITY_CONFIG_PATH, JSON.stringify(this.config, null, 2), 'utf8');
-        }
-        catch { /* non-fatal */ }
-        this.log(`Config updated: threshold=${this.config.threshold} workers=${this.config.maxWorkers}`);
-    }
-    getConfig() {
-        return { ...this.config };
-    }
-    // ── Manual execution (dashboard-triggered) ──────────────────────────────────
-    /**
-     * Look up repo metadata to determine session type.
-     * Returns 'claude', 'github-copilot', or 'unknown'.
-     */
-    getRepoSessionType(repo) {
-        try {
-            const meta = this.cache.getRepositoryByPath(repo);
-            return meta?.sessionType ?? 'unknown';
-        }
-        catch {
-            return 'unknown';
-        }
-    }
-    /**
-     * Generate a human-readable command string for a queue item.
-     */
-    getCmdForItem(itemId) {
-        const item = this.queue.getItem(itemId);
-        if (!item)
-            return null;
-        const sessionType = this.getRepoSessionType(item.repo);
-        const shortFile = path.basename(item.filePath);
-        if (sessionType === 'github-copilot') {
-            return { cmd: `gh copilot suggest "fix violations in ${shortFile}"`, sessionType };
-        }
-        return {
-            cmd: `claude --dangerously-skip-permissions "fix all violations in @${shortFile}"`,
-            sessionType,
-        };
-    }
-    /**
-     * Execute a single queue item manually from the dashboard.
-     * Opens a real terminal window and polls a status file for completion.
-     */
-    async executeItem(itemId) {
-        const item = this.queue.getItem(itemId);
-        if (!item)
-            return { ok: false, workerId: null, error: 'Queue item not found' };
-        if (item.status === 'in_progress')
-            return { ok: false, workerId: null, error: 'Item already in progress' };
-        // Mark as in_progress
-        const workerId = `manual-${itemId}-${Date.now()}`;
-        this.queue.markInProgress(itemId, workerId);
-        this.broadcastItem(itemId);
-        // Generate the fix prompt
-        const prompt = await this.generateFixPrompt(item.filePath, item.repo);
-        if (!prompt) {
-            this.queue.markFailed(itemId, 'Could not generate fix prompt');
-            this.broadcastItem(itemId);
-            return { ok: false, workerId: null, error: 'Could not fetch analysis for file' };
-        }
-        const sessionType = this.getRepoSessionType(item.repo);
-        const claudePath = this.resolveClaudePath();
-        // Write prompt + bash script to temp files
-        const id = `gk-manual-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`;
-        const tmp = os.tmpdir();
-        const promptFile = path.join(tmp, `${id}.prompt`);
-        const statusFile = path.join(tmp, `${id}.status`);
-        const logFile = path.join(tmp, `${id}.log`);
-        const scriptFile = path.join(tmp, `${id}.sh`);
-        try {
-            fs.writeFileSync(promptFile, prompt, 'utf8');
-            this.writeTerminalScript(scriptFile, { promptFile, statusFile, logFile, claudePath, repo: item.repo, sessionType });
-        }
-        catch (err) {
-            this.queue.markFailed(itemId, 'Could not write script files');
-            this.broadcastItem(itemId);
-            return { ok: false, workerId: null, error: 'Could not write script files' };
-        }
-        this.log(`Manual execute: ${claudePath} for ${path.basename(item.filePath)} (${sessionType})`);
-        // Open a real terminal window
-        const opened = this.openTerminal(scriptFile);
-        if (!opened) {
-            this.queue.markFailed(itemId, 'Could not open terminal');
-            this.broadcastItem(itemId);
-            this.cleanupFiles(promptFile, statusFile, logFile, scriptFile);
-            return { ok: false, workerId: null, error: 'Could not open terminal' };
-        }
-        const execution = {
-            workerId,
-            queueId: itemId,
-            filePath: item.filePath,
-            repo: item.repo,
-            outputFile: logFile,
-            statusFile,
-            scriptFile,
-            promptFile,
-            startTime: Date.now(),
-            running: true,
-            exitCode: null,
-        };
-        this.manualExecutions.set(workerId, execution);
-        // Poll for completion in the background
-        this.pollManualCompletion(workerId);
-        return { ok: true, workerId };
-    }
-    /**
-     * Cancel a running manual execution by writing an abort marker to the status file.
-     * The polling loop detects it and cleans up.
-     */
-    cancelExecution(workerId) {
-        const exec = this.manualExecutions.get(workerId);
-        if (!exec || !exec.running)
-            return false;
-        exec.running = false;
-        exec.exitCode = -1;
-        if (exec.pollTimer)
-            clearInterval(exec.pollTimer);
-        // Write cancelled marker so polling loop won't treat it as a real exit
-        try {
-            fs.writeFileSync(exec.statusFile, JSON.stringify({ exitCode: -1, timestamp: Math.floor(Date.now() / 1000) }), 'utf8');
-        }
-        catch { /* ignore */ }
-        this.queue.markFailed(exec.queueId, 'Cancelled by user');
-        this.broadcastItem(exec.queueId);
-        this.cleanupFiles(exec.outputFile, exec.statusFile, exec.scriptFile, exec.promptFile);
-        this.manualExecutions.delete(workerId);
-        this.log(`Manual execution cancelled: ${workerId}`);
-        return true;
-    }
-    /**
-     * Delete a queue item (remove from database).
-     */
-    deleteQueueItem(itemId) {
-        for (const [wid, exec] of this.manualExecutions) {
-            if (exec.queueId === itemId && exec.running) {
-                exec.running = false;
-                exec.exitCode = -1;
-                if (exec.pollTimer)
-                    clearInterval(exec.pollTimer);
-                try {
-                    fs.writeFileSync(exec.statusFile, JSON.stringify({ exitCode: -1, timestamp: Math.floor(Date.now() / 1000) }), 'utf8');
-                }
-                catch { /* ignore */ }
-                this.manualExecutions.delete(wid);
-            }
-        }
-        try {
-            this.cache.quality.updateQueueItem(itemId, { status: 'skipped' });
-            this.broadcast({ type: 'queue_update', queueItem: this.queue.getItem(itemId) ?? undefined });
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    /**
-     * Get the current output of a running manual execution.
-     */
-    getExecutionOutput(workerId) {
-        const exec = this.manualExecutions.get(workerId);
-        if (!exec)
-            return null;
-        return {
-            output: this.readOutputFile(exec.outputFile),
-            running: exec.running,
-            exitCode: exec.exitCode,
-            startTime: exec.startTime,
-        };
-    }
-    // ── Manual execution helpers ─────────────────────────────────────────────────
-    async generateFixPrompt(filePath, repo) {
-        try {
-            const url = `http://127.0.0.1:5378/api/file-detail?file=${encodeURIComponent(filePath)}&repo=${encodeURIComponent(repo)}`;
-            const res = await fetch(url);
-            if (!res.ok)
-                return null;
-            const data = await res.json();
-            if (!data.analysis)
-                return null;
-            const { rating, violations } = data.analysis;
-            const numbered = violations.map((v, i) => {
-                const fixStr = typeof v.fix === 'string' ? v.fix : '';
-                return `${i + 1}. [${v.severity.toUpperCase()}]${v.line ? ` (line ${v.line})` : ''}: ${v.message}${fixStr ? `\n   Fix: ${fixStr}` : ''}`;
-            }).join('\n');
-            return `fix all violations in @${filePath}\nFile: ${filePath}\nRating: ${rating}/10\nViolations: ${violations.length}\n\n${numbered}`;
-        }
-        catch {
-            return null;
-        }
-    }
-    resolveClaudePath() {
-        const candidates = [
-            'claude',
-            '/home/mohantn/.local/bin/claude',
-            '/usr/local/bin/claude',
-            `${os.homedir()}/.npm-global/bin/claude`,
-            `${os.homedir()}/.npm-packages/bin/claude`,
-        ];
-        for (const c of candidates) {
-            try {
-                if (fs.existsSync(c))
-                    return c;
-            }
-            catch { /* ignore */ }
-        }
-        try {
-            const resolved = (0, child_process_1.execSync)('which claude 2>/dev/null', { encoding: 'utf8', timeout: 2000 }).trim();
-            if (resolved)
-                return resolved;
-        }
-        catch { /* ignore */ }
-        return 'claude';
-    }
-    async reanalyzeFile(filePath, repo) {
-        try {
-            const res = await fetch(`http://127.0.0.1:5379/analyze`, {
-                method: 'POST',
-                headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify({ filePath, repoRoot: repo }),
-            });
-            if (!res.ok)
-                return null;
-            const data = await res.json();
-            return data.analysis ?? null;
-        }
-        catch {
-            return null;
-        }
-    }
-    readOutputFile(filePath) {
-        try {
-            return fs.readFileSync(filePath, 'utf8');
-        }
-        catch {
-            return '';
-        }
-    }
-    cleanupFiles(...files) {
-        for (const f of files) {
-            try {
-                fs.unlinkSync(f);
-            }
-            catch { /* ignore */ }
-        }
-    }
-    // ── Terminal helpers (reuse the same pattern as FixWorker) ────────────────────
-    /** Write the bash script that will run inside the terminal window. */
-    writeTerminalScript(scriptPath, opts) {
-        const cmd = opts.sessionType === 'github-copilot'
-            ? `gh copilot suggest "fix violations in $(cat '${opts.promptFile}')"`
-            : `"${opts.claudePath}" --dangerously-skip-permissions "$(cat '${opts.promptFile}')"`;
-        fs.writeFileSync(scriptPath, `#!/usr/bin/env bash
-# Note: this script is invoked via "bash -i" so ~/.bashrc is sourced automatically.
-set -uo pipefail
-
-STATUS_FILE='${opts.statusFile}'
-LOG_FILE='${opts.logFile}'
-REPO='${opts.repo}'
-
-EXIT_CODE=0
-
-on_exit() {
-  local last=$?
-  [ "$last" -ne 0 ] && [ "$EXIT_CODE" -eq 0 ] && EXIT_CODE=$last
-  printf '{"exitCode":%d,"timestamp":%d}' "$EXIT_CODE" "$(date +%s)" > "$STATUS_FILE" 2>/dev/null || true
-}
-trap on_exit EXIT
-
-cd "$REPO"
-
-${cmd} 2>&1 | tee "$LOG_FILE" || EXIT_CODE=$?
-
-echo ""
-echo "────────────────────────────────────────────"
-if [ "$EXIT_CODE" -eq 0 ]; then
-  echo "  Claude fix finished — press Enter to close"
-else
-  echo "  Claude exited with code $EXIT_CODE — press Enter to close"
-fi
-echo "────────────────────────────────────────────"
-read -r || true
-`, 'utf8');
-        fs.chmodSync(scriptPath, 0o755);
-    }
-    /** Open a real terminal window running the given script. */
-    openTerminal(scriptPath) {
-        if (this.isWSL()) {
-            // Strategy 1: cmd.exe /c start — opens a new CMD window (most reliable on WSL)
-            // Use cmd /k to keep the window open after the script exits
-            try {
-                (0, child_process_1.spawn)('cmd.exe', ['/c', 'start', '', 'cmd', '/k', 'wsl.exe', 'bash', '-i', scriptPath], { detached: true, stdio: 'ignore' }).unref();
-                return true;
-            }
-            catch { /* try next */ }
-            // Strategy 2: Windows Terminal (wt.exe)
-            try {
-                (0, child_process_1.execSync)('command -v wt.exe 2>/dev/null', { timeout: 1000 });
-                (0, child_process_1.spawn)('wt.exe', ['-w', '0', 'nt', '--', 'wsl.exe', 'bash', '-i', scriptPath], { detached: true, stdio: 'ignore' }).unref();
-                return true;
-            }
-            catch { /* try next */ }
-            // Strategy 3: powershell Start-Process
-            try {
-                (0, child_process_1.spawn)('powershell.exe', ['-NoProfile', '-Command',
-                    `Start-Process cmd -ArgumentList '/k wsl.exe bash -i \\"${scriptPath}\\"'`], { detached: true, stdio: 'ignore' }).unref();
-                return true;
-            }
-            catch {
-                return false;
-            }
-        }
-        const terminals = [
-            ['gnome-terminal', ['--', 'bash', scriptPath]],
-            ['konsole', ['--hold', '-e', 'bash', scriptPath]],
-            ['xterm', ['-e', `bash "${scriptPath}"`]],
-            ['x-terminal-emulator', ['-e', `bash "${scriptPath}"`]],
-        ];
-        for (const [bin, args] of terminals) {
-            try {
-                (0, child_process_1.execSync)(`command -v ${bin} 2>/dev/null`, { timeout: 1000 });
-                (0, child_process_1.spawn)(bin, args, { detached: true, stdio: 'ignore' }).unref();
-                return true;
-            }
-            catch { /* not found */ }
-        }
-        return false;
-    }
-    isWSL() {
-        if (process.env['WSL_DISTRO_NAME'])
-            return true;
-        try {
-            const v = fs.readFileSync('/proc/version', 'utf8').toLowerCase();
-            return v.includes('microsoft') || v.includes('wsl');
-        }
-        catch {
-            return false;
-        }
-    }
-    /** Poll the status file every 3 seconds until the terminal script writes a result. */
-    pollManualCompletion(workerId) {
-        const exec = this.manualExecutions.get(workerId);
-        if (!exec)
-            return;
-        const startTime = Date.now();
-        const POLL_MS = 3000;
-        const MAX_WAIT = 600_000; // 10 minutes for manual execution
-        const poll = async () => {
-            const e = this.manualExecutions.get(workerId);
-            if (!e || !e.running)
-                return;
-            // Timeout check
-            if (Date.now() - startTime > MAX_WAIT) {
-                e.running = false;
-                e.exitCode = null;
-                this.queue.markFailed(e.queueId, 'Manual execution timed out');
-                this.broadcastItem(e.queueId);
-                this.cleanupFiles(e.outputFile, e.statusFile, e.scriptFile, e.promptFile);
-                this.manualExecutions.delete(workerId);
-                return;
-            }
-            // Check status file
-            let status = null;
-            try {
-                if (fs.existsSync(e.statusFile)) {
-                    status = JSON.parse(fs.readFileSync(e.statusFile, 'utf8'));
-                }
-            }
-            catch { /* not written yet */ }
-            if (status !== null) {
-                clearInterval(e.pollTimer);
-                e.running = false;
-                e.exitCode = status.exitCode;
-                const fullOutput = this.readOutputFile(e.outputFile);
-                const analysis = await this.reanalyzeFile(e.filePath, e.repo);
-                const newRating = analysis?.rating ?? 0;
-                const violationsRemaining = analysis?.violations.length ?? 0;
-                this.cache.quality.logAttempt({
-                    queueId: e.queueId,
-                    attempt: 1, // approximate
-                    ratingBefore: 0,
-                    ratingAfter: newRating,
-                    violationsFixed: 0,
-                    violationsRemaining,
-                    fixSummary: status.exitCode === 0 ? `Manual fix completed (exit ${status.exitCode})` : `Manual fix failed (exit ${status.exitCode})`,
-                    errorMessage: status.exitCode !== 0 ? `Process exited with code ${status.exitCode}` : undefined,
-                    durationMs: Date.now() - e.startTime,
-                    workerOutput: fullOutput,
-                });
-                if (status.exitCode === 0 && newRating >= this.config.threshold) {
-                    this.queue.markCompleted(e.queueId, newRating);
-                }
-                else if (status.exitCode !== 0) {
-                    this.queue.markFailed(e.queueId, `Manual fix exited with code ${status.exitCode}`);
-                }
-                else {
-                    this.queue.markFailed(e.queueId, `Rating ${newRating} below threshold ${this.config.threshold}`);
-                }
-                this.broadcastItem(e.queueId);
-                this.cleanupFiles(e.outputFile, e.statusFile, e.scriptFile, e.promptFile);
-                this.manualExecutions.delete(workerId);
-            }
-        };
-        exec.pollTimer = setInterval(poll, POLL_MS);
-    }
-    async run() {
-        this.log('Quality loop started');
-        // 1. Try restore from checkpoint
-        const restored = this.queue.restoreFromCheckpoint();
-        if (restored.length > 0) {
-            this.log(`Restored ${restored.length} items from checkpoint`);
-        }
-        // 2. Build queue from repos
-        await this.buildQueue();
-        // 3. Start timers
-        this.startHeartbeat();
-        this.startCheckpoints();
-        // 4. Main loop
-        while (!this.stopped) {
-            if (this.paused) {
-                await this.sleep(2000);
-                continue;
-            }
-            // Clean stale locks
-            this.locks.clearStale();
-            // Get stats
-            const stats = this.queue.getStats();
-            this.broadcastProgress(stats);
-            // Check completion
-            if (stats.pending === 0 && stats.inProgress === 0) {
-                if (stats.failed > 0 || stats.skipped > 0) {
-                    this.log(`Loop complete: ${stats.completed} passed, ${stats.failed} failed, ${stats.skipped} skipped`);
-                }
-                else {
-                    this.log(`ALL ${stats.completed} files pass threshold!`);
-                }
-                await this.saveFinalCheckpoint('complete');
-                break;
-            }
-            // Calculate available slots
-            const slots = this.config.maxWorkers - this.activeWorkers.size;
-            if (slots <= 0) {
-                await this.waitForAnyWorker();
-                continue;
-            }
-            // Pick next files
-            const candidates = this.queue.pickNext(slots, this.locks.getLockedPaths());
-            if (candidates.length === 0) {
-                // All pending files are locked — wait
-                await this.sleep(1000);
-                continue;
-            }
-            // Spawn workers
-            for (const item of candidates) {
-                if (this.stopped)
-                    break;
-                const workerId = `w${++this.workerCounter}-${item.id}`;
-                if (!this.locks.acquire(item.filePath, workerId))
-                    continue;
-                this.queue.markInProgress(item.id, workerId);
-                this.broadcastItem(item.id);
-                const workerStartTime = Date.now();
-                const promise = this.runWorker(item.id, item.filePath, workerId, workerStartTime);
-                const timeout = setTimeout(() => {
-                    this.log(`Worker ${workerId} timed out for ${path.basename(item.filePath)}`);
-                    this.handleWorkerTimeout(workerId);
-                }, 300_000); // 5 min hard limit
-                this.activeWorkers.set(workerId, {
-                    queueId: item.id,
-                    filePath: item.filePath,
-                    promise,
-                    startTime: workerStartTime,
-                    timeout,
-                });
-                this.broadcast({
-                    type: 'worker_activity',
-                    workerAction: 'start',
-                    workerFilePath: item.filePath,
-                    workerId,
-                });
-                // Handle completion
-                promise.finally(() => {
-                    clearTimeout(timeout);
-                    this.activeWorkers.delete(workerId);
-                });
-            }
-            // Wait for a worker slot if all full
-            if (this.activeWorkers.size >= this.config.maxWorkers) {
-                await this.waitForAnyWorker();
-            }
-            else {
-                await this.sleep(500);
-            }
-        }
-        // 5. Shutdown
-        this.cleanup();
-    }
-    async runWorker(queueId, filePath, workerId, startTime) {
-        let result;
-        try {
-            const worker = new fix_worker_1.FixWorker({
-                filePath,
-                repo: this.resolveRepo(filePath),
-                threshold: this.config.threshold,
-            });
-            result = await worker.fix();
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            result = {
-                success: false,
-                newRating: 0,
-                ratingBefore: 0,
-                violationsRemaining: 0,
-                violationsFixed: 0,
-                durationMs: Date.now() - startTime,
-                attemptNumber: 0,
-                fixSummary: '',
-                error: message,
-                shouldRetry: false,
-            };
-        }
-        // Release file lock
-        this.locks.release(filePath, workerId);
-        // Log attempt
-        this.cache.quality.logAttempt({
-            queueId,
-            attempt: result.attemptNumber,
-            ratingBefore: result.ratingBefore,
-            ratingAfter: result.newRating,
-            violationsFixed: result.violationsFixed,
-            violationsRemaining: result.violationsRemaining,
-            fixSummary: result.fixSummary,
-            errorMessage: result.error,
-            durationMs: result.durationMs,
-            workerOutput: result.workerOutput,
-        });
-        // Update queue item
-        if (result.success) {
-            this.queue.markCompleted(queueId, result.newRating);
-            this.filesFixed++;
-        }
-        else {
-            this.queue.markFailed(queueId, result.error || 'Unknown error');
-        }
-        // Record trend
-        const stats = this.queue.getStats();
-        this.queue.recordTrend(this.config.repos.join(','), this.getOverallRating(), this.getTotalFiles(), stats);
-        // Broadcast
-        this.broadcast({
-            type: 'worker_activity',
-            workerAction: result.success ? 'complete' : 'error',
-            workerFilePath: filePath,
-            workerId,
-            workerRating: result.newRating,
-            workerSuccess: result.success,
-            workerError: result.error,
-        });
-        this.broadcastItem(queueId);
-        const relPath = path.basename(filePath);
-        if (result.success) {
-            this.log(`[OK] ${relPath}: ${result.ratingBefore} → ${result.newRating} (${result.durationMs}ms, ${result.attemptNumber} cycle(s))`);
-        }
-        else {
-            this.log(`[FAIL] ${relPath}: ${result.ratingBefore} → ${result.newRating} — ${result.error ?? 'Max attempts'} (${result.durationMs}ms)`);
-        }
-    }
-    resolveRepo(filePath) {
-        // Find the best matching repo from config
-        for (const repo of this.config.repos) {
-            if (filePath.startsWith(repo))
-                return repo;
-        }
-        return this.config.repos[0] ?? path.dirname(filePath);
-    }
-    handleWorkerTimeout(workerId) {
-        const worker = this.activeWorkers.get(workerId);
-        if (!worker)
-            return;
-        this.locks.release(worker.filePath, workerId);
-        this.activeWorkers.delete(workerId);
-    }
-    async buildQueue() {
-        const fileRatings = new Map();
-        const violationCounts = new Map();
-        for (const repo of this.config.repos) {
-            const analyses = this.callbacks.getAnalyzedFiles(repo);
-            for (const a of analyses) {
-                if (a.rating < this.config.threshold) {
-                    fileRatings.set(a.path, { rating: a.rating, repo: repo });
-                }
-            }
-        }
-        this.log(`Found ${fileRatings.size} files below threshold ${this.config.threshold}`);
-        if (fileRatings.size === 0)
-            return 0;
-        return this.queue.buildQueue({
-            repos: this.config.repos,
-            threshold: this.config.threshold,
-            fileRatings,
-            violationCounts,
-        });
-    }
-    startHeartbeat() {
-        const interval = (this.config.heartbeatIntervalSec ?? 10) * 1000;
-        this.heartbeatTimer = setInterval(() => {
-            if (this.stopped)
-                return;
-            const stats = this.queue.getStats();
-            this.broadcastProgress(stats);
-        }, interval);
-    }
-    startCheckpoints() {
-        const interval = (this.config.checkpointIntervalSec ?? 30) * 1000;
-        this.checkpointTimer = setInterval(() => {
-            if (this.stopped)
-                return;
-            this.queue.saveCheckpoint('heartbeat', this.filesFixed, this.getOverallRating());
-        }, interval);
-    }
-    async saveFinalCheckpoint(reason) {
-        this.queue.saveCheckpoint(reason, this.filesFixed, this.getOverallRating());
-        const stats = this.queue.getStats();
-        this.broadcast({
-            type: 'queue_progress',
-            queueStats: {
-                total: stats.total,
-                pending: stats.pending,
-                inProgress: stats.inProgress,
-                completed: stats.completed,
-                failed: stats.failed,
-                skipped: stats.skipped,
-            },
-            queueOverallRating: this.getOverallRating(),
-            queueDone: true,
-        });
-    }
-    broadcastProgress(stats) {
-        this.broadcast({
-            type: 'queue_progress',
-            queueStats: {
-                total: stats.total,
-                pending: stats.pending,
-                inProgress: stats.inProgress,
-                completed: stats.completed,
-                failed: stats.failed,
-                skipped: stats.skipped,
-            },
-            queueOverallRating: this.getOverallRating(),
-            queueDone: stats.pending === 0 && stats.inProgress === 0,
-        });
-    }
-    broadcastItem(itemId) {
-        const item = this.queue.getItem(itemId);
-        if (!item)
-            return;
-        this.broadcast({ type: 'queue_update', queueItem: item });
-    }
-    broadcast(msg) {
-        try {
-            this.callbacks.broadcast(msg);
-        }
-        catch {
-            // Broadcast failures are non-fatal
-        }
-    }
-    async waitForAnyWorker() {
-        if (this.activeWorkers.size === 0)
-            return;
-        // Wait for first worker to complete
-        const workers = Array.from(this.activeWorkers.values());
-        await Promise.race(workers.map(w => w.promise));
-    }
-    getOverallRating() {
-        try {
-            const all = this.cache.getAll();
-            if (all.length === 0)
-                return 10;
-            const sum = all.reduce((a, f) => a + f.rating, 0);
-            return Math.round((sum / all.length) * 10) / 10;
-        }
-        catch {
-            return 10;
-        }
-    }
-    getTotalFiles() {
-        try {
-            const all = this.cache.getAll();
-            return all.length;
-        }
-        catch {
-            return 0;
-        }
-    }
-    cleanup() {
-        if (this.checkpointTimer)
-            clearInterval(this.checkpointTimer);
-        if (this.heartbeatTimer)
-            clearInterval(this.heartbeatTimer);
-        this.checkpointTimer = null;
-        this.heartbeatTimer = null;
-        // Kill any remaining workers (just timeouts)
-        for (const [id, w] of this.activeWorkers) {
-            clearTimeout(w.timeout);
-            this.locks.release(w.filePath, id);
-        }
-        this.activeWorkers.clear();
-        this.locks.clearStale();
-        this.log('Shutdown complete');
-        this.loopPromise = null;
-    }
-    log(msg) {
-        console.error(`[quality-loop] ${msg}`);
-    }
-    sleep(ms) {
-        return new Promise(r => setTimeout(r, ms));
-    }
-}
-exports.QualityOrchestrator = QualityOrchestrator;
-// Load config from disk
-function loadQualityConfig() {
-    try {
-        if (fs.existsSync(QUALITY_CONFIG_PATH)) {
-            const raw = fs.readFileSync(QUALITY_CONFIG_PATH, 'utf8');
-            return JSON.parse(raw);
-        }
-    }
-    catch (err) {
-        console.error(`[quality-loop] Failed to load config: ${err}`);
-    }
-    return {
-        threshold: 7.0,
-        maxWorkers: 2,
-        maxAttemptsPerFile: 3,
-        workerMode: 'auto',
-        repos: [],
-        excludePatterns: ['**/node_modules/**', '**/dist/**', '**/.git/**'],
-        checkpointIntervalSec: 30,
-        heartbeatIntervalSec: 10,
-    };
-}
-// Save config to disk
-function saveQualityConfig(config) {
-    const dir = path.dirname(QUALITY_CONFIG_PATH);
-    fs.mkdirSync(dir, { recursive: true });
-    fs.writeFileSync(QUALITY_CONFIG_PATH, JSON.stringify(config, null, 2), 'utf8');
-}
-//# sourceMappingURL=orchestrator.js.map