mixdog 0.9.63 → 0.9.64

package/src/runtime/agent/orchestrator/tools/patch/orchestrator.mjs

@@ -3,14 +3,20 @@
 // executePatchTool entry point + replay capture. Moved verbatim from
 // patch.mjs; control flow and output are unchanged.
 
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
-import { resolve as pathResolve, isAbsolute, join as pathJoin } from 'node:path';
+import { chmodSync, existsSync, readFileSync, writeFileSync, mkdirSync, rmSync, statSync } from 'node:fs';
+import { dirname as pathDirname, resolve as pathResolve, isAbsolute, join as pathJoin } from 'node:path';
 import { parsePatch } from 'diff';
 import { getAbortSignalForSession } from '../../session/abort-lookup.mjs';
-import { withBuiltinPathLocks } from '../builtin.mjs';
+import {
+  clearReadSnapshotForPath,
+  invalidateBuiltinResultCache,
+  normalizeOutputPath,
+  withBuiltinPathLocks,
+} from '../builtin.mjs';
 import { withAdvisoryLocks } from '../builtin/advisory-lock.mjs';
 import { wrapMutationRouteOutput } from '../mutation-planner.mjs';
 import { getPluginData } from '../../config.mjs';
+import { markCodeGraphDirtyPaths } from '../code-graph-state.mjs';
 import { prepareInput, isV4APatchInput, hasUnifiedBareV4AHunk, canFallbackCountedUnified, parseV4APatch, parseUnifiedBareV4APatch, parseUnifiedCountedAsV4APatch, isCompactedPlaceholderPatch, salvageV4AOpening } from './parsing.mjs';
 import {
   resolveBasePath,
@@ -27,7 +33,6 @@ import {
 import { ensureNativePatchBinaryAvailable } from './native-server.mjs';
 import { assertPathReachable } from '../builtin/fs-reachability.mjs';
 import { dispatchNativePatch, dispatchJsPatchEntries } from './dispatch.mjs';
-import { normalizeOutputPath } from '../builtin.mjs';
 import {
   planV4ARenameSections,
   applyV4ARenameSections,
@@ -42,6 +47,42 @@ function isPatchErrorText(text) {
   return /^Error:/i.test(String(text ?? '').trimStart());
 }
 
+function capturePatchRollbackState(paths) {
+  return paths.map((fullPath) => {
+    if (!existsSync(fullPath)) return { fullPath, existed: false, content: null, mode: null };
+    const stat = statSync(fullPath);
+    if (!stat.isFile()) throw new Error(`apply_patch: rollback snapshot target is not a regular file: ${normalizeOutputPath(fullPath)}`);
+    return {
+      fullPath,
+      existed: true,
+      content: readFileSync(fullPath),
+      mode: stat.mode,
+    };
+  });
+}
+
+function restorePatchRollbackState(snapshots, readStateScope) {
+  const errors = [];
+  const paths = snapshots.map((snapshot) => snapshot.fullPath);
+  for (const snapshot of snapshots) {
+    try {
+      if (snapshot.existed) {
+        mkdirSync(pathDirname(snapshot.fullPath), { recursive: true });
+        writeFileSync(snapshot.fullPath, snapshot.content);
+        if (snapshot.mode != null) chmodSync(snapshot.fullPath, snapshot.mode);
+      } else if (existsSync(snapshot.fullPath)) {
+        rmSync(snapshot.fullPath, { force: true });
+      }
+    } catch (err) {
+      errors.push(`${normalizeOutputPath(snapshot.fullPath)} — ${err?.message || String(err)}`);
+    }
+  }
+  invalidateBuiltinResultCache(paths);
+  markCodeGraphDirtyPaths(paths);
+  for (const fullPath of paths) clearReadSnapshotForPath(fullPath, readStateScope);
+  return errors;
+}
+
 // Apply one "wave" (a set of unique-target parsed entries) via the native
 // (+ JS out-of-base) split. Returns { backend, text } on success or
 // { backend, error } so the caller decides whether earlier waves already
@@ -99,7 +140,7 @@ async function applyParsedWave({ parsed: wparsed, entries: wentries, headerRewri
 async function applyPatchSequence(patchStr, requestedFormat, basePath, ctx) {
   const {
     v4aConvertOpts, dryRun, fuzz, fuzzy, rejectPartial,
-    readStateScope, abortSignal, mutationPlan,
+    readStateScope, abortSignal, mutationPlan, rollbackOnFailure,
   } = ctx;
 
   // Build the ordered section "units". Each unit resolves its own parsed
@@ -206,6 +247,14 @@ async function applyPatchSequence(patchStr, requestedFormat, basePath, ctx) {
 
   return withBuiltinPathLocks(lockPaths, () =>
     withAdvisoryLocks(lockPaths, async () => {
+      let rollbackSnapshots = [];
+      if (!dryRun && rollbackOnFailure) {
+        try {
+          rollbackSnapshots = capturePatchRollbackState(lockPaths);
+        } catch (err) {
+          return `Error: ${err?.message || String(err)}`;
+        }
+      }
       const applied = [];
       const skipped = [];
       let failed = null;
@@ -275,17 +324,27 @@ async function applyPatchSequence(patchStr, requestedFormat, basePath, ctx) {
         return wrapPatchMutationOutput(body, mutationPlan, { backend });
       }
       const failMsg = failed.error.replace(/^Error:\s*/, '');
+      const rollbackErrors = (!dryRun && rollbackOnFailure)
+        ? restorePatchRollbackState(rollbackSnapshots, readStateScope)
+        : [];
       const committedPhrase = dryRun
         ? `${applied.length} earlier section(s) were validated`
-        : `${applied.length} earlier section(s) were applied to disk (committed) and left in place`;
+        : (rollbackOnFailure
+          ? (rollbackErrors.length === 0
+            ? `${applied.length} earlier section(s) were applied, then all touched paths were rolled back to their pre-patch state`
+            : `${applied.length} earlier section(s) were applied, but rollback was incomplete`)
+          : `${applied.length} earlier section(s) were applied to disk (committed) and left in place`);
       const lines = [
         `Error: apply_patch sequence stopped at section ${failedIndex + 1}/${units.length} (${failed.displayPath}); `
           + `${committedPhrase}; ${skipped.length} later section(s) were skipped (not attempted).`,
       ];
       if (appliedTexts) {
-        lines.push(`--- ${dryRun ? 'validated' : 'applied (committed to disk)'} ---`, appliedTexts);
+        lines.push(`--- ${dryRun ? 'validated' : (rollbackOnFailure ? 'applied before rollback' : 'applied (committed to disk)')} ---`, appliedTexts);
       }
       lines.push(`--- failed section: ${failed.displayPath} ---`, failMsg);
+      if (rollbackErrors.length > 0) {
+        lines.push('--- rollback incomplete ---', ...rollbackErrors);
+      }
       if (skipped.length > 0) {
         lines.push(`--- skipped (not attempted): ${skipped.join(', ')} ---`);
       }
@@ -397,14 +456,18 @@ async function apply_patch(args, cwd, options = {}) {
   const rejectedV4AHunks = [];
   const v4aConvertOpts = { rejectPartial, rejectedHunks: rejectedV4AHunks, fuzzy, dryRun, readStateScope };
   // Default internal ordered mode: apply sections in listed order, stop at the
-  // first failure, and report applied/failed/skipped with true disk state.
+  // first failure, and roll every touched path back to its pre-patch state.
+  // mode:"partial" retains the old committed-prefix behavior for internal
+  // callers that explicitly need it.
   // The legacy bulk/atomic path remains available as an explicit escape hatch.
+  const patchMode = String(args?.mode || '').toLowerCase();
   const legacyBulkMode = args?.sequence === false
-    || ['atomic', 'bulk'].includes(String(args?.mode || '').toLowerCase());
+    || ['atomic', 'bulk'].includes(patchMode);
   if (!legacyBulkMode) {
     return applyPatchSequence(patchStr, requestedFormat, basePath, {
       v4aConvertOpts, dryRun, fuzz, fuzzy, rejectPartial,
       readStateScope, abortSignal, mutationPlan,
+      rollbackOnFailure: patchMode !== 'partial',
     });
   }
   let v4aRenamePlan = null;

package/src/runtime/agent/orchestrator/tools/patch/parsing.mjs

@@ -16,7 +16,7 @@ export function prepareInput(patchStr) {
   return String(patchStr).replace(/^\uFEFF/, '').replace(/\r\n/g, '\n');
 }
 
-export function isApplyPatchEnvelope(patchStr) {
+function isApplyPatchEnvelope(patchStr) {
   const text = prepareInput(patchStr).trimStart();
   return text.startsWith('*** Begin Patch')
     || text.startsWith('*** Add File:')
@@ -96,7 +96,7 @@ export function hasUnifiedBareV4AHunk(patchStr) {
   return text.split('\n').some((line) => line.startsWith('@@') && !UNIFIED_HUNK_HEADER_RE.test(line));
 }
 
-export function isUnifiedHunkCountError(err) {
+function isUnifiedHunkCountError(err) {
   const message = String(err?.message || err || '');
   return /Hunk at line .*more lines than expected|Hunk at line .*less lines than expected|expected \d+ old lines|line count did not match/i.test(message);
 }
@@ -128,7 +128,7 @@ function stripV4APathHeader(line, prefix) {
   return stripPatchPathMetadata(String(line || '').slice(prefix.length));
 }
 
-export function normaliseV4APath(rawPath) {
+function normaliseV4APath(rawPath) {
   const p = stripPatchPathMetadata(rawPath);
   if (!p) return '';
   return p.replace(/^["']|["']$/g, '').replace(/\\/g, '/');
@@ -187,7 +187,7 @@ function splitPatchLines(patchStr) {
 // Matches EVERY placeholder variant, not just "<key>: <N> chars, sha256:…":
 // the marker key segment varies ("patch", "old_string", "patch v4a, sha256:…",
 // etc.), so anchor on the "[mixdog compacted …]" bracket span alone.
-export const COMPACTED_PLACEHOLDER_RE = /^\s*\[mixdog compacted\b[^\]\n]*\]/;
+const COMPACTED_PLACEHOLDER_RE = /^\s*\[mixdog compacted\b[^\]\n]*\]/;
 
 // Mid-body scan reuses the same broad bracket shape. It only runs on lines that
 // are NOT unified diff content (+/-/space-prefixed), so a legit edit whose real

package/src/runtime/agent/orchestrator/tools/patch/paths.mjs

@@ -197,7 +197,7 @@ function nativeHeaderSupported(entry) {
 // ancestor when the leaf does not yet exist (e.g. a create-mode target).
 // Returns the resolved real path, or the lexically-resolved path if no
 // ancestor can be realpath'd.
-export function realpathNearestExistingAncestor(absPath) {
+function realpathNearestExistingAncestor(absPath) {
   let cur = pathResolve(absPath);
   while (true) {
     try {

package/src/runtime/agent/orchestrator/tools/patch/v4a-convert.mjs

@@ -530,7 +530,7 @@ function readRawBufForV4AConversion(fullPath) {
 // file: the V4A source-line cache MUST key on this normalized form at every
 // get/set, otherwise a mixed-case duplicate section refreshed under one
 // casing is missed under another and converts against stale/original lines.
-export function v4aLinesCacheKey(fullPath) {
+function v4aLinesCacheKey(fullPath) {
   return process.platform === 'win32' ? String(fullPath).toLowerCase() : String(fullPath);
 }
 

package/src/runtime/agent/orchestrator/tools/patch-tool-defs.mjs

@@ -1,4 +1,4 @@
-export const APPLY_PATCH_LARK_GRAMMAR = `start: begin_patch hunk+ end_patch
+const APPLY_PATCH_LARK_GRAMMAR = `start: begin_patch hunk+ end_patch
 begin_patch: "*** Begin Patch" LF
 end_patch: "*** End Patch" LF?
 
@@ -19,14 +19,14 @@ eof_line: "*** End of File" LF
 %import common.LF
 `;
 
-export const APPLY_PATCH_FREEFORM_DESCRIPTION = 'Use the `apply_patch` tool to edit files. This is a FREEFORM tool, so do not wrap the patch in JSON.';
+const APPLY_PATCH_FREEFORM_DESCRIPTION = 'Use the `apply_patch` tool to edit files. This is a FREEFORM tool, so do not wrap the patch in JSON.';
 
 export const PATCH_TOOL_DEFS = [
   {
     name: 'apply_patch',
     title: 'Mixdog Apply Patch',
     annotations: { title: 'Mixdog Apply Patch', readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false, compressible: false, compressibleLossless: true },
-    description: 'Apply known file edits in one patch; sections run in listed order. Do not split a dependent edit across turns.',
+    description: 'Apply known file edits in one atomic patch; sections run in listed order and all touched paths roll back if any section fails. Do not split a dependent edit across turns.',
     freeformDescription: APPLY_PATCH_FREEFORM_DESCRIPTION,
     freeform: {
       type: 'grammar',
@@ -36,7 +36,7 @@ export const PATCH_TOOL_DEFS = [
     inputSchema: {
       type: 'object',
       properties: {
-        patch: { type: 'string', description: 'Patch text. V4A preferred; use one file block per target file with exact current context; include all known edits in listed order.' },
+        patch: { type: 'string', description: 'Patch text. V4A preferred; use one file block per target file with exact current context; include all known edits in listed order. On failure, the tool rolls all earlier writes back.' },
         format: { type: 'string', enum: ['unified', 'v4a'], description: 'Auto-detected.' },
         base_path: { type: 'string', description: 'Repo root.' },
         dry_run: { type: 'boolean', description: 'Default false. true = validate only, no write.' },

package/src/runtime/agent/orchestrator/tools/patch.mjs

@@ -42,6 +42,6 @@ import {
   splitBufferLinesForPatch,
 } from './patch/matcher.mjs';
 
-export const __patchTestHooks = { findFirstFailingUnifiedHunk, computeUnifiedChangeBand, collectUnifiedOps, unifiedOldLinesMatchAt, splitBufferLinesForPatch };
+const __patchTestHooks = { findFirstFailingUnifiedHunk, computeUnifiedChangeBand, collectUnifiedOps, unifiedOldLinesMatchAt, splitBufferLinesForPatch };
 
 scheduleNativePatchPrewarm();

package/src/runtime/agent/orchestrator/tools/result-compression.mjs

@@ -141,7 +141,7 @@ function normalizeTrailingNewlines(text) {
 // aggregated worker bodies in ai-wrapped-dispatch). These functions are
 // NO LONGER part of the tool-result compression chain — that chain is
 // lossless-only.
-export function normalizeWhitespace(text) {
+function normalizeWhitespace(text) {
     if (typeof text !== 'string') return text;
     return text
         .split('\n')
@@ -150,7 +150,7 @@ export function normalizeWhitespace(text) {
         .replace(/\n{3,}/g, '\n\n');
 }
 
-export function dedupRepeatedLines(text) {
+function dedupRepeatedLines(text) {
     if (typeof text !== 'string') return text;
     const lines = text.split('\n');
     const out = [];
@@ -240,7 +240,7 @@ function _trimLongLines(content) {
  * @param {string} content
  * @param {{ trimLongLines?: boolean, fullOutputPath?: string, sequential?: boolean }} [opts]
  */
-export function tailTrimLargeOutput(content, opts = {}) {
+function tailTrimLargeOutput(content, opts = {}) {
     if (typeof content !== 'string') return content;
     let text = content;
     if (opts.trimLongLines) {