salmon-loop 0.2.3

package/dist/core/observability/monitor.js

@@ -0,0 +1,240 @@
+import { text } from '../../locales/index.js';
+import { LIMITS } from '../config/limits.js';
+import { ErrorType } from '../types/index.js';
+import { getLogger } from './logger.js';
+/**
+ * RingBuffer implementation to store a fixed number of recent errors
+ */
+class RingBuffer {
+    capacity;
+    buffer;
+    head = 0;
+    size = 0;
+    constructor(capacity) {
+        this.capacity = capacity;
+        this.buffer = new Array(capacity);
+    }
+    push(item) {
+        this.buffer[this.head] = item;
+        this.head = (this.head + 1) % this.capacity;
+        if (this.size < this.capacity) {
+            this.size++;
+        }
+    }
+    toArray() {
+        const result = [];
+        for (let i = 0; i < this.size; i++) {
+            const index = (this.head - this.size + i + this.capacity) % this.capacity;
+            result.push(this.buffer[index]);
+        }
+        return result;
+    }
+    get length() {
+        return this.size;
+    }
+}
+/**
+ * Monitor class to track errors and generate reports
+ *
+ * Prefer explicit wiring via setMonitor()/getMonitor() at startup.
+ * Tests may also instantiate `new Monitor()` directly for isolation.
+ */
+export class Monitor {
+    errorHistory;
+    checkpointMetrics;
+    applyBackMetrics;
+    constructor() {
+        this.errorHistory = new RingBuffer(LIMITS.maxErrorHistory);
+        this.checkpointMetrics = {
+            createAttempts: 0,
+            createFailures: 0,
+            cleanupAttempts: 0,
+            cleanupFailures: 0,
+        };
+        this.applyBackMetrics = {
+            attempts: 0,
+            failures: 0,
+            totalDuration: 0,
+            durations: [],
+        };
+    }
+    /**
+     * Record an error in the history
+     */
+    recordError(type, message) {
+        this.errorHistory.push({
+            type,
+            message,
+            timestamp: new Date(),
+        });
+    }
+    /**
+     * Generate a formatted error report
+     */
+    getErrorReport() {
+        const errors = this.errorHistory.toArray();
+        if (errors.length === 0) {
+            return text.monitor.noErrors;
+        }
+        let report = `\n=== ${text.monitor.reportTitle} ===\n`;
+        report += `${text.monitor.totalErrors(errors.length)}\n\n`;
+        report += `${text.monitor.recentErrors}\n`;
+        for (const error of errors) {
+            report += `${text.monitor.errorEntry(error.timestamp.toISOString(), error.type, error.message)}\n`;
+        }
+        report += '===========================================\n';
+        return report;
+    }
+    /**
+     * Check memory usage and log warning if it exceeds threshold
+     */
+    checkMemoryUsage() {
+        const memoryUsage = process.memoryUsage();
+        const heapUsedMB = memoryUsage.heapUsed / 1024 / 1024;
+        const thresholdMB = 512;
+        if (heapUsedMB > thresholdMB) {
+            const msg = text.monitor.memoryWarning(heapUsedMB.toFixed(2), thresholdMB.toString());
+            this.recordError(ErrorType.UNKNOWN, msg);
+            getLogger().warn(`[Monitor] ${msg}`);
+            if (global.gc) {
+                getLogger().debug(`[Monitor] ${text.monitor.suggestingGc}`);
+                global.gc();
+            }
+        }
+    }
+    /**
+     * Record checkpoint creation attempt
+     */
+    recordCheckpointCreate(success) {
+        this.checkpointMetrics.createAttempts++;
+        if (!success) {
+            this.checkpointMetrics.createFailures++;
+        }
+    }
+    /**
+     * Record checkpoint cleanup attempt
+     */
+    recordCheckpointCleanup(success) {
+        this.checkpointMetrics.cleanupAttempts++;
+        if (!success) {
+            this.checkpointMetrics.cleanupFailures++;
+        }
+    }
+    /**
+     * Record applyBack operation
+     */
+    recordApplyBack(success, duration) {
+        this.applyBackMetrics.attempts++;
+        if (!success) {
+            this.applyBackMetrics.failures++;
+        }
+        this.applyBackMetrics.totalDuration += duration;
+        this.applyBackMetrics.durations.push(duration);
+        // Keep only last 100 durations to avoid memory bloat
+        if (this.applyBackMetrics.durations.length > 100) {
+            this.applyBackMetrics.durations.shift();
+        }
+    }
+    /**
+     * Get checkpoint creation failure rate (0-1)
+     */
+    getCheckpointCreateFailureRate() {
+        if (this.checkpointMetrics.createAttempts === 0)
+            return 0;
+        return this.checkpointMetrics.createFailures / this.checkpointMetrics.createAttempts;
+    }
+    /**
+     * Get worktree cleanup failure count
+     */
+    getWorktreeCleanupFailureCount() {
+        return this.checkpointMetrics.cleanupFailures;
+    }
+    /**
+     * Get average applyBack duration in milliseconds
+     */
+    getApplyBackAvgDuration() {
+        if (this.applyBackMetrics.attempts === 0)
+            return 0;
+        return this.applyBackMetrics.totalDuration / this.applyBackMetrics.attempts;
+    }
+    /**
+     * Get checkpoint metrics summary
+     */
+    getCheckpointMetrics() {
+        return { ...this.checkpointMetrics };
+    }
+    /**
+     * Get applyBack metrics summary
+     */
+    getApplyBackMetrics() {
+        return {
+            attempts: this.applyBackMetrics.attempts,
+            failures: this.applyBackMetrics.failures,
+            totalDuration: this.applyBackMetrics.totalDuration,
+            durations: [...this.applyBackMetrics.durations],
+        };
+    }
+    /**
+     * Generate metrics report
+     */
+    getMetricsReport() {
+        let report = `\n${text.monitor.metricsTitle}\n`;
+        report += `\n${text.monitor.checkpointCreation}\n`;
+        report += `${text.monitor.attempts(this.checkpointMetrics.createAttempts)}\n`;
+        report += `${text.monitor.failures(this.checkpointMetrics.createFailures)}\n`;
+        report += `${text.monitor.failureRate((this.getCheckpointCreateFailureRate() * 100).toFixed(2))}\n`;
+        report += `\n${text.monitor.worktreeCleanup}\n`;
+        report += `${text.monitor.attempts(this.checkpointMetrics.cleanupAttempts)}\n`;
+        report += `${text.monitor.failures(this.checkpointMetrics.cleanupFailures)}\n`;
+        report += `\n${text.monitor.applyBackOps}\n`;
+        report += `${text.monitor.attempts(this.applyBackMetrics.attempts)}\n`;
+        report += `${text.monitor.failures(this.applyBackMetrics.failures)}\n`;
+        report += `${text.monitor.avgDuration(this.getApplyBackAvgDuration().toFixed(2))}\n`;
+        if (this.applyBackMetrics.durations.length > 0) {
+            const sorted = [...this.applyBackMetrics.durations].sort((a, b) => a - b);
+            const p50 = sorted[Math.floor(sorted.length * 0.5)];
+            const p95 = sorted[Math.floor(sorted.length * 0.95)];
+            report += `${text.monitor.p50Duration(p50.toFixed(2))}\n`;
+            report += `${text.monitor.p95Duration(p95.toFixed(2))}\n`;
+        }
+        report += '======================================\n';
+        return report;
+    }
+    /**
+     * Reset all metrics (useful for testing)
+     */
+    resetMetrics() {
+        this.checkpointMetrics = {
+            createAttempts: 0,
+            createFailures: 0,
+            cleanupAttempts: 0,
+            cleanupFailures: 0,
+        };
+        this.applyBackMetrics = {
+            attempts: 0,
+            failures: 0,
+            totalDuration: 0,
+            durations: [],
+        };
+    }
+}
+export function createMonitor() {
+    return new Monitor();
+}
+let activeMonitor = null;
+export function setMonitor(next) {
+    activeMonitor = next;
+}
+export function getMonitor() {
+    if (!activeMonitor) {
+        throw new Error('Monitor is not initialized. Call setMonitor(createMonitor()) at startup.');
+    }
+    return activeMonitor;
+}
+export function tryGetMonitor() {
+    return activeMonitor;
+}
+export function clearMonitor() {
+    activeMonitor = null;
+}
+//# sourceMappingURL=monitor.js.map

