salmon-loop 0.2.3 → 0.2.16

package/dist/core/grizzco/steps/patch/diff-normalization.js

@@ -0,0 +1,70 @@
+import { text } from '../../../../locales/index.js';
+import { wrapPatchEmpty, wrapPatchInvalid, wrapPatchNotUnifiedDiff } from '../../../llm/errors.js';
+import { extractUnifiedDiffFromLLMContent } from '../../../llm/utils.js';
+import { normalizeDiff, validateDiff } from '../../../patch/diff.js';
+import { DiffValidationError } from '../../../types/errors.js';
+const isCanonicalDiffHeader = (diffText) => diffText.trimStart().startsWith('diff --git ');
+export function assertCanonicalDiffHeader(diffText) {
+    if (!diffText.trim()) {
+        throw wrapPatchEmpty();
+    }
+    if (!isCanonicalDiffHeader(diffText)) {
+        throw wrapPatchNotUnifiedDiff();
+    }
+}
+export function rewriteUniqueBasenameDiffPaths(diffText, plannedFiles) {
+    if (plannedFiles.length === 0)
+        return diffText;
+    const basenameMap = new Map();
+    for (const file of plannedFiles.map((item) => item.replace(/\\/g, '/'))) {
+        const basename = file.split('/').at(-1);
+        if (!basename)
+            continue;
+        const existing = basenameMap.get(basename);
+        if (existing === undefined) {
+            basenameMap.set(basename, file);
+            continue;
+        }
+        if (existing !== file) {
+            basenameMap.set(basename, null);
+        }
+    }
+    const resolvePath = (candidate) => {
+        const normalized = candidate.replace(/\\/g, '/');
+        if (normalized === 'dev/null' || normalized.includes('/'))
+            return candidate;
+        const mapped = basenameMap.get(normalized);
+        return mapped ?? candidate;
+    };
+    return diffText
+        .replace(/^diff --git a\/(.+?) b\/(.+)$/gm, (_, left, right) => `diff --git a/${resolvePath(left)} b/${resolvePath(right)}`)
+        .replace(/^--- a\/(.+)$/gm, (_, left) => `--- a/${resolvePath(left)}`)
+        .replace(/^\+\+\+ b\/(.+)$/gm, (_, right) => `+++ b/${resolvePath(right)}`);
+}
+export function validatePatchDiff(diffText) {
+    assertCanonicalDiffHeader(diffText);
+    const normalizedPatch = normalizeDiff(diffText);
+    try {
+        const diffMeta = validateDiff(normalizedPatch);
+        return {
+            patch: diffText,
+            normalizedPatch,
+            diffMeta,
+        };
+    }
+    catch (error) {
+        if (error instanceof DiffValidationError) {
+            if (error.message === text.diff.notUnifiedFormat)
+                throw wrapPatchNotUnifiedDiff();
+            if (error.message.startsWith(text.llm.patchEmpty()))
+                throw wrapPatchEmpty();
+            throw wrapPatchInvalid(error.message);
+        }
+        throw error;
+    }
+}
+export function extractAndValidatePatch(args) {
+    const patch = rewriteUniqueBasenameDiffPaths(extractUnifiedDiffFromLLMContent(args.rawContent), args.plannedFiles);
+    return validatePatchDiff(patch);
+}
+//# sourceMappingURL=diff-normalization.js.map

package/dist/core/grizzco/steps/patch/diff-salvage.js

@@ -0,0 +1,46 @@
+import { extractAndValidatePatch } from './diff-normalization.js';
+const SALVAGEABLE_PATCH_CODES = new Set(['LLM_PATCH_NOT_UNIFIED_DIFF', 'LLM_PATCH_EMPTY']);
+function errorMessage(error) {
+    if (error instanceof Error)
+        return error.message;
+    return String(error);
+}
+export function isSalvageablePatchError(error) {
+    if (!error || typeof error !== 'object')
+        return false;
+    const llmCode = error.llmCode;
+    return typeof llmCode === 'string' && SALVAGEABLE_PATCH_CODES.has(llmCode);
+}
+export async function salvagePatchDiff(args) {
+    if (!isSalvageablePatchError(args.initialError))
+        return null;
+    args.onAttempt?.({
+        reason: errorMessage(args.initialError),
+        badContentLength: args.rawContent.length,
+    });
+    const repaired = await args.repair({ badContent: args.rawContent });
+    const repairedContent = repaired.content || '';
+    try {
+        const validated = extractAndValidatePatch({
+            rawContent: repairedContent,
+            plannedFiles: args.plannedFiles,
+        });
+        args.onResult?.({
+            ok: true,
+            contentLength: repairedContent.length,
+        });
+        return {
+            ...validated,
+            rawContent: repairedContent,
+        };
+    }
+    catch (salvageError) {
+        args.onResult?.({
+            ok: false,
+            contentLength: repairedContent.length,
+            error: errorMessage(salvageError).slice(0, 400),
+        });
+        throw args.initialError;
+    }
+}
+//# sourceMappingURL=diff-salvage.js.map

