salmon-loop 0.3.2 → 0.5.0

package/dist/core/extensions/schemas.js

@@ -21,4 +21,25 @@ export const SkillsConfigSchema = z
     discovery: skillDiscoverySchema.optional().default({}),
 })
     .strict();
+export const AgentProfileConfigSchema = z.object({
+    id: z.string().min(1),
+    name: z.string().min(1),
+    role: z.string().min(1),
+    description: z.string(),
+    allowedTools: z.array(z.string()).optional(),
+    toolInheritance: z.enum(['none', 'safe', 'all']).optional(),
+    permissionMode: z.enum(['default', 'plan', 'bypassPermissions']).optional(),
+    systemPrompt: z.string().optional(),
+    readOnly: z.boolean().optional(),
+    stratagem: z.enum(['investigator', 'surgeon', 'janitor']).optional(),
+    maxTokens: z.number().positive().optional(),
+    maxAttempts: z.number().positive().optional(),
+    timeoutMs: z.number().positive().optional(),
+    model: z.string().optional(),
+    enabled: z.boolean().optional(),
+});
+export const AgentsConfigSchema = z.object({
+    version: z.literal(1),
+    agents: z.array(AgentProfileConfigSchema),
+});
 //# sourceMappingURL=schemas.js.map

package/dist/core/facades/cli-authorization-provider.js

@@ -1,2 +1,3 @@
+export { DEFAULT_TOOL_AUTH } from '../config/defaults.js';
 export { getLogger } from '../observability/logger.js';
 //# sourceMappingURL=cli-authorization-provider.js.map

package/dist/core/facades/cli-command-chat.js

@@ -1,9 +1,11 @@
 export { ConfigError, normalizePermissionMode, resolveConfig } from '../config/index.js';
 export { ExtensionConfigError, resolveExtensions } from '../extensions/index.js';
 export { createRuntimeLlm } from '../llm/factory.js';
+export { createSubAgentLlmFactory } from '../llm/sub-agent-factory.js';
 export { getLogger } from '../observability/logger.js';
 export { PluginLoader } from '../plugin/loader.js';
 export { resolveExecutionProfile } from '../runtime/execution-profile.js';
 export { clearPluginRegistry, createPluginRegistry, setPluginRegistry, } from '../plugin/registry.js';
 export { clearPromptRegistry, createPromptRegistry, setPromptRegistry, } from '../prompts/registry.js';
+export { getString } from '../utils/serialize.js';
 //# sourceMappingURL=cli-command-chat.js.map

package/dist/core/facades/cli-run-handler.js

@@ -1,4 +1,5 @@
 export { normalizePermissionMode } from '../config/index.js';
+export { createSubAgentLlmFactory } from '../llm/sub-agent-factory.js';
 export { getLogger, PlainReporter, SilentReporter } from '../observability/logger.js';
 export { createPluginRegistry, setPluginRegistry, } from '../plugin/registry.js';
 export { createPromptRegistry, setPromptRegistry, } from '../prompts/registry.js';

package/dist/core/facades/cli-utils-serialize.js

@@ -0,0 +1,2 @@
+export { isRecord } from '../utils/serialize.js';
+//# sourceMappingURL=cli-utils-serialize.js.map

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

@@ -1,12 +1,13 @@
 import { resolveLlmCapabilities } from '../../llm/capabilities.js';
 import { Phase } from '../../types/runtime.js';
