salmon-loop 0.2.3

package/dist/core/grizzco/steps/patch.js

@@ -0,0 +1,220 @@
+import { text } from '../../../locales/index.js';
+import { GitAdapter } from '../../adapters/git/git-adapter.js';
+import { LIMITS } from '../../config/limits.js';
+import { repairToUnifiedDiff } from '../../llm/contracts/repair.js';
+import { wrapPatchEmpty, wrapPatchInvalid, wrapPatchNotUnifiedDiff } from '../../llm/errors.js';
+import { composeChatMessages } from '../../llm/message-composition.js';
+import { emitLlmOutput } from '../../llm/output-policy.js';
+import { extractUnifiedDiffFromLLMContent, formatContextForPrompt } from '../../llm/utils.js';
+import { normalizeDiff, validateDiff } from '../../patch/diff.js';
+import { getPatchPrompt, getPatchSystemPrompt } from '../../prompts/runtime.js';
+import { chatWithTools, chatWithToolsStreaming } from '../../tools/session.js';
+import { DiffValidationError } from '../../types/errors.js';
+import { Phase } from '../../types/runtime.js';
+import { resolveLlmToolCallingPolicy } from '../dsl/llm-strategy.js';
+async function checkPatchApplies(args) {
+    const git = new GitAdapter(args.repoRoot);
+    return git.execMeta(['apply', '--check', '--recount', '--ignore-whitespace', '--whitespace=nowarn', '-'], {
+        input: Buffer.from(args.diff, 'utf8'),
+        timeoutMs: 15000,
+        limits: { maxStdoutBytes: 0, maxStderrChars: 4000 },
+    });
+}
+export const generatePatch = async (ctx) => {
+    const toolstack = ctx.toolstack;
+    const toolPolicy = resolveLlmToolCallingPolicy(Phase.PATCH, ctx.options.llm);
+    // Backwards-compatible fallback for non-tool-capable LLMs.
+    if (!toolstack || !toolPolicy.enabled) {
+        const patch = await ctx.options.llm.createPatch(ctx.context, ctx.plan, ctx.lastError, ctx.options.signal);
+        emitLlmOutput({
+            emit: ctx.emit,
+            policy: ctx.options.llmOutput,
+            kind: 'patch',
+            step: 'PATCH',
+            content: patch,
+        });
+        const normalizedPatch = normalizeDiff(patch);
+        let diffMeta;
+        try {
+            diffMeta = validateDiff(normalizedPatch);
+        }
+        catch (e) {
+            if (e instanceof DiffValidationError) {
+                if (e.message === text.diff.notUnifiedFormat)
+                    throw wrapPatchNotUnifiedDiff();
+                if (e.message.startsWith(text.llm.patchEmpty()))
+                    throw wrapPatchEmpty();
+                throw wrapPatchInvalid(e.message);
+            }
+            throw e;
+        }
+        ctx.emit({
+            type: 'log',
+            level: 'debug',
+            message: `Patch generated: ${diffMeta.changedFiles.length} files changed`,
+            timestamp: new Date(),
+        });
+        return {
+            ...ctx,
+            diff: normalizedPatch,
+            diffMeta,
+            changedFiles: diffMeta.changedFiles,
+        };
+    }
+    const planStr = JSON.stringify(ctx.plan, null, 2);
+    const prompt = await getPatchPrompt(planStr, formatContextForPrompt(ctx.context), LIMITS.maxFilesChanged, LIMITS.maxDiffLines, ctx.lastError);
+    const systemPrompt = await getPatchSystemPrompt(toolstack?.registry, { plan: ctx.planRuntime });
+    const baseMessages = composeChatMessages({
+        system: systemPrompt,
+        user: prompt,
+        conversationContext: ctx.options.conversationContext,
+    });
+    const supportsStreaming = typeof ctx.options.llm.chatStream === 'function';
+    const llmOutput = {
+        policy: ctx.options.llmOutput,
+        kind: 'patch',
+        step: 'PATCH',
+    };
+    const response = await (supportsStreaming ? chatWithToolsStreaming : chatWithTools)(baseMessages, {
+        signal: ctx.options.signal,
+    }, {
+        phase: Phase.PATCH,
+        llm: ctx.options.llm,
+        runtime: {
+            repoRoot: ctx.workspace.workPath,
+            persistenceRoot: ctx.workspace.baseRepoPath || ctx.workspace.workPath,
+            worktreeRoot: ctx.workspace.strategy === 'worktree' ? ctx.workspace.workPath : undefined,
+            attemptId: ctx.attempt ?? 1,
+            dryRun: Boolean(ctx.options?.dryRun),
+            llm: ctx.options.llm,
+            model: ctx.options.llm.getModelId?.() || process.env.SALMONLOOP_MODEL || process.env.S8P_MODEL,
+            userInputProvider: ctx.options.userInputProvider,
+            agentKind: ctx.options.agentKind ?? 'primary',
+            languagePlugins: ctx.options.languagePlugins,
+            subAgentController: ctx.options.subAgentController,
+        },
+        toolstack,
+        eventPayload: ctx.options.eventPayload,
+        toolCallingAudit: {
+            event: (entry) => {
+                const list = ctx.toolCallingAudit ?? [];
+                list.push(entry);
+                ctx.toolCallingAudit = list;
+            },
+        },
+        maxRounds: toolPolicy.maxRounds,
+        llmOutput,
+        emit: (event) => ctx.emit({ ...event, timestamp: event.timestamp ?? new Date() }),
+    });
+    let rawContent = response.content || '';
+    let patch = '';
+    let normalizedPatch = '';
+    let diffMeta;
+    const validateWithLlmErrors = (diffText) => {
+        const normalized = normalizeDiff(diffText);
+        try {
+            return validateDiff(normalized);
+        }
+        catch (e) {
+            if (e instanceof DiffValidationError) {
+                if (e.message === text.diff.notUnifiedFormat)
+                    throw wrapPatchNotUnifiedDiff();
+                if (e.message.startsWith(text.llm.patchEmpty()))
+                    throw wrapPatchEmpty();
+                throw wrapPatchInvalid(e.message);
+            }
+            throw e;
+        }
+    };
+    try {
+        patch = extractUnifiedDiffFromLLMContent(rawContent);
+        normalizedPatch = normalizeDiff(patch);
+        diffMeta = validateWithLlmErrors(patch);
+    }
+    catch (e) {
+        const asLlmError = e;
+        if (asLlmError instanceof Error &&
+            'llmCode' in asLlmError &&
+            asLlmError.llmCode &&
+            ['LLM_PATCH_EMPTY', 'LLM_PATCH_NOT_UNIFIED_DIFF'].includes(asLlmError.llmCode)) {
+            let repaired;
+            try {
+                repaired = await repairToUnifiedDiff({
+                    llm: ctx.options.llm,
+                    baseMessages,
+                    chatOptions: { signal: ctx.options.signal },
+                    badContent: rawContent,
+                    reason: asLlmError.message,
+                });
+            }
+            catch {
+                throw asLlmError;
+            }
+            rawContent = repaired.content || '';
+            patch = extractUnifiedDiffFromLLMContent(rawContent);
+            normalizedPatch = normalizeDiff(patch);
+            diffMeta = validateWithLlmErrors(patch);
+            emitLlmOutput({
+                emit: ctx.emit,
+                policy: ctx.options.llmOutput,
+                kind: 'patch',
+                step: 'PATCH',
+                content: patch,
+            });
+        }
+        else {
+            throw asLlmError;
+        }
+    }
+    // Deterministic contract: the patch should be applicable (git apply --check) before moving on.
+    // When this fails, attempt a single LLM repair pass using the git error message as feedback.
+    const applyCheck = await checkPatchApplies({
+        repoRoot: ctx.workspace.workPath,
+        diff: normalizedPatch,
+    });
+    if (!applyCheck.ok) {
+        const details = (applyCheck.stderr || '').trim();
+        try {
+            const repaired = await repairToUnifiedDiff({
+                llm: ctx.options.llm,
+                baseMessages,
+                chatOptions: { signal: ctx.options.signal },
+                badContent: patch,
+                reason: `Patch does not apply cleanly: ${details.slice(0, 1200)}`,
+            });
+            rawContent = repaired.content || '';
+            patch = extractUnifiedDiffFromLLMContent(rawContent);
+            normalizedPatch = normalizeDiff(patch);
+            diffMeta = validateWithLlmErrors(patch);
+            const applyCheck2 = await checkPatchApplies({
+                repoRoot: ctx.workspace.workPath,
+                diff: normalizedPatch,
+            });
+            if (applyCheck2.ok) {
+                emitLlmOutput({
+                    emit: ctx.emit,
+                    policy: ctx.options.llmOutput,
+                    kind: 'patch',
+                    step: 'PATCH',
+                    content: patch,
+                });
+            }
+        }
+        catch {
+            // Preserve the original patch and let VALIDATE provide the canonical failure if needed.
+        }
+    }
+    ctx.emit({
+        type: 'log',
+        level: 'debug',
+        message: `Patch generated: ${diffMeta.changedFiles.length} files changed`,
+        timestamp: new Date(),
+    });
+    return {
+        ...ctx,
+        diff: normalizedPatch,
+        diffMeta,
+        changedFiles: diffMeta.changedFiles,
+    };
+};
+//# sourceMappingURL=patch.js.map