package/dist/core/grizzco/steps/patch/prompt-input.js

@@ -0,0 +1,42 @@
+import { LIMITS } from '../../../config/limits.js';
+import { getPatchPrompt, getPatchSystemPrompt } from '../../../prompts/runtime.js';
+import { SessionReplacementPreviewProvider } from '../../../session/replacement-preview-provider.js';
+import { Phase } from '../../../types/runtime.js';
+import { buildPhaseRequestEnvelope } from '../request-assembly.js';
+export async function buildPatchPromptInput(args) {
+    const planStr = JSON.stringify(args.plan, null, 2);
+    const systemPrompt = await getPatchSystemPrompt(args.promptVisibleTools, {
+        plan: args.planRuntime,
+    });
+    const requestEnvelope = await buildPhaseRequestEnvelope({
+        phase: args.phase ?? Phase.PATCH,
+        defaultNamespace: 'patch',
+        context: args.context,
+        contextResult: args.contextResult,
+        cacheSharing: args.cacheSharing,
+        onCacheMismatch: args.onCacheMismatch,
+        systemPrompt,
+        buildUserPrompt: (contextPrompt) => getPatchPrompt(planStr, contextPrompt, LIMITS.maxFilesChanged, LIMITS.maxDiffLines, args.lastError),
+        conversationContext: args.conversationContext,
+        artifactHints: args.artifactHints,
+        previewProvider: new SessionReplacementPreviewProvider(args.replacementState),
+        toolCallingAudit: args.toolCallingAudit,
+        toolVisibility: args.toolVisibility,
+        extraAttachments: [
+            {
+                key: 'plan-json',
+                kind: 'plan',
+                label: 'Plan JSON',
+                content: planStr,
+            },
+        ],
+    });
+    return {
+        planStr,
+        systemPrompt,
+        envelope: requestEnvelope.envelope,
+        baseMessages: requestEnvelope.baseMessages,
+        cacheSurface: requestEnvelope.cacheSurface,
+    };
+}
+//# sourceMappingURL=prompt-input.js.map

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

@@ -1,98 +1,116 @@
-import { text } from '../../../locales/index.js';
-import { GitAdapter } from '../../adapters/git/git-adapter.js';
-import { LIMITS } from '../../config/limits.js';
+import { supportsLlmStreaming } from '../../llm/capabilities.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 { recordAuditEvent } from '../../observability/audit-trail.js';
 import { chatWithTools, chatWithToolsStreaming } from '../../tools/session.js';
-import { DiffValidationError } from '../../types/errors.js';
+import { resolveVisibleToolSpecs } from '../../tools/tool-visibility.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 },
+import { checkPatchApplies } from './patch/apply-check.js';
+import { extractAndValidatePatch } from './patch/diff-normalization.js';
+import { salvagePatchDiff } from './patch/diff-salvage.js';
+import { buildPatchPromptInput } from './patch/prompt-input.js';
+import { buildPhaseToolRuntimeContext, buildToolVisibilityRuntime } from './tool-runtime.js';
+const recordPatchSalvageAttempt = (args) => {
+    recordAuditEvent('patch.salvage.attempt', {
+        reason: args.reason,
+        badContentLength: args.badContentLength,
+        toolsDisabled: true,
+    }, { source: 'patch', severity: 'low', scope: 'session', phase: 'PATCH' });
+};
+const recordPatchSalvageResult = (args) => {
+    recordAuditEvent('patch.salvage.result', {
+        ok: args.ok,
+        contentLength: args.contentLength,
+        error: args.error,
+    }, {
+        source: 'patch',
+        severity: args.ok ? 'low' : 'medium',
+        scope: 'session',
+        phase: 'PATCH',
     });
-}
+};
 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);
+        const legacyPatch = 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,
+            content: legacyPatch,
+        });
+        const validated = extractAndValidatePatch({
+            rawContent: legacyPatch,
+            plannedFiles: ctx.plan.files,
         });