package/dist/core/observability/run-outcome-reporter.js

@@ -0,0 +1,15 @@
+export function buildRunOutcomeReport(result) {
+    return {
+        success: result.success,
+        reason: result.reason,
+        reasonCode: result.reasonCode,
+        diagnosticCode: result.diagnosticCode,
+        safeHint: result.safeHint,
+        remediationSteps: result.remediationSteps,
+        attempts: result.attempts,
+        failurePhase: result.failurePhase,
+        errorCode: result.errorCode,
+        changedFiles: result.changedFiles,
+    };
+}
+//# sourceMappingURL=run-outcome-reporter.js.map

package/dist/core/observability/token-usage.js

@@ -0,0 +1,36 @@
+import { getAuditTrail } from './audit-trail.js';
+function safeFiniteNumber(value) {
+    if (typeof value !== 'number' || !Number.isFinite(value))
+        return null;
+    return value;
+}
+export function extractTokenUsageFromAuditTrail(auditTrail) {
+    let inputTokens = 0;
+    let outputTokens = 0;
+    for (const event of auditTrail) {
+        if (!event || typeof event !== 'object')
+            continue;
+        if (event.action !== 'llm.usage')
+            continue;
+        const details = event.details;
+        if (!details || typeof details !== 'object')
+            continue;
+        const promptTokens = safeFiniteNumber(details.promptTokens);
+        const completionTokens = safeFiniteNumber(details.completionTokens);
+        if (typeof promptTokens === 'number')
+            inputTokens += promptTokens;
+        if (typeof completionTokens === 'number')
+            outputTokens += completionTokens;
+    }
+    if (inputTokens === 0 && outputTokens === 0)
+        return null;
+    return {
+        inputTokens,
+        outputTokens,
+        totalTokens: inputTokens + outputTokens,
+    };
+}
+export function getTokenUsageFromAuditTrail() {
+    return extractTokenUsageFromAuditTrail(getAuditTrail());
+}
+//# sourceMappingURL=token-usage.js.map

package/dist/core/observability/ui-log-sanitize.js

@@ -0,0 +1,35 @@
+import { LIMITS } from '../config/limits.js';
+import { sanitizeErrorMessage } from '../utils/sanitizer.js';
+// eslint-disable-next-line no-control-regex
+const ANSI_REGEX = new RegExp('\\u001b\\[[0-9;]*m', 'g');
+// Heuristic: if a log line looks like a dumped SDK error/object, do not let it through to GUI.
+const TECHNICAL_DUMP_HINT_REGEX = /(AI_RetryError|APICallError|RetryError|ZodError|requestBodyValues|responseBody|\[Symbol\(vercel\.ai\.error)/i;
+function stripControlChars(text) {
+    let result = '';
+    for (let i = 0; i < text.length; i += 1) {
+        const code = text.charCodeAt(i);
+        result += code < 32 || code === 127 ? ' ' : text[i];
+    }
+    return result;
+}
+function truncate(text, maxLen) {
+    if (text.length <= maxLen)
+        return text;
+    return text.slice(0, Math.max(0, maxLen - 3)) + '...';
+}
+export function sanitizeUiLogMessage(message, level) {
+    let msg = String(message ?? '');
+    msg = msg.replace(ANSI_REGEX, '');
+    // If it looks like a technical dump, hide it aggressively.
+    if (TECHNICAL_DUMP_HINT_REGEX.test(msg)) {
+        return 'ERR_TECHNICAL_DETAILS_HIDDEN';
+    }
+    // For warn/error we apply stricter sanitization.
+    if (level === 'warn' || level === 'error') {
+        msg = sanitizeErrorMessage(msg);
+    }
+    msg = stripControlChars(msg);
+    msg = truncate(msg, LIMITS.maxLogLength);
+    return msg;
+}
+//# sourceMappingURL=ui-log-sanitize.js.map

package/dist/core/patch/aggregator.js

@@ -0,0 +1,93 @@
+export class PatchAggregator {
+    /**
+     * Aggregates multiple candidate patches into a single patch using hunk-level merging.
+     *
+     * Strategy:
+     * 1. Parse unified diffs into atomic Hunks.
+     * 2. Perform line range collision detection: [start, start + len).
+     * 3. Safely merge non-overlapping hunks even within the same file.
+     * 4. Report conflicts only when line ranges actually overlap.
+     */
+    static aggregate(candidates) {
+        const fileHunksMap = new Map();
+        const touchedPaths = new Set();
+        for (const candidate of candidates) {
+            for (const path of candidate.touchedPaths) {
+                touchedPaths.add(path);
+                if (!fileHunksMap.has(path)) {
+                    fileHunksMap.set(path, { hunks: [], agents: [] });
+                }
+                const entry = fileHunksMap.get(path);
+                if (!entry.agents.includes(candidate.agentId)) {
+                    entry.agents.push(candidate.agentId);
+                }
+                const parsedHunks = this.parseHunks(candidate.patch);
+                entry.hunks.push(...parsedHunks);
+            }
+        }
+        const conflicts = [];
+        let mergedPatch = '';
+        for (const [path, entry] of fileHunksMap) {
+            // Sort hunks by starting line to ensure stable output and easier collision check
+            const sortedHunks = [...entry.hunks].sort((a, b) => a.oldStart - b.oldStart);
+            const mergedFileHunks = [];
+            let fileConflict = false;
+            for (const hunk of sortedHunks) {
+                // Collision detection: Check if this hunk overlaps with any already accepted hunk
+                const collision = mergedFileHunks.find((existing) => Math.max(existing.oldStart, hunk.oldStart) <
+                    Math.min(existing.oldStart + existing.oldLen, hunk.oldStart + hunk.oldLen));
+                if (collision) {
+                    conflicts.push({
+                        path,
+                        reason: `Hunk collision detected at line ${hunk.oldStart}. Multiple agents modified overlapping ranges.`,
+                        agents: entry.agents,
+                    });
+                    fileConflict = true;
+                    break;
+                }
+                mergedFileHunks.push(hunk);
+            }
+            if (!fileConflict && mergedFileHunks.length > 0) {
+                // Construct the aggregated patch for this file
+                mergedPatch += `--- a/${path}\n+++ b/${path}\n`;
+                mergedPatch += mergedFileHunks.map((h) => h.lines.join('\n')).join('\n') + '\n';
+            }
+        }
+        return {
+            mergedPatch,
+            touchedPaths: Array.from(touchedPaths),
+            conflicts,
+        };
+    }
+    static parseHunks(diff) {
+        const hunks = [];
+        const lines = diff.split('\n');
+        let currentHunk = null;
+        for (const line of lines) {
+            // Unified diff hunk header: @@ -oldStart,oldLen +newStart,newLen @@
+            const match = line.match(/^@@ -(\d+),?(\d*) \+(\d+),?(\d*) @@/);
+            if (match) {
+                if (currentHunk)
+                    hunks.push(currentHunk);
+                currentHunk = {
+                    header: line,
+                    oldStart: parseInt(match[1]),
+                    oldLen: parseInt(match[2] || '1'),
+                    newStart: parseInt(match[3]),
+                    newLen: parseInt(match[4] || '1'),
+                    lines: [line],
+                };
+            }
+            else if (currentHunk) {
+                // Skip file headers (--- / +++) and only collect lines belonging to the hunk
+                if (!line.startsWith('---') && !line.startsWith('+++')) {
+                    currentHunk.lines.push(line);
+                }
+            }
+        }
+        if (currentHunk)
+            hunks.push(currentHunk);
+        return hunks;
+    }
+}
+//# sourceMappingURL=aggregator.js.map