package/dist/core/grizzco/steps/plan.js

@@ -0,0 +1,191 @@
+import { text } from '../../../locales/index.js';
+import { LIMITS } from '../../config/limits.js';
+import { repairToJsonObject } from '../../llm/contracts/repair.js';
+import { sanitizeError } from '../../llm/errors.js';
+import { composeChatMessages } from '../../llm/message-composition.js';
+import { emitLlmOutput } from '../../llm/output-policy.js';
+import { formatContextForPrompt, parsePlanFromLLMContent } from '../../llm/utils.js';
+import { logIgnoredError } from '../../observability/ignored-error.js';
+import { readPlan, updatePlan } from '../../plan/index.js';
+import { getPlanPrompt, getPlanSystemPrompt } from '../../prompts/runtime.js';
+import { chatWithTools, chatWithToolsStreaming } from '../../tools/session.js';
+import { Phase } from '../../types/runtime.js';
+import { resolveLlmToolCallingPolicy } from '../dsl/llm-strategy.js';
+function sanitizeSubtaskText(raw) {
+    const oneLine = String(raw ?? '')
+        .replace(/\r?\n/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+    if (!oneLine)
+        return null;
+    // Prevent metadata injection (our plan format uses HTML comments for stable IDs).
+    const withoutComments = oneLine.replaceAll('<!--', '').replaceAll('-->', '').trim();
+    if (!withoutComments)
+        return null;
+    const maxLen = 180;
+    if (withoutComments.length <= maxLen)
+        return withoutComments;
+    return withoutComments.slice(0, maxLen - 1).trimEnd() + '…';
+}
+async function hydrateRuntimePlanTodos(ctx, plan) {
+    const runtime = ctx.planRuntime;
+    if (!runtime?.sessionId)
+        return;
+    const persistenceRoot = ctx.workspace.baseRepoPath || ctx.workspace.workPath;
+    const res = await readPlan({ persistenceRoot, sessionId: runtime.sessionId });
+    const existingNonRoot = [...res.active, ...res.pending, ...res.recentDone].some((s) => s?.stepId && s.stepId !== 'work_root');
+    if (existingNonRoot)
+        return;
+    const candidates = Array.isArray(plan.changes) && plan.changes.length > 0
+        ? plan.changes
+        : Array.isArray(plan.files)
+            ? plan.files.map((f) => `Edit ${f}`)
+            : [];
+    const unique = [];
+    const seen = new Set();
+    for (const c of candidates) {
+        const sanitized = sanitizeSubtaskText(c);
+        if (!sanitized || seen.has(sanitized))
+            continue;
+        seen.add(sanitized);
+        unique.push(sanitized);
+        if (unique.length >= 32)
+            break;
+    }
+    if (unique.length === 0)
+        return;
+    await updatePlan({
+        persistenceRoot,
+        sessionId: runtime.sessionId,
+        baseHash: res.baseHash,
+        stepId: 'work_root',
+        patch: {
+            appendSubtasks: unique,
+        },
+    });
+}
+export const generatePlan = async (ctx) => {
+    const toolstack = ctx.toolstack;
+    const toolPolicy = resolveLlmToolCallingPolicy(Phase.PLAN, ctx.options.llm);
+    // Backwards-compatible fallback: keep non-tool-capable LLMs on the legacy createPlan path.
+    if (!toolstack || !toolPolicy.enabled) {
+        const plan = await ctx.options.llm.createPlan(ctx.context, ctx.options.instruction, ctx.lastError, ctx.options.signal);
+        emitLlmOutput({
+            emit: ctx.emit,
+            policy: ctx.options.llmOutput,
+            kind: 'plan',
+            step: 'PLAN',
+            content: JSON.stringify(plan, null, 2),
+        });
+        ctx.emit({
+            type: 'log',
+            level: 'debug',
+            message: `Plan generated: ${plan.goal}`,
+            timestamp: new Date(),
+        });
+        // Best-effort: keep runtime plan actionable even if the LLM doesn't call plan.* tools.
+        await hydrateRuntimePlanTodos(ctx, plan).catch((error) => logIgnoredError('[Plan] hydrate runtime plan todos (legacy)', error));
+        return {
+            ...ctx,
+            plan,
+        };
+    }
+    const prompt = await getPlanPrompt(formatContextForPrompt(ctx.context), ctx.options.instruction, LIMITS.maxFilesChanged, ctx.lastError);
+    const systemPrompt = await getPlanSystemPrompt(toolstack?.registry, { plan: ctx.planRuntime });
+    const baseMessages = composeChatMessages({
+        system: systemPrompt,
+        user: prompt,
+        conversationContext: ctx.options.conversationContext,
+    });
+    const supportsStreaming = typeof ctx.options.llm.chatStream === 'function';
+    const llmOutput = {
+        policy: ctx.options.llmOutput,
+        kind: 'plan',
+        step: 'PLAN',
+    };
+    const response = await (supportsStreaming ? chatWithToolsStreaming : chatWithTools)(baseMessages, {
+        responseFormat: 'json_object',
+        signal: ctx.options.signal,
+    }, {
+        phase: Phase.PLAN,
+        llm: ctx.options.llm,
+        runtime: {
+            repoRoot: ctx.workspace.workPath,
+            persistenceRoot: ctx.workspace.baseRepoPath || ctx.workspace.workPath,
+            worktreeRoot: ctx.workspace.strategy === 'worktree' ? ctx.workspace.workPath : undefined,
+            attemptId: ctx.attempt ?? 1,
+            dryRun: Boolean(ctx.options?.dryRun),
+            llm: ctx.options.llm,
+            model: ctx.options.llm.getModelId?.() || process.env.SALMONLOOP_MODEL || process.env.S8P_MODEL,
+            userInputProvider: ctx.options.userInputProvider,
+            agentKind: ctx.options.agentKind ?? 'primary',
+            languagePlugins: ctx.options.languagePlugins,
+            subAgentController: ctx.options.subAgentController,
+        },
+        toolstack,
+        eventPayload: ctx.options.eventPayload,
+        toolCallingAudit: {
+            event: (entry) => {
+                const list = ctx.toolCallingAudit ?? [];
+                list.push(entry);
+                ctx.toolCallingAudit = list;
+            },
+        },
+        maxRounds: toolPolicy.maxRounds,
+        llmOutput,
+        emit: (event) => ctx.emit({ ...event, timestamp: event.timestamp ?? new Date() }),
+    });
+    const content = response.content;
+    let finalContent = content || '';
+    let plan;
+    try {
+        if (!finalContent) {
+            throw new Error(text.llm.planEmpty);
+        }
+        plan = parsePlanFromLLMContent(finalContent);
+    }
+    catch (e) {
+        let repaired;
+        try {
+            repaired = await repairToJsonObject({
+                llm: ctx.options.llm,
+                baseMessages,
+                chatOptions: { signal: ctx.options.signal },
+                badContent: finalContent,
+                reason: sanitizeError(e),
+            });
+        }
+        catch (repairError) {
+            throw new Error(text.llm.planParseFailed(finalContent, sanitizeError(repairError)));
+        }
+        finalContent = repaired.content || '';
+        emitLlmOutput({
+            emit: ctx.emit,
+            policy: ctx.options.llmOutput,
+            kind: 'plan',
+            step: 'PLAN',
+            content: finalContent,
+        });
+        try {
+            if (!finalContent)
+                throw new Error(text.llm.planEmpty);
+            plan = parsePlanFromLLMContent(finalContent);
+        }
+        catch (e2) {
+            throw new Error(text.llm.planParseFailed(finalContent, sanitizeError(e2)));
+        }
+    }
+    ctx.emit({
+        type: 'log',
+        level: 'debug',
+        message: `Plan generated: ${plan.goal}`,
+        timestamp: new Date(),
+    });
+    // Best-effort: keep runtime plan actionable even if the LLM doesn't call plan.* tools.
+    await hydrateRuntimePlanTodos(ctx, plan).catch((error) => logIgnoredError('[Plan] hydrate runtime plan todos (tools)', error));
+    return {
+        ...ctx,
+        plan,
+    };
+};
+//# sourceMappingURL=plan.js.map

package/dist/core/grizzco/steps/preflight.js

@@ -0,0 +1,93 @@
+import { text } from '../../../locales/index.js';
+import { recordAuditEvent } from '../../observability/audit-trail.js';
+import { createStandardToolstack } from '../../tools/loader.js';
+import { Phase } from '../../types/runtime.js';
+import { preflight } from '../../verification/runner.js';
+import { resolveLlmToolCallingPolicy } from '../dsl/llm-strategy.js';
+export const runPreflight = async (ctx) => {
+    const result = await preflight(ctx.workspace, ctx.emit, {
+        ignoreDirty: ctx.mode === 'review' || ctx.mode === 'research' || ctx.mode === 'answer',
+    });
+    if (!result.ok) {
+        const reason = result.reason || text.loop.preflightFailedNotGit;
+        ctx.emit({
+            type: 'log',
+            level: 'error',
+            message: reason,
+            timestamp: new Date(),
+        });
+        const error = new Error(reason);
+        error.code = result.reasonCode || 'LOOP_FAILED';
+        throw error;
+    }
+    ctx.emit({
+        type: 'log',
+        level: 'info',
+        message: text.loop.preflightPassed,
+        timestamp: new Date(),
+    });
+    const toolstack = resolveLlmToolCallingPolicy(Phase.PLAN, ctx.options.llm).enabled
+        ? await createStandardToolstack({
+            repoRoot: ctx.workspace.workPath,
+            persistenceRoot: ctx.workspace.baseRepoPath || ctx.workspace.workPath,
+            worktreeRoot: ctx.workspace.strategy === 'worktree' ? ctx.workspace.workPath : undefined,
+            attemptId: ctx.attempt ?? 1,
+            dryRun: Boolean(ctx.options?.dryRun),
+            allowedToolNames: Array.isArray(ctx.options.allowedToolNames)
+                ? ctx.options.allowedToolNames
+                : undefined,
+            permissionRules: ctx.options.permissionRules,
+            authorizationProvider: ctx.options.authorizationProvider,
+            authorizationMode: ctx.options.authorizationMode,
+            extensions: ctx.options.extensions,
+            onAuthorizationSummary: (summary) => {
+                ctx.emit({
+                    type: 'authorization.summary',
+                    summary,
+                    stage: 'realtime',
+                    timestamp: new Date(),
+                });
+            },
+            onAuthorizationDecision: (event) => {
+                if (!ctx.options.eventPayload?.includeAuthorizationDecisions)
+                    return;
+                ctx.emit({
+                    type: 'authorization.decision',
+                    callId: event.callId,
+                    toolName: event.toolName,
+                    phase: event.phase,
+                    outcome: event.outcome,
+                    source: event.source,
+                    reason: event.reason,
+                    ttlMs: event.ttlMs,
+                    persist: event.persist,
+                    riskLevel: event.riskLevel,
+                    sideEffects: event.sideEffects,
+                    timestamp: new Date(),
+                });
+                recordAuditEvent('authorization.decision', {
+                    callId: event.callId,
+                    toolName: event.toolName,
+                    phase: event.phase,
+                    outcome: event.outcome,
+                    source: event.source,
+                    reason: event.reason,
+                    ttlMs: event.ttlMs,
+                    persist: event.persist,
+                    riskLevel: event.riskLevel,
+                    sideEffects: event.sideEffects,
+                }, { source: 'tool', severity: 'low', scope: 'session', phase: event.phase });
+            },
+            model: ctx.options.llm.getModelId?.() || process.env.SALMONLOOP_MODEL || process.env.S8P_MODEL,
+        })
+        : undefined;
+    return {
+        ...ctx,
+        preflightResult: result,
+        // Toolstack is created once per attempt when tool calling is enabled. This keeps governance
+        // deterministic while avoiding unnecessary setup for non-tool-capable LLMs.
+        toolstack,
+        toolAuditLogger: toolstack?.audit,
+    };
+};
+//# sourceMappingURL=preflight.js.map

package/dist/core/grizzco/steps/prepare-deps.js

@@ -0,0 +1,49 @@
+import { text } from '../../../locales/index.js';
+import { LIMITS } from '../../config/limits.js';
+import { recordAuditEvent } from '../../observability/audit-trail.js';
+import { detectNodeRuntimeProfile, resolveNodeWorktreePrepareCommand, } from '../../target-runtime/index.js';
+import { runCommand } from '../../verification/runner.js';
+export const runPrepareDeps = async (ctx) => {
+    if (ctx.workspace.strategy !== 'worktree') {
+        recordAuditEvent('prepare_deps.skipped', { reason: 'non_worktree', strategy: ctx.workspace.strategy }, { source: 'verification', severity: 'low', scope: 'session', phase: 'PREPARE_DEPS' });
+        return ctx;
+    }
+    let command = ctx.options.worktreePrepare?.trim();
+    if (!command) {
+        const runtimeProfile = await detectNodeRuntimeProfile(ctx.workspace.workPath);
+        if (runtimeProfile) {
+            command = resolveNodeWorktreePrepareCommand(runtimeProfile);
+            recordAuditEvent('prepare_deps.auto_detected', { command, packageManager: runtimeProfile.packageManager, source: runtimeProfile.source }, { source: 'verification', severity: 'low', scope: 'session', phase: 'PREPARE_DEPS' });
+        }
+    }
+    if (!command) {
+        recordAuditEvent('prepare_deps.skipped', { reason: 'no_command' }, { source: 'verification', severity: 'low', scope: 'session', phase: 'PREPARE_DEPS' });
+        return ctx;
+    }
+    ctx.emit({
+        type: 'log',
+        level: 'debug',
+        message: text.loop.worktreePrepareDebug(command),
+        timestamp: new Date(),
+    });
+    recordAuditEvent('prepare_deps.start', { command }, { source: 'verification', severity: 'low', scope: 'session', phase: 'PREPARE_DEPS' });
+    const prepareResult = await runCommand(ctx.workspace.workPath, command, LIMITS.worktreePrepareTimeoutMs, undefined, ctx.options.signal);
+    recordAuditEvent('prepare_deps.summary', {
+        ok: prepareResult.ok,
+        exitCode: prepareResult.exitCode,
+        outputChars: prepareResult.output.length,
+    }, {
+        source: 'verification',
+        severity: prepareResult.ok ? 'low' : 'medium',
+        scope: 'session',
+        phase: 'PREPARE_DEPS',
+    });
+    if (!prepareResult.ok) {
+        const message = text.loop.worktreePrepareFailed(prepareResult.output);
+        const error = new Error(message);
+        error.code = 'DEPENDENCY_ERROR';
+        throw error;
+    }
+    return ctx;
+};
+//# sourceMappingURL=prepare-deps.js.map

package/dist/core/grizzco/steps/read-only-shrink.js

@@ -0,0 +1,4 @@
+export async function runReadOnlyShrink(ctx) {
+    return ctx;
+}
+//# sourceMappingURL=read-only-shrink.js.map