-        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`,
+            message: `Patch generated: ${validated.diffMeta.changedFiles.length} files changed`,
             timestamp: new Date(),
         });
         return {
             ...ctx,
-            diff: normalizedPatch,
-            diffMeta,
-            changedFiles: diffMeta.changedFiles,
+            diff: validated.normalizedPatch,
+            diffMeta: validated.diffMeta,
+            changedFiles: validated.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,
+    const toolVisibility = buildToolVisibilityRuntime(ctx);
+    const promptVisibleTools = resolveVisibleToolSpecs({
+        phase: Phase.PATCH,
+        toolstack,
+        worktreeRoot: ctx.workspace.strategy === 'worktree' ? ctx.workspace.workPath : undefined,
+        flowMode: ctx.mode,
+        runtime: toolVisibility,
+    });
+    const patchPromptInput = await buildPatchPromptInput({
+        context: ctx.context,
+        contextResult: ctx.contextResult,
+        plan: ctx.plan,
+        planRuntime: ctx.planRuntime,
+        lastError: ctx.lastError,
+        promptVisibleTools,
+        toolVisibility: {
+            toolstack,
+            runtime: toolVisibility,
+            worktreeRoot: ctx.workspace.strategy === 'worktree' ? ctx.workspace.workPath : undefined,
+            flowMode: ctx.mode,
+        },
+        phase: Phase.PATCH,
+        cacheSharing: ctx.cacheSharing,
+        onCacheMismatch: (mismatch) => {
+            recordAuditEvent('request.cache_sharing_hash_mismatch', mismatch, {
+                source: 'llm',
+                severity: 'low',
+                scope: 'session',
+                phase: Phase.PATCH,
+            });
+        },
         conversationContext: ctx.options.conversationContext,
+        artifactHints: ctx.artifactHints,
+        replacementState: ctx.replacementState,
+        toolCallingAudit: ctx.toolCallingAudit,
     });
-    const supportsStreaming = typeof ctx.options.llm.chatStream === 'function';
+    const { cacheSurface, envelope, baseMessages } = patchPromptInput;
+    const supportsStreaming = supportsLlmStreaming(ctx.options.llm, Phase.PATCH);
     const llmOutput = {
         policy: ctx.options.llmOutput,
         kind: 'patch',
         step: 'PATCH',
     };
     const response = await (supportsStreaming ? chatWithToolsStreaming : chatWithTools)(baseMessages, {
+        providerHints: envelope.providerHints,
         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,
-        },
+        runtime: buildPhaseToolRuntimeContext(ctx, Phase.PATCH, cacheSurface),
+        toolVisibility,
         toolstack,
         eventPayload: ctx.options.eventPayload,
         toolCallingAudit: {
@@ -107,114 +125,55 @@ export const generatePatch = async (ctx) => {
         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;
-        }
-    };
+    let parsedPatch;
     try {
-        patch = extractUnifiedDiffFromLLMContent(rawContent);
-        normalizedPatch = normalizeDiff(patch);
-        diffMeta = validateWithLlmErrors(patch);
+        parsedPatch = extractAndValidatePatch({
+            rawContent,
+            plannedFiles: ctx.plan.files,
+        });
     }
     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;
+        const salvaged = await salvagePatchDiff({
+            initialError: e,
+            rawContent,
+            plannedFiles: ctx.plan.files,
+            repair: ({ badContent }) => repairToUnifiedDiff({ badContent }),
+            onAttempt: recordPatchSalvageAttempt,
+            onResult: recordPatchSalvageResult,
+        });
+        if (!salvaged) {
+            throw e;
         }
+        rawContent = salvaged.rawContent;
+        parsedPatch = salvaged;
+        emitLlmOutput({
+            emit: ctx.emit,
+            policy: ctx.options.llmOutput,
+            kind: 'patch',
+            step: 'PATCH',
+            content: salvaged.patch,
+        });
     }
     // 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,
+        diff: parsedPatch.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.
-        }
+        // 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`,
+        message: `Patch generated: ${parsedPatch.diffMeta.changedFiles.length} files changed`,
         timestamp: new Date(),
     });
     return {
         ...ctx,
-        diff: normalizedPatch,
-        diffMeta,
-        changedFiles: diffMeta.changedFiles,
+        diff: parsedPatch.normalizedPatch,
+        diffMeta: parsedPatch.diffMeta,
+        changedFiles: parsedPatch.diffMeta.changedFiles,
     };
 };
 //# sourceMappingURL=patch.js.map