mixdog 0.9.172 → 0.9.174

package/src/runtime/agent/orchestrator/tools/builtin/read-snapshot-runtime.mjs

@@ -48,41 +48,89 @@ export function readTextForSnapshotCheck(fullPath, cache = null, st = null) {
   return content;
 }
 
-export function recordReadSnapshot(fullPath, st, scope = null, meta = {}) {
-  const readFiles = readFilesForScope(scope);
-  let mtimeMs;
-  let ctimeMs;
-  let size;
+// The stat identity a snapshot is keyed on: the caller's stat when it has
+// one, else a fresh stat; an unstattable path gets a never-matching identity.
+function snapshotStatIdentity(fullPath, st) {
   try {
-    if (st && typeof st.mtimeMs === 'number') {
-      mtimeMs = st.mtimeMs;
-      ctimeMs = st.ctimeMs;
-      size = st.size;
-    } else {
-      const fresh = statSync(fullPath);
-      mtimeMs = fresh.mtimeMs;
-      ctimeMs = fresh.ctimeMs;
-      size = fresh.size;
-    }
+    const source = st && typeof st.mtimeMs === 'number' ? st : statSync(fullPath);
+    return { mtimeMs: source.mtimeMs, ctimeMs: source.ctimeMs, size: source.size };
   } catch {
-    mtimeMs = Date.now();
-    ctimeMs = mtimeMs;
-    size = 0;
+    const now = Date.now();
+    return { mtimeMs: now, ctimeMs: now, size: 0 };
+  }
+}
+
+function isMutationSource(source) {
+  return source === 'edit' || String(source || '').startsWith('apply_patch_');
+}
+
+// Body-delivery provenance. An edit / apply_patch snapshot claims full-file
+// coverage (it knows the bytes it wrote), which let a later Read answer
+// "[file unchanged]" for a body this session had NEVER received. Full-file
+// knowledge is inherited only from a prior full-file READ of the same path.
+// Returns undefined when the incoming meta's own value stands.
+function resolveBodyDelivered({ next, meta, priorSnapshot, identity, incomingIsGrep }) {
+  if (isMutationSource(meta.source)) {
+    const priorLineCount = Number(priorSnapshot?.fileLineCount);
+    const priorPagedFull =
+      Number.isFinite(priorLineCount) &&
+      priorLineCount > 0 &&
+      snapshotRangesCoverAllLines(priorSnapshot, priorLineCount);
+    // The earlier read only describes THIS file if it still matched when
+    // the mutation ran: the caller passes the target's pre-write identity
+    // and it must equal the snapshot's. Missing evidence fails closed, so
+    // an external write landing between read and edit can never hide
+    // behind "[file unchanged]".
+    const priorStillCurrent =
+      !!priorSnapshot && !!meta.preMutationStat && statMatchesSnapshot(meta.preMutationStat, priorSnapshot);
+    // A prior mutation's full range is synthetic (see recordReadSnapshot), so
+    // only its explicit bodyDelivered counts; otherwise a second edit after a
+    // partial read promoted the never-read lines to delivered.
+    const priorRangesAreReads = !isMutationSource(priorSnapshot?.source);
+    return (
+      priorStillCurrent &&
+      priorSnapshot.grepOnly !== true &&
+      (priorSnapshot.bodyDelivered === true ||
+        (priorRangesAreReads && (snapshotCoversFullFile(priorSnapshot) || priorPagedFull)))
+    );
+  }
+  if (!incomingIsGrep && snapshotCoversFullFile(next)) return true;
+  // A partial read cannot carry full-body delivery across file versions.
+  if (priorSnapshot?.bodyDelivered === true && statMatchesSnapshot(identity, priorSnapshot)) return true;
+  return undefined;
+}
+
+// Range hashes carried over from the same file version, then the incoming
+// read's own; malformed rows are dropped.
+function collectRangeHashRows(existing, sameFile, meta) {
+  const candidates = [];
+  if (sameFile && Array.isArray(existing.rangeHashes)) {
+    candidates.push(...existing.rangeHashes);
+  } else if (sameFile && existing.rangeHash && Array.isArray(existing.ranges) && existing.ranges.length === 1) {
+    candidates.push({ ...existing.ranges[0], hash: existing.rangeHash });
+  }
+  if (meta.rangeHash && Array.isArray(meta.ranges) && meta.ranges.length === 1) {
+    candidates.push({ ...meta.ranges[0], hash: meta.rangeHash });
   }
+  if (Array.isArray(meta.rangeHashes)) candidates.push(...meta.rangeHashes);
+  return candidates.map((row) => normaliseRangeHashEntry(row)).filter(Boolean);
+}
+
+export function recordReadSnapshot(fullPath, st, scope = null, meta = {}) {
+  const readFiles = readFilesForScope(scope);
+  const identity = snapshotStatIdentity(fullPath, st);
+  const { mtimeMs, ctimeMs, size } = identity;
   const incomingRanges = Array.isArray(meta.ranges) ? meta.ranges : [{ startLine: 1, endLine: Infinity }];
   const replaceExisting = meta.replaceExisting === true;
   const existing = replaceExisting ? null : readFiles.get(fullPath);
-  const sameFile =
-    existing && statMatchesSnapshot({ mtimeMs, ctimeMs, size }, existing) && Array.isArray(existing.ranges);
+  const sameFile = existing && statMatchesSnapshot(identity, existing) && Array.isArray(existing.ranges);
   // A mutation snapshot claims the full range because it knows the bytes it
   // wrote, not because the session received them. Merging a later partial
   // read into that synthetic range produced full coverage, which promoted
   // bodyDelivered and let the next edit hide never-delivered ranges behind
   // "[file unchanged]". Only delivered ranges take part in the merge.
   const existingIsUndeliveredMutation =
-    sameFile &&
-    (existing.source === 'edit' || String(existing.source || '').startsWith('apply_patch_')) &&
-    existing.bodyDelivered !== true;
+    sameFile && isMutationSource(existing.source) && existing.bodyDelivered !== true;
   const retainedRanges = sameFile && !existingIsUndeliveredMutation ? existing.ranges : [];
   const merged = mergeReadRanges([...retainedRanges, ...incomingRanges]);
   // fileLineCount is omitted here so it can ONLY be set via the explicit
@@ -109,55 +157,15 @@ export function recordReadSnapshot(fullPath, st, scope = null, meta = {}) {
   // replaceExisting.
   const incomingIsGrep = meta.source === 'grep';
   next.grepOnly = incomingIsGrep && (sameFile ? existing.grepOnly === true : true);
-  // Body-delivery provenance. An edit / apply_patch snapshot claims full-file
-  // coverage (it knows the bytes it wrote), which let a later Read answer
-  // "[file unchanged]" for a body this session had NEVER received. Full-file
-  // knowledge is inherited only from a prior full-file READ of the same path.
-  const priorSnapshot = readFiles.get(fullPath);
-  const incomingIsMutation = meta.source === 'edit' || String(meta.source || '').startsWith('apply_patch_');
-  if (incomingIsMutation) {
-    const priorLineCount = Number(priorSnapshot?.fileLineCount);
-    const priorPagedFull =
-      Number.isFinite(priorLineCount) &&
-      priorLineCount > 0 &&
-      snapshotRangesCoverAllLines(priorSnapshot, priorLineCount);
-    // The earlier read only describes THIS file if it still matched when
-    // the mutation ran: the caller passes the target's pre-write identity
-    // and it must equal the snapshot's. Missing evidence fails closed, so
-    // an external write landing between read and edit can never hide
-    // behind "[file unchanged]".
-    const priorStillCurrent =
-      !!priorSnapshot && !!meta.preMutationStat && statMatchesSnapshot(meta.preMutationStat, priorSnapshot);
-    next.bodyDelivered =
-      priorStillCurrent &&
-      priorSnapshot.grepOnly !== true &&
-      (priorSnapshot.bodyDelivered === true || snapshotCoversFullFile(priorSnapshot) || priorPagedFull);
-  } else if (!incomingIsGrep && snapshotCoversFullFile(next)) {
-    next.bodyDelivered = true;
-  } else if (priorSnapshot?.bodyDelivered === true && statMatchesSnapshot({ mtimeMs, ctimeMs, size }, priorSnapshot)) {
-    // A partial read cannot carry full-body delivery across file versions.
-    next.bodyDelivered = true;
-  }
-  const rangeHashRows = [];
-  if (sameFile && Array.isArray(existing.rangeHashes)) {
-    for (const row of existing.rangeHashes) {
-      const nextRow = normaliseRangeHashEntry(row);
-      if (nextRow) rangeHashRows.push(nextRow);
-    }
-  } else if (sameFile && existing.rangeHash && Array.isArray(existing.ranges) && existing.ranges.length === 1) {
-    const nextRow = normaliseRangeHashEntry({ ...existing.ranges[0], hash: existing.rangeHash });
-    if (nextRow) rangeHashRows.push(nextRow);
-  }
-  if (meta.rangeHash && Array.isArray(meta.ranges) && meta.ranges.length === 1) {
-    const nextRow = normaliseRangeHashEntry({ ...meta.ranges[0], hash: meta.rangeHash });
-    if (nextRow) rangeHashRows.push(nextRow);
-  }
-  if (Array.isArray(meta.rangeHashes)) {
-    for (const row of meta.rangeHashes) {
-      const nextRow = normaliseRangeHashEntry(row);
-      if (nextRow) rangeHashRows.push(nextRow);
-    }
-  }
+  const bodyDelivered = resolveBodyDelivered({
+    next,
+    meta,
+    priorSnapshot: readFiles.get(fullPath),
+    identity,
+    incomingIsGrep,
+  });
+  if (bodyDelivered !== undefined) next.bodyDelivered = bodyDelivered;
+  const rangeHashRows = collectRangeHashRows(existing, sameFile, meta);
   if (!next.contentHash && snapshotCoversFullFile(next)) {
     try {
       // Reuse the raw-content cache (populated by the read that produced

package/src/runtime/agent/orchestrator/tools/builtin/read-special-files.mjs

@@ -1,5 +1,4 @@
-import { readFile, stat } from 'node:fs/promises';
-import { open } from 'node:fs/promises';
+import { open, readFile, stat } from 'node:fs/promises';
 import { READ_MAX_SIZE_BYTES } from './read-constants.mjs';
 import { imageBlocksFromBuffer } from './read-image-resize.mjs';
 import { inspectPdfBuffer } from '../../../../attachments/pdf-extract.mjs';
@@ -132,6 +131,67 @@ export async function extractPdfText(
   }
 }
 
+const joinedNotebookText = (value) => (Array.isArray(value) ? value.join('') : value);
+
+// A code cell's source followed by its outputs as text: text outputs inline
+// (a single huge one replaced with a jq hint rather than dumped), image
+// outputs as placeholders plus the images to embed AFTER the code block.
+function renderIpynbCodeCell(cell, cellIndex, fullPath) {
+  let block = joinedNotebookText(cell.source) || '';
+  const outputs = Array.isArray(cell.outputs) ? cell.outputs : [];
+  const pendingImages = [];
+  for (const out of outputs) {
+    const data = out.data || {};
+    if (data['text/plain'] || out.text) {
+      const rawTxt = joinedNotebookText(data['text/plain'] || out.text);
+      if (typeof rawTxt === 'string' && rawTxt.length > IPYNB_OUTPUT_MAX_CHARS) {
+        block += `\n# Output: [large output omitted — ${rawTxt.length} chars; inspect with: cat "${fullPath}" | jq '.cells[${cellIndex}].outputs']`;
+      } else {
+        block += `\n# Output:\n${rawTxt}`;
+      }
+    } else if (data['image/png'] || data['image/jpeg']) {
+      const isPng = !!data['image/png'];
+      const b64 = joinedNotebookText(isPng ? data['image/png'] : data['image/jpeg']);
+      pendingImages.push({ mimeType: isPng ? 'image/png' : 'image/jpeg', b64 });
+      block += `\n# Output: [image output — cell ${cellIndex}]`;
+    }
+  }
+  return { block, pendingImages };
+}
+
+// Keeps text blocks until `maxOutputBytes` of text, cutting the one that
+// crosses it, then marks the cut. Image blocks pass through uncounted.
+function capNotebookText(blocks, maxOutputBytes) {
+  let running = 0;
+  const capped = [];
+  let truncated = false;
+  for (const b of blocks) {
+    if (b.type !== 'text') {
+      capped.push(b);
+      continue;
+    }
+    if (running >= maxOutputBytes) {
+      truncated = true;
+      continue;
+    }
+    if (running + b.text.length > maxOutputBytes) {
+      capped.push({ type: 'text', text: b.text.slice(0, maxOutputBytes - running) });
+      running = maxOutputBytes;
+      truncated = true;
+    } else {
+      capped.push(b);
+      running += b.text.length;
+    }
+  }
+  if (truncated) {
+    capped.push({
+      type: 'text',
+      text: `\n\n... [notebook output truncated at ${Math.round(maxOutputBytes / 1024)} KB]`,
+    });
+  }
+  return capped;
+}
+
 export async function extractIpynbText(
   fullPath,
   { maxOutputBytes = DEFAULT_READ_MAX_OUTPUT_BYTES, hasRangeArgs = false, textOnly = false } = {}
@@ -176,34 +236,10 @@ export async function extractIpynbText(
     let cellIndex = -1;
     for (const cell of cells) {
       cellIndex += 1;
-      const src = Array.isArray(cell.source) ? cell.source.join('') : cell.source || '';
       if (cell.cell_type === 'markdown') {
-        pushText(src);
+        pushText(joinedNotebookText(cell.source) || '');
       } else if (cell.cell_type === 'code') {
-        let block = src;
-        const outputs = Array.isArray(cell.outputs) ? cell.outputs : [];
-        // Collect image outputs to emit AFTER this cell's code block.
-        const pendingImages = [];
-        for (const out of outputs) {
-          const data = out.data || {};
-          if (data['text/plain'] || out.text) {
-            const joinedText = (value) => (Array.isArray(value) ? value.join('') : value);
-            const rawTxt = joinedText(data['text/plain'] || out.text);
-            // A single huge output is replaced
-            // with a jq hint rather than dumped inline.
-            if (typeof rawTxt === 'string' && rawTxt.length > IPYNB_OUTPUT_MAX_CHARS) {
-              block += `\n# Output: [large output omitted — ${rawTxt.length} chars; inspect with: cat "${fullPath}" | jq '.cells[${cellIndex}].outputs']`;
-            } else {
-              block += `\n# Output:\n${rawTxt}`;
-            }
-          } else if (data['image/png'] || data['image/jpeg']) {
-            const isPng = !!data['image/png'];
-            const b64 = isPng ? data['image/png'] : data['image/jpeg'];
-            const b64str = Array.isArray(b64) ? b64.join('') : b64;
-            pendingImages.push({ mimeType: isPng ? 'image/png' : 'image/jpeg', b64: b64str });
-            block += `\n# Output: [image output — cell ${cellIndex}]`;
-          }
-        }
+        const { block, pendingImages } = renderIpynbCodeCell(cell, cellIndex, fullPath);
         pushText(`\`\`\`python\n${block}\n\`\`\``);
         // Embed each image output as a real image block (resized via the
         // shared helper). On fallback (sharp absent / decode failure) the
@@ -237,33 +273,7 @@ export async function extractIpynbText(
     // Output-byte cap on the combined TEXT. Image blocks are not counted
     // (they're already size-bounded by the resize helper).
     if (textLen > maxOutputBytes) {
-      // Trim trailing text blocks until under the cap, then mark the cut.
-      let running = 0;
-      const capped = [];
-      let truncated = false;
-      for (const b of blocks) {
-        if (b.type !== 'text') {
-          capped.push(b);
-          continue;
-        }
-        if (running >= maxOutputBytes) {
-          truncated = true;
-          continue;
-        }
-        if (running + b.text.length > maxOutputBytes) {
-          capped.push({ type: 'text', text: b.text.slice(0, maxOutputBytes - running) });
-          running = maxOutputBytes;
-          truncated = true;
-        } else {
-          capped.push(b);
-          running += b.text.length;
-        }
-      }
-      if (truncated)
-        capped.push({
-          type: 'text',
-          text: `\n\n... [notebook output truncated at ${Math.round(maxOutputBytes / 1024)} KB]`,
-        });
+      const capped = capNotebookText(blocks, maxOutputBytes);
       blocks.length = 0;
       blocks.push(...capped);
     }