+import { FileStatus, OpType } from '../domain/grizzco-types.js';
 import { DecisionEngine, PlanBuilder } from './DecisionEngine.js';
 function defaultMaxRoundsForPhase(phase) {
     // Explore needs more rounds to navigate the codebase
     if (phase === Phase.EXPLORE)
         return 8;
     if (phase === Phase.AUTOPILOT)
-        return 8;
+        return 12;
     if (phase === Phase.RESEARCH)
         return 8;
     if (phase === Phase.PLAN)
@@ -24,7 +25,7 @@ export function resolveLlmToolCallingPolicy(phase, llm) {
         repoRoot: '',
         file: {
             path: '',
-            status: 0,
+            status: FileStatus.CLEAN,
             isBinary: false,
             isSymlink: false,
             isIgnored: false,
@@ -32,7 +33,7 @@ export function resolveLlmToolCallingPolicy(phase, llm) {
             size: 0,
         },
         operation: {
-            type: 0,
+            type: OpType.PATCH,
             path: '',
         },
         options: {

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

@@ -5,6 +5,7 @@ import { buildFailureEnvelope } from '../../../observability/error-envelope.js';
 import { getTokenUsageFromAuditTrail } from '../../../observability/token-usage.js';
 import { resolveExecutionProfile } from '../../../runtime/execution-profile.js';
 import { ErrorType, Phase } from '../../../types/runtime.js';
+import { isRecord } from '../../../utils/serialize.js';
 const ROOT_CAUSE_CODES = [
     'LLM_RATE_LIMITED',
     'LLM_UPSTREAM_5XX',
@@ -22,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);
@@ -34,17 +41,19 @@ export function buildLoopResultFromTransaction({ executionReport, flowMode, opti
                 : 'NON_RETRYABLE_FAILURE';
     const ctx = executionReport.lastContext ??
         executionReport.flowReport.data;
+    const ctxObj = isRecord(ctx) ? ctx : null;
     const contextHash = (() => {
-        const hashFromBudget = ctx?.contextResult?.meta?.contextHash;
+        const contextResult = isRecord(ctxObj?.contextResult) ? ctxObj.contextResult : null;
+        const meta = isRecord(contextResult?.meta) ? contextResult.meta : null;
+        const hashFromBudget = meta?.contextHash;
         if (typeof hashFromBudget === 'string')
             return hashFromBudget;
-        const hashFromContext = ctx && typeof ctx === 'object' && 'context' in ctx
-            ? ctx.context?.contextHash
-            : undefined;
+        const context = isRecord(ctxObj?.context) ? ctxObj.context : null;
+        const hashFromContext = context?.contextHash;
         return typeof hashFromContext === 'string' ? hashFromContext : undefined;
     })();
-    const verifyArtifact = ctx && typeof ctx === 'object' && 'verifyArtifact' in ctx
-        ? ctx.verifyArtifact
+    const verifyArtifact = ctxObj && typeof ctxObj.verifyArtifact !== 'undefined'
+        ? ctxObj.verifyArtifact
         : executionReport.lastVerifyArtifact;
     const artifactHints = (() => {
         const hints = {
@@ -71,12 +80,14 @@ export function buildLoopResultFromTransaction({ executionReport, flowMode, opti
         }
         return hints;
     })();
+    const report = isRecord(ctxObj?.report) ? ctxObj.report : null;
     const assistantMessage = ((flowMode === 'answer' || profile.driver === 'agent') &&
-        ctx?.report?.summary?.trim?.()
-        ? String(ctx.report.summary).trim()
+        typeof report?.summary === 'string' &&
+        report.summary.trim()
+        ? report.summary.trim()
         : undefined) ?? undefined;
-    const finalPatch = ctx && typeof ctx === 'object' && 'diff' in ctx ? ctx.diff : undefined;
-    const changedFiles = ctx && typeof ctx === 'object' && 'changedFiles' in ctx ? ctx.changedFiles : undefined;
+    const finalPatch = ctxObj && typeof ctxObj.diff === 'string' ? ctxObj.diff : undefined;
+    const changedFiles = Array.isArray(ctxObj?.changedFiles) ? ctxObj.changedFiles : undefined;
     const authorizationDecisions = (() => {
         if (!options.eventPayload?.includeAuthorizationDecisions)
             return undefined;
@@ -88,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',
@@ -110,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',
@@ -133,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
@@ -159,7 +174,7 @@ export function buildLoopResultFromTransaction({ executionReport, flowMode, opti
         remediationSteps,
         fallbackMessage: failureReason,
     });
-    return {
+    const result = {
         success: false,
         reason: resultReason,
         reasonCode,
@@ -190,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;