salmon-loop 0.4.1 → 0.5.0

package/dist/core/feedback/parsers.js

@@ -1,3 +1,4 @@
+import { getLogger } from '../observability/logger.js';
 export function parseTscOutput(output) {
     const diagnostics = [];
     const lines = output.split('\n');
@@ -46,8 +47,296 @@ export function parsePythonError(output) {
     }
     return diagnostics;
 }
+export function parsePytestOutput(output) {
+    const diagnostics = [];
+    const lines = output.split('\n');
+    // Pattern 1: FAILED lines (--tb=short -q format)
+    // e.g. FAILED tests/test_foo.py::test_bar - AssertionError: expected 5, got 3
+    // e.g. FAILED tests/test_foo.py::TestClass::test_method - ValueError: bad value
+    const failedRegex = /^FAILED\s+(\S+?)\s+-\s+(.+)$/;
+    // Pattern 2: Assertion detail lines (E   prefix)
+    // e.g. E       AssertionError: expected 5, got 3
+    const assertionRegex = /^\s*E\s{2,}(\w+(?:Error|Exception)?):\s*(.+)$/;
+    // Pattern 3: File:line reference in traceback
+    // e.g. tests/test_module.py:42: in test_function
+    const fileLineRegex = /^\s*(\S+\.py):(\d+): in /;
+    // Pattern 4: One-line format (--tb=line)
+    // e.g. tests/test_module.py:42: AssertionError
+    const lineFormatRegex = /^(\S+\.py):(\d+):\s+(\w+(?:Error|Exception)?)$/;
+    // Track current file context for enhancing FAILED diagnostics
+    let currentFile = null;
+    let currentLine = null;
+    // Map test_id -> { file, line, assertion } for merging
+    const assertionMap = new Map();
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        // Collect file:line context from tracebacks
+        const fileMatch = line.match(fileLineRegex);
+        if (fileMatch) {
+            currentFile = fileMatch[1];
+            currentLine = parseInt(fileMatch[2]);
+            continue;
+        }
+        // Collect assertion details
+        const assertionMatch = line.match(assertionRegex);
+        if (assertionMatch && currentFile) {
+            // Associate with the most recent file context
+            const key = `${currentFile}:${currentLine}`;
+            if (!assertionMap.has(key)) {
+                assertionMap.set(key, {
+                    file: currentFile,
+                    line: currentLine ?? undefined,
+                    assertion: `${assertionMatch[1]}: ${assertionMatch[2]}`,
+                });
+            }
+            continue;
+        }
+        // Parse FAILED lines — the primary signal
+        const failedMatch = line.match(failedRegex);
+        if (failedMatch) {
+            const testId = failedMatch[1]; // e.g. tests/test_foo.py::test_bar
+            const errorMessage = failedMatch[2];
+            // Extract file from test_id (everything before ::)
+            const testFile = testId.split('::')[0];
+            diagnostics.push({
+                file: testFile,
+                severity: 'error',
+                message: errorMessage,
+                source: 'pytest',
+            });
+            continue;
+        }
+        // Parse one-line format
+        const lineFormatMatch = line.match(lineFormatRegex);
+        if (lineFormatMatch) {
+            diagnostics.push({
+                file: lineFormatMatch[1],
+                line: parseInt(lineFormatMatch[2]),
+                severity: 'error',
+                message: lineFormatMatch[3],
+                source: 'pytest',
+            });
+        }
+    }
+    // Enhance FAILED diagnostics with file:line info from tracebacks
+    if (diagnostics.length > 0 && assertionMap.size > 0) {
+        for (const diag of diagnostics) {
+            if (diag.source === 'pytest' && !diag.line) {
+                // Find matching assertion detail by file
+                for (const [, info] of assertionMap) {
+                    if (info.file === diag.file && info.line) {
+                        diag.line = info.line;
+                        if (info.assertion && diag.message.length < info.assertion.length) {
+                            diag.message = info.assertion;
+                        }
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    return diagnostics;
+}
+export function parseJestOutput(output) {
+    const diagnostics = [];
+    const lines = output.split('\n');
+    // Pattern 1: FAIL src/foo.test.ts
+    const suiteFailRegex = /^(?:FAIL|✗|✘)\s+(\S+)$/;
+    // Pattern 2: ● Test suite failed to run / ● test_name
+    const bulletRegex = /^\s*●\s+(.+)$/;
+    // Pattern 3: inline error: src/foo.ts:10:5 - error TS2322: ...
+    const inlineRegex = /^(\S+\.tsx?):(\d+):(\d+)\s+-\s+(error|warning)\s+(.+)$/;
+    let currentSuite = null;
+    for (const line of lines) {
+        const suiteMatch = line.match(suiteFailRegex);
+        if (suiteMatch) {
+            currentSuite = suiteMatch[1];
+            continue;
+        }
+        const inlineMatch = line.match(inlineRegex);
+        if (inlineMatch) {
+            diagnostics.push({
+                file: inlineMatch[1],
+                line: parseInt(inlineMatch[2]),
+                column: parseInt(inlineMatch[3]),
+                severity: inlineMatch[4],
+                message: inlineMatch[5],
+                source: 'jest',
+            });
+            continue;
+        }
+        const bulletMatch = line.match(bulletRegex);
+        if (bulletMatch && currentSuite) {
+            diagnostics.push({
+                file: currentSuite,
+                severity: 'error',
+                message: bulletMatch[1],
+                source: 'jest',
+            });
+        }
+    }
+    return diagnostics;
+}
+// ── Structured JSON parsers ──────────────────────────────────────────────────
+/** Parse jest --json output (single JSON object). */
+export function parseJestJson(output) {
+    const diagnostics = [];
+    let parsed;
+    try {
+        parsed = JSON.parse(output);
+    }
+    catch (error) {
+        getLogger().debug(`[Parsers] Failed to parse jest JSON output: ${error instanceof Error ? error.message : String(error)}`);
+        return [];
+    }
+    for (const suite of parsed.testResults ?? []) {
+        for (const assertion of suite.assertionResults ?? []) {
+            if (assertion.status === 'failed') {
+                diagnostics.push({
+                    file: suite.name,
+                    severity: 'error',
+                    message: (assertion.failureMessages ?? []).join('\n') ||
+                        `Test failed: ${(assertion.ancestorTitles ?? []).join(' > ')} > ${assertion.fullName ?? assertion.title}`,
+                    source: 'jest',
+                });
+            }
+        }
+    }
+    return diagnostics;
+}
+/** Extract test summary from jest --json output. */
+export function parseJestJsonSummary(output) {
+    try {
+        const parsed = JSON.parse(output);
+        if (typeof parsed.numTotalTests === 'number') {
+            const passed = parsed.numPassedTests ?? 0;
+            const failed = parsed.numFailedTests ?? 0;
+            const total = parsed.numTotalTests;
+            return { total, passed, failed, skipped: total - passed - failed };
+        }
+    }
+    catch (error) {
+        /* not JSON */
+        getLogger().debug(`[Parsers] Failed to parse jest JSON summary: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return undefined;
+}
+/** Parse eslint --format json output (JSON array). */
+export function parseEslintJson(output) {
+    const diagnostics = [];
+    let parsed;
+    try {
+        parsed = JSON.parse(output);
+    }
+    catch (error) {
+        getLogger().debug(`[Parsers] Failed to parse eslint JSON output: ${error instanceof Error ? error.message : String(error)}`);
+        return [];
+    }
+    if (!Array.isArray(parsed))
+        return [];
+    for (const file of parsed) {
+        for (const msg of file.messages ?? []) {
+            diagnostics.push({
+                file: file.filePath,
+                line: msg.line,
+                column: msg.column,
+                severity: msg.severity === 2 ? 'error' : 'warning',
+                message: msg.message + (msg.ruleId ? ` (${msg.ruleId})` : ''),
+                source: 'eslint',
+            });
+        }
+    }
+    return diagnostics;
+}
+/** Parse bun test --json NDJSON output. */
+export function parseBunTestNdjson(output) {
+    const diagnostics = [];
+    for (const line of output.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith('{'))
+            continue;
+        try {
+            const evt = JSON.parse(trimmed);
+            if (evt.type === 'test-fail' || evt.data?.status === 'fail') {
+                const data = evt.data ?? {};
+                diagnostics.push({
+                    file: data.file ?? data.sourceFile ?? 'unknown',
+                    severity: 'error',
+                    message: data.error?.message ?? data.message ?? 'Test failed',
+                    source: 'bun',
+                });
+            }
+        }
+        catch (error) {
+            /* skip non-JSON lines */
+            getLogger().debug(`[Parsers] Failed to parse bun test NDJSON line: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    return diagnostics;
+}
+/** Parse go test -json NDJSON output. */
+export function parseGoTestNdjson(output) {
+    const diagnostics = [];
+    for (const line of output.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith('{'))
+            continue;
+        try {
+            const evt = JSON.parse(trimmed);
+            if (evt.Action === 'fail' && evt.Test) {
+                diagnostics.push({
+                    file: evt.Package ?? 'unknown',
+                    severity: 'error',
+                    message: `Test failed: ${evt.Test}`,
+                    source: 'go',
+                });
+            }
+        }
+        catch (error) {
+            /* skip non-JSON lines */
+            getLogger().debug(`[Parsers] Failed to parse go test NDJSON line: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    return diagnostics;
+}
+/** Dispatch to the correct structured parser based on runner type. */
+export function parseRunnerOutput(output, runner) {
+    switch (runner) {
+        case 'jest':
+        case 'vitest':
+            return parseJestJson(output);
+        case 'eslint':
+            return parseEslintJson(output);
+        case 'bun':
+            return parseBunTestNdjson(output);
+        case 'go':
+            return parseGoTestNdjson(output);
+        case 'pytest':
+        case 'tsc':
+        case 'unknown':
+        default:
+            return parseGenericOutput(output);
+    }
+}
+/** Extract test summary from structured JSON output when available. */
+export function parseStructuredSummary(output, runner) {
+    switch (runner) {
+        case 'jest':
+        case 'vitest':
+            return parseJestJsonSummary(output);
+        default:
+            return undefined;
+    }
+}
+// ── Text-based heuristic dispatcher (fallback) ──────────────────────────────
 export function parseGenericOutput(output) {
-    // Fallback or combined parser
+    // Try pytest first (SWE-bench's primary test runner)
+    const pytest = parsePytestOutput(output);
+    if (pytest.length > 0)
+        return pytest;
+    const jest = parseJestOutput(output);
+    if (jest.length > 0)
+        return jest;
     const tsc = parseTscOutput(output);
     if (tsc.length > 0)
         return tsc;

package/dist/core/grizzco/dsl/llm-strategy.js

@@ -7,7 +7,7 @@ function defaultMaxRoundsForPhase(phase) {
     if (phase === Phase.EXPLORE)
         return 8;
     if (phase === Phase.AUTOPILOT)
-        return 8;
+        return 12;
     if (phase === Phase.RESEARCH)
         return 8;
     if (phase === Phase.PLAN)

package/dist/core/grizzco/engine/observability/loop-telemetry.js

@@ -1,4 +1,5 @@
 import { LIMITS } from '../../../config/limits.js';
+import { getLogger } from '../../../observability/logger.js';
 export class LoopTelemetry {
     now;
     logs = [];
@@ -16,11 +17,13 @@ export class LoopTelemetry {
                 try {
                     return JSON.stringify(output);
                 }
-                catch {
+                catch (error) {
+                    getLogger().debug(`[LoopTelemetry] JSON.stringify failed, falling back to String(): ${error instanceof Error ? error.message : String(error)}`);
                     try {
                         return String(output);
                     }
-                    catch {
+                    catch (stringError) {
+                        getLogger().debug(`[LoopTelemetry] String() conversion also failed: ${stringError instanceof Error ? stringError.message : String(stringError)}`);
                         return '[Unserializable]';
                     }
                 }

package/dist/core/grizzco/engine/outcome/loop-result-mapper.js

@@ -23,6 +23,12 @@ function toRootCauseCode(code) {
         ? code
         : undefined;
 }
+function applyPassthroughFields(result, options) {
+    if (options.tags)
+        result.tags = options.tags;
+    if (options.providerMeta)
+        result.providerMeta = options.providerMeta;
+}
 export function buildLoopResultFromTransaction({ executionReport, flowMode, options, telemetry, auditPath, }) {
     const profile = resolveExecutionProfile(flowMode);
     const rootCause = toRootCauseCode(executionReport.lastErrorCode);
@@ -93,7 +99,7 @@ export function buildLoopResultFromTransaction({ executionReport, flowMode, opti
         const usage = getTokenUsageFromAuditTrail() ?? undefined;
         const budgetSummary = getBudgetRunSummary() ?? undefined;
         if (options.dryRun || profile.readOnly) {
-            return {
+            const result = {
                 success: true,
                 reason: text.loop.operationCompleted,
                 reasonCode: options.dryRun ? 'DRY_RUN' : 'SUCCESS',
@@ -115,8 +121,10 @@ export function buildLoopResultFromTransaction({ executionReport, flowMode, opti
                 fsMode: executionReport.flowReport.fsMode ?? flowMode,
                 budgetSummary,
             };
+            applyPassthroughFields(result, options);
+            return result;
         }
-        return {
+        const result = {
             success: true,
             reason: text.loop.operationCompleted,
             reasonCode: 'SUCCESS',
@@ -138,6 +146,8 @@ export function buildLoopResultFromTransaction({ executionReport, flowMode, opti
             fsMode: executionReport.flowReport.fsMode ?? flowMode,
             budgetSummary,
         };
+        applyPassthroughFields(result, options);
+        return result;
     }
     const retryFailureReason = executionReport.history.at(-1)?.error ?? text.loop.loopExecutionFailed;
     const failureReason = executionReport.retryExhausted
@@ -164,7 +174,7 @@ export function buildLoopResultFromTransaction({ executionReport, flowMode, opti
         remediationSteps,
         fallbackMessage: failureReason,
     });
-    return {
+    const result = {
         success: false,
         reason: resultReason,
         reasonCode,
@@ -195,6 +205,8 @@ export function buildLoopResultFromTransaction({ executionReport, flowMode, opti
             ? executionReport.terminalInputRequired
             : undefined,
     };
+    applyPassthroughFields(result, options);
+    return result;
 }
 export function buildLoopFailureResult({ message, flowMode, telemetry, auditPath, reasonCode, failurePhase, errorCode, }) {
     const usage = getTokenUsageFromAuditTrail() ?? undefined;

package/dist/core/grizzco/engine/transaction/attempt-failure.js

@@ -7,6 +7,8 @@ import { isRecoverableToolInputErrorCode } from '../../../tools/recoverable-tool
 import { EXECUTION_PHASES } from '../../../types/runtime.js';
 import { isRecord } from '../../../utils/serialize.js';
 import { classifyError, isRetryable } from '../../../verification/runner.js';
+// Used by non-autopilot modes to determine retry eligibility.
+// Autopilot overrides via finalize() — this set has no effect there.
 const RETRYABLE_PHASES = new Set([
     'CONTEXT',
     'EXPLORE',
@@ -30,7 +32,7 @@ function inferFailurePhase(flowReport) {
     }
     return 'VERIFY';
 }
-function extractErrorCode(error) {
+export function extractErrorCode(error) {
     if (typeof error === 'object' && error !== null) {
         const err = error;
         // Prioritize code (from SalmonError) for better specificity
@@ -57,7 +59,19 @@ function extractInputRequired(error) {
         return undefined;
     if (typeof value.prompt !== 'string' || typeof value.type !== 'string')
         return undefined;
-    return value;
+    const result = { type: value.type, prompt: value.prompt };
+    if (value.reason === 'approval' ||
+        value.reason === 'clarification' ||
+        value.reason === 'reopen') {
+        result.reason = value.reason;
+    }
+    if (Array.isArray(value.questions)) {
+        result.questions = value.questions;
+    }
+    if (typeof value.responseFormat === 'string') {
+        result.responseFormat = value.responseFormat;
+    }
+    return result;
 }
 function extractInterrupt(error) {
     if (!isRecord(error))
@@ -67,11 +81,23 @@ function extractInterrupt(error) {
         return undefined;
     if (typeof value.type !== 'string')
         return undefined;
-    return value;
+    const result = {
+        type: value.type,
+    };
+    if (typeof value.reason === 'string')
+        result.reason = value.reason;
+    if (typeof value.prompt === 'string')
+        result.prompt = value.prompt;
+    if (isRecord(value.data))
+        result.data = value.data;
+    return result;
 }
 export function resolveAttemptFailure(params) {
     const { flowReport, context, flowMode } = params;
     const profile = resolveExecutionProfile(flowMode);
+    // Autopilot is one-shot: never retry at the transaction-runner level.
+    const finalize = (failure) => flowMode === 'autopilot' ? { ...failure, retryable: false } : failure;
+    const effectiveVerifyPolicy = params.verifyPolicy ?? profile.verifyPolicy;
     const interrupt = extractInterrupt(flowReport.error);
     const interruptCode = extractErrorCode(flowReport.error);
     if (interruptCode === 'INTERRUPT_REQUIRED' && interrupt?.type === 'awaiting_input') {
@@ -93,7 +119,7 @@ export function resolveAttemptFailure(params) {
         };
     }
     const autopilotCompletion = flowMode === 'autopilot' && context && 'completion' in context ? context.completion : undefined;
-    const verifyOk = profile.verifyPolicy === 'never' ? true : context?.verifyResult?.ok !== false;
+    const verifyOk = effectiveVerifyPolicy === 'never' ? true : context?.verifyResult?.ok !== false;
     const applyBackResult = context && 'applyBackResult' in context ? context.applyBackResult : undefined;
     const applyBackFailed = profile.failurePolicy === 'rollback' &&
         applyBackResult?.success === false &&
@@ -123,7 +149,7 @@ export function resolveAttemptFailure(params) {
         return undefined;
     }
     const errorCode = extractErrorCode(flowReport.error) ?? extractErrorCodeFromTraces(flowReport);
-    if (profile.verifyPolicy !== 'never' && context?.verifyResult?.ok === false) {
+    if (effectiveVerifyPolicy !== 'never' && context?.verifyResult?.ok === false) {
         const verifyOutput = context.verifyResult.output || text.loop.loopExecutionFailed;
         const errorType = classifyError(verifyOutput);
         const fallbackReason = sanitizeReason(context.lastError || verifyOutput);
@@ -135,7 +161,7 @@ export function resolveAttemptFailure(params) {
             environmentMode,
             fallbackReason,
         });
-        return {
+        return finalize({
             reason: guidance.safeHint,
             reasonCode: 'VERIFY_FAILED',
             failurePhase: 'VERIFY',
@@ -144,7 +170,7 @@ export function resolveAttemptFailure(params) {
             diagnosticCode: guidance.diagnosticCode,
             safeHint: guidance.safeHint,
             remediationSteps: guidance.remediationSteps,
-        };
+        });
     }
     if (flowMode === 'autopilot' && autopilotCompletion) {
         if (autopilotCompletion.status === 'changed' ||
@@ -152,13 +178,11 @@ export function resolveAttemptFailure(params) {
             if (flowReport.success && verifyOk)
                 return undefined;
         }
-        const reasonCode = autopilotCompletion.status === 'verification_missing'
-            ? 'VERIFY_COMMAND_MISSING'
-            : autopilotCompletion.status === 'tool_failure' &&
-                isRecoverableToolInputErrorCode(autopilotCompletion.errorCode)
-                ? 'TOOL_CORRECTION_REQUIRED'
-                : 'LOOP_FAILED';
-        const failurePhase = autopilotCompletion.status === 'verification_missing' ? 'VERIFY' : 'AUTOPILOT';
+        const reasonCode = autopilotCompletion.status === 'tool_failure' &&
+            isRecoverableToolInputErrorCode(autopilotCompletion.errorCode)
+            ? 'TOOL_CORRECTION_REQUIRED'
+            : 'LOOP_FAILED';
+        const failurePhase = 'AUTOPILOT';
         const fallbackReason = autopilotCompletion.reason ||
             (autopilotCompletion.status === 'no_effect'
                 ? 'Autopilot completed without changing files or producing an answer.'
@@ -170,7 +194,7 @@ export function resolveAttemptFailure(params) {
             environmentMode,
             fallbackReason,
         });
-        return {
+        return finalize({
             reason: guidance.safeHint,
             reasonCode,
             failurePhase,
@@ -179,7 +203,7 @@ export function resolveAttemptFailure(params) {
             diagnosticCode: guidance.diagnosticCode,
             safeHint: guidance.safeHint,
             remediationSteps: guidance.remediationSteps,
-        };
+        });
     }
     if (errorCode === 'PREFLIGHT_NOT_GIT') {
         const fallbackReason = sanitizeReason(flowReport.error);
@@ -272,7 +296,7 @@ export function resolveAttemptFailure(params) {
             environmentMode,
             fallbackReason,
         });
-        return {
+        return finalize({
             reason: guidance.safeHint,
             reasonCode: 'TOOL_CORRECTION_REQUIRED',
             failurePhase,
@@ -281,7 +305,7 @@ export function resolveAttemptFailure(params) {
             diagnosticCode: guidance.diagnosticCode,
             safeHint: guidance.safeHint,
             remediationSteps: guidance.remediationSteps,
-        };
+        });
     }
     const guidance = buildFailureGuidance({
         reasonCode: failurePhase === 'ROLLBACK' ? 'ROLLBACK_FAILED' : 'LOOP_FAILED',
@@ -304,7 +328,7 @@ export function resolveAttemptFailure(params) {
             remediationSteps: guidance.remediationSteps,
         };
     }
-    return {
+    return finalize({
         reason: guidance.safeHint,
         reasonCode: 'LOOP_FAILED',
         failurePhase,
@@ -313,6 +337,6 @@ export function resolveAttemptFailure(params) {
         diagnosticCode: guidance.diagnosticCode,
         safeHint: guidance.safeHint,
         remediationSteps: guidance.remediationSteps,
-    };
+    });
 }
 //# sourceMappingURL=attempt-failure.js.map