decorated-pi 0.5.4 → 0.6.0

package/{extensions/patch.ts → tools/patch/core.ts}

@@ -545,6 +545,11 @@ export async function computePatchPreview(
     const lineOffsets = buildLineOffsets(rawContent);
     const totalLines = lineOffsets.length - 1;
     let content = normalizeLineEndings(rawContent);
+    // Snapshot the original (pre-edit) content for diff display. The
+    // `content` variable below is mutated in-place as edits are applied,
+    // but the TUI diff should show the ORIGINAL lines (not the post-edit
+    // content) so leading whitespace is preserved correctly.
+    const originalContent = content;
     const allReplacements: ReplacementInfo[] = [];
     const neededRanges: LineRange[] = [];
     let cumulativeOffset = 0;
@@ -622,12 +627,13 @@ export async function computePatchPreview(
         cumulativeOffset += newNorm.length - oldNorm.length;
       }
 
-      // Merge needed ranges and extract only those lines
+      // Merge needed ranges and extract lines from the ORIGINAL content
+      // (not the mutated `content`), so the diff shows pre-edit lines.
       const mergedRanges = mergeRanges(neededRanges);
-      const currentLineOffsets = buildLineOffsets(content);
+      const originalLineOffsets = buildLineOffsets(originalContent);
       const neededLines: Map<number, string> = new Map();
       for (const range of mergedRanges) {
-        const lines = extractLineRange(content, currentLineOffsets, range.startLine, range.endLine);
+        const lines = extractLineRange(originalContent, originalLineOffsets, range.startLine, range.endLine);
         for (let i = 0; i < lines.length; i++) {
           neededLines.set(range.startLine + i, lines[i]);
         }
@@ -761,6 +767,160 @@ function formatChunkMetadataLines(chunk: ReplacementChunk): string[] {
   return lines;
 }
 
+type RenderOp =
+  | { type: "context"; line: number; text: string; /** New-file line number (differs from `line` when there are added/removed lines before it). Optional for backward compat. */ newLine?: number }
+  | { type: "removed"; line: number; text: string; /** Optional for type compatibility — removed lines always keep their original `line` and never receive a `newLine` assignment. */ newLine?: number }
+  | { type: "added"; line: number; text: string; /** New-file line number (differs from `line` when there are added/removed lines before it). Optional for backward compat. */ newLine?: number };
+
+interface RenderableReplacement {
+  operations: RenderOp[];
+  /** Line number of the first removed/added operation (BEFORE trimming).
+   *  Used to limit how far "context before" extends. */
+  firstChangeLine: number;
+  /** Line number of the last removed/added operation (BEFORE trimming). */
+  lastChangeLine: number;
+}
+
+/** Compute a minimal line-level diff between old and new lines using LCS.
+ *  Common lines become context, while only truly different lines become
+ *  removed/added. The resulting context is trimmed to `contextLines` lines
+ *  before the first and after the last non-context operation so the TUI hunk
+ *  doesn't grow with the size of the LLM's old_str. */
+function splitReplacementForRender(
+  rep: ReplacementInfo,
+  contextLines: number,
+): RenderableReplacement {
+  const m = rep.oldLines.length;
+  const n = rep.newLines.length;
+
+  // DP table: dp[i][j] = LCS length of oldLines[0..i) and newLines[0..j)
+  const dp: number[][] = Array.from({ length: m + 1 }, () => new Array<number>(n + 1).fill(0));
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      if (rep.oldLines[i - 1] === rep.newLines[j - 1]) {
+        dp[i]![j] = dp[i - 1]![j - 1]! + 1;
+      } else {
+        dp[i]![j] = Math.max(dp[i - 1]![j]!, dp[i]![j - 1]!);
+      }
+    }
+  }
+
+  // Backtrack to produce operations in reverse order.
+  const stack: RenderOp[] = [];
+  let i = m;
+  let j = n;
+  while (i > 0 && j > 0) {
+    if (rep.oldLines[i - 1] === rep.newLines[j - 1]) {
+      stack.push({ type: "context", line: rep.oldStartLine + i - 1, text: rep.oldLines[i - 1]! });
+      i--;
+      j--;
+    } else if (dp[i - 1]![j]! > dp[i]![j - 1]!) {
+      stack.push({ type: "removed", line: rep.oldStartLine + i - 1, text: rep.oldLines[i - 1]! });
+      i--;
+    } else {
+      stack.push({ type: "added", line: rep.oldStartLine + j - 1, text: rep.newLines[j - 1]! });
+      j--;
+    }
+  }
+  while (i > 0) {
+    stack.push({ type: "removed", line: rep.oldStartLine + i - 1, text: rep.oldLines[i - 1]! });
+    i--;
+  }
+  while (j > 0) {
+    stack.push({ type: "added", line: rep.oldStartLine + j - 1, text: rep.newLines[j - 1]! });
+    j--;
+  }
+
+  // Reverse to get the final order.
+  const operations: RenderOp[] = [];
+  while (stack.length > 0) operations.push(stack.pop()!);
+
+  // Find first and last non-context operations (in the original order).
+  let firstChangeLine = rep.oldStartLine;
+  let lastChangeLine = rep.oldStartLine;
+  for (const op of operations) {
+    if (op.type !== "context") {
+      firstChangeLine = op.line;
+      break;
+    }
+  }
+  for (let k = operations.length - 1; k >= 0; k--) {
+    if (operations[k]!.type !== "context") {
+      lastChangeLine = operations[k]!.line;
+      break;
+    }
+  }
+
+  // Trim context operations that sit far from any non-context change.
+  const firstNonContextIdx = operations.findIndex(op => op.type !== "context");
+  if (firstNonContextIdx === -1) {
+    return { operations: [], firstChangeLine, lastChangeLine };
+  }
+  let lastNonContextIdx = operations.length - 1;
+  for (let k = operations.length - 1; k >= 0; k--) {
+    if (operations[k]!.type !== "context") { lastNonContextIdx = k; break; }
+  }
+  const start = Math.max(0, firstNonContextIdx - contextLines);
+  const end = Math.min(operations.length - 1, lastNonContextIdx + contextLines);
+  const trimmed = operations.slice(start, end + 1);
+
+  // Second pass: compute the new-file line number for each operation.
+  // Standard unified-diff convention: context/removed use ORIGINAL line
+  // numbers; added use NEW-file line numbers (so they don't collide with
+  // the line numbers of unchanged lines that follow in the file).
+  let newLineCounter = rep.oldStartLine;
+  for (const op of trimmed) {
+    if (op.type === "context" || op.type === "added") {
+      op.newLine = newLineCounter;
+      newLineCounter++;
+    }
+    // removed: no new-file line; skip increment
+  }
+
+  return { operations: trimmed, firstChangeLine, lastChangeLine };
+}
+
+/** Compute the actual hunk range for a chunk by looking at the rendered
+ *  context (before / after) and the LCS-trimmed operations. Returns
+ *  [startLine, endLine] (1-based, inclusive). */
+function computeRenderedRange(
+  chunk: ReplacementChunk,
+  repViews: Array<{ rep: ReplacementInfo; view: RenderableReplacement; beforeStart: number; afterEnd: number }>,
+  totalLines: number,
+  contextLines: number,
+): { startLine: number; endLine: number } {
+  let renderedStart = Infinity;
+  let renderedEnd = -Infinity;
+  for (const { view, beforeStart, afterEnd } of repViews) {
+    // Skip reps with no operations (no changes to render). The original
+    // check also required beforeStart >= oldStartLine && afterEnd <= oldEndLine,
+    // but that fails when oldStartLine > CONTEXT_LINES (beforeStart would be
+    // oldStartLine - CONTEXT_LINES < oldStartLine), causing view.operations[0]
+    // to be undefined and throw "Cannot read properties of undefined".
+    if (view.operations.length === 0) continue;
+    // Use the new-file line number of the first/last operations so the
+    // hunk header matches the line numbers used in the diff content.
+    const opStart = view.operations[0]!.newLine ?? view.operations[0]!.line;
+    const opEnd = view.operations[view.operations.length - 1]!.newLine ?? view.operations[view.operations.length - 1]!.line;
+    // beforeStart / afterEnd are in original line numbers; convert via
+    // the offset of this rep's operations. For a clean approximation
+    // (and to avoid running into line-number collisions), use the rep's
+    // own oldStartLine/oldEndLine as the anchor for the conversion.
+    const origStart = view.operations[0]!.line;
+    const origEnd = view.operations[view.operations.length - 1]!.line;
+    const beforeNew = opStart - (origStart - beforeStart);
+    const afterNew = opEnd + (afterEnd - origEnd);
+    const s = Math.min(beforeNew, opStart);
+    const e = Math.max(afterNew, opEnd);
+    if (s < renderedStart) renderedStart = s;
+    if (e > renderedEnd) renderedEnd = e;
+  }
+  if (renderedStart === Infinity) {
+    return { startLine: chunk.startLine, endLine: chunk.endLine };
+  }
+  return { startLine: renderedStart, endLine: Math.min(totalLines, renderedEnd) };
+}
+
 /**
  * Generate diff as visual chunks merged by overlapping/adjacent context windows.
  * This keeps spacing stable when multiple nearby edits would otherwise create
@@ -768,57 +928,104 @@ function formatChunkMetadataLines(chunk: ReplacementChunk): string[] {
  */
 function generateReplacementDiff(filePath: string, reps: ReplacementInfo[], originalLines: string[]): string {
   const parts: string[] = [];
-  parts.push(`--- ${filePath}`);
-  parts.push(`+++ ${filePath}`);
 
   if (reps.length === 0) {
-    parts.push("");
-    return parts.join("\n");
+    return "";
   }
 
   const maxLineNum = Math.max(originalLines.length, ...reps.map(r => r.oldEndLine));
   const numWidth = String(maxLineNum).length;
   const CONTEXT = 3;
   const chunks = buildReplacementChunks(reps, originalLines.length, CONTEXT);
+  let firstHunk = true;
 
   for (let c = 0; c < chunks.length; c++) {
     const chunk = chunks[c]!;
-    if (c > 0) parts.push("");
-    parts.push(formatChunkHeader(chunk));
-    parts.push(...formatChunkMetadataLines(chunk));
 
-    let cursor = chunk.startLine;
+    // Pre-compute the rendered range for this chunk so the hunk header
+    // reflects what we actually emit (not the full chunk window).
+    const repViews = chunk.reps.map(rep => {
+      const v = splitReplacementForRender(rep, CONTEXT);
+      const beforeStart = Math.max(chunk.startLine, v.firstChangeLine - CONTEXT);
+      const afterEnd = Math.min(chunk.endLine, v.lastChangeLine + CONTEXT);
+      return { rep, view: v, beforeStart, afterEnd };
+    });
+
+    // Skip hunk entirely if every rep produced no effective changes
+    // (e.g., LLM sent old_str === new_str). Rendering context-only hunks
+    // is misleading — there is nothing to show.
+    if (repViews.every(r => r.view.operations.length === 0)) continue;
 
-    for (const rep of chunk.reps) {
-      // Context before this replacement (only once per original line)
-      for (let i = cursor; i < rep.oldStartLine; i++) {
+    const { startLine: renderedStart, endLine: renderedEnd } = computeRenderedRange(
+      chunk, repViews, originalLines.length, CONTEXT,
+    );
+    const syntheticChunk = { ...chunk, startLine: renderedStart, endLine: renderedEnd };
+    parts.push(formatChunkHeader(syntheticChunk));
+    parts.push(...formatChunkMetadataLines(syntheticChunk));
+
+    let lastOutputLine = 0;
+    for (const { rep, view, beforeStart } of repViews) {
+      // Skip no-op reps (old_str === new_str): no changes to show, and
+      // emitting their context lines would mislead the reader.
+      if (view.operations.length === 0) continue;
+
+      // Context before this rep. Start from `lastOutputLine + 1` to
+      // avoid duplicating context lines already emitted by the previous
+      // rep's before-context window or operations.
+      const ctxStart = Math.max(lastOutputLine + 1, beforeStart);
+      for (let i = ctxStart; i < rep.oldStartLine; i++) {
         const num = String(i).padStart(numWidth, " ");
         parts.push(` ${num} ${originalLines[i - 1]}`);
+        lastOutputLine = i;
       }
 
-      // Removed lines (from original)
-      for (let i = 0; i < rep.oldLines.length; i++) {
-        const num = String(rep.oldStartLine + i).padStart(numWidth, " ");
-        parts.push(`-${num} ${rep.oldLines[i]}`);
-      }
-
-      // Added lines
-      for (let i = 0; i < rep.newLines.length; i++) {
-        const num = String(rep.oldStartLine + i).padStart(numWidth, " ");
-        parts.push(`+${num} ${rep.newLines[i]}`);
+      for (const op of view.operations) {
+        // Use the new-file line number for context and added lines so
+        // they don't conflict with the original-file line numbers used by
+        // the trailing-context loop. Removed lines keep the original.
+        const newNum = op.newLine !== undefined
+          ? String(op.newLine).padStart(numWidth, " ")
+          : String(op.line).padStart(numWidth, " ");
+        const origNum = String(op.line).padStart(numWidth, " ");
+        if (op.type === "context") {
+          parts.push(` ${newNum} ${op.text}`);
+          lastOutputLine = op.line;
+        }
+        // For removed lines, use the file's actual content (not the LLM's
+        // old_str) so leading whitespace is preserved even if the LLM
+        // stripped it from the old_str.
+        else if (op.type === "removed") {
+          const fileLine = originalLines[op.line - 1] ?? op.text;
+          parts.push(`-${origNum} ${fileLine}`);
+          lastOutputLine = op.line;
+        }
+        else {
+          parts.push(`+${newNum} ${op.text}`);
+        }
       }
-
-      cursor = rep.oldEndLine + 1;
     }
 
-    // Trailing context for the merged chunk
-    for (let i = cursor; i <= chunk.endLine; i++) {
-      const num = String(i).padStart(numWidth, " ");
-      parts.push(` ${num} ${originalLines[i - 1]}`);
+    // Trailing context after the LAST NON-NOOP rep. Use new-file line
+    // numbers (offset from the last operation's newLine) so trailing
+    // context doesn't collide with added lines.
+    let lastRealEntry: typeof repViews[number] | undefined;
+    for (const rv of repViews) {
+      if (rv.view.operations.length > 0) lastRealEntry = rv;
+    }
+    if (lastRealEntry) {
+      const lastOp = lastRealEntry.view.operations[lastRealEntry.view.operations.length - 1];
+      const lastNewLine = lastOp?.newLine ?? lastOp?.line ?? lastRealEntry.rep.oldEndLine;
+      const lastOrigLine = lastOp?.line ?? lastRealEntry.rep.oldEndLine;
+      // Start from lastOutputLine + 1 to avoid duplicating context
+      // already emitted.
+      const ctxStart = Math.max(lastOutputLine + 1, lastRealEntry.rep.oldEndLine + 1);
+      for (let i = ctxStart; i <= lastRealEntry.afterEnd; i++) {
+        const num = String(lastNewLine + (i - lastOrigLine)).padStart(numWidth, " ");
+        parts.push(` ${num} ${originalLines[i - 1]}`);
+      }
     }
   }
 
-  if (parts[parts.length - 1] !== "") parts.push("");
   return parts.join("\n");
 }
 
@@ -826,18 +1033,12 @@ function generateReplacementDiff(filePath: string, reps: ReplacementInfo[], orig
 // Formatting
 // ═══════════════════════════════════════════════════════════════════════════
 
-export function formatPatchResult(result: PatchResult): string {
-  const lines: string[] = [];
-  for (const p of result.created) lines.push(`A ${p}`);
-  for (const p of result.modified) lines.push(`M ${p}`);
-  let output = lines.length > 0
-    ? "Updated the following files:\n" + lines.join("\n")
-    : "No files were modified.";
-  if (result.warnings.length > 0) {
-    output += "\n\n" + result.warnings.join("\n");
-  }
-  return output;
-}
+// Note: a previous `formatPatchResult` helper lived here. It was removed
+// when the tool's execute() was simplified to return a constant "Success"
+// string (the LLM already knows what it asked to change, so the summary
+// was redundant and cost prompt-cache stability). If callers need to
+// surface the file list to a non-LLM UI, they can format `result.modified`
+// and `result.created` themselves — they are plain `string[]`.
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Helpers
@@ -1028,8 +1229,7 @@ function generateLocalDiff(
   if (reps.length === 0) return "";
 
   const parts: string[] = [];
-  parts.push(`--- ${filePath}`);
-  parts.push(`+++ ${filePath}`);
+  let firstHunk = true;
 
   // Calculate dynamic width based on max line number
   const maxLineNum = Math.max(totalLines, ...reps.map(r => r.oldEndLine));
@@ -1038,36 +1238,107 @@ function generateLocalDiff(
   // Merge replacement chunks
   const chunks = buildReplacementChunks(reps, totalLines, CONTEXT_LINES);
   for (let c = 0; c < chunks.length; c++) {
-    if (c > 0) parts.push("");
     const chunk = chunks[c]!;
-    parts.push(formatChunkHeader(chunk));
-    parts.push(...formatChunkMetadataLines(chunk));
+
+    // Pre-compute the rendered range so the hunk header reflects what we
+    // actually emit (not the full chunk window).
+    const repViews = chunk.reps.map(rep => {
+      const view = splitReplacementForRender(rep, CONTEXT_LINES);
+      const beforeStart = Math.max(chunk.startLine, view.firstChangeLine - CONTEXT_LINES);
+      const afterEnd = Math.min(chunk.endLine, view.lastChangeLine + CONTEXT_LINES);
+      return { rep, view, beforeStart, afterEnd };
+    });
+
+    // Skip hunk entirely if every rep produced no effective changes
+    // (e.g., LLM sent old_str === new_str). Rendering context-only hunks
+    // is misleading — there is nothing to show.
+    if (repViews.every(r => r.view.operations.length === 0)) continue;
+
+    if (firstHunk) {
+      parts.push(`--- ${filePath}`);
+      parts.push(`+++ ${filePath}`);
+      firstHunk = false;
+    } else {
+      parts.push("");
+    }
+
+    const { startLine: renderedStart, endLine: renderedEnd } = computeRenderedRange(
+      chunk, repViews, totalLines, CONTEXT_LINES,
+    );
+    const syntheticChunk = { ...chunk, startLine: renderedStart, endLine: renderedEnd };
+    parts.push(formatChunkHeader(syntheticChunk));
+    parts.push(...formatChunkMetadataLines(syntheticChunk));
 
     // Output context + removed + added
-    let cursor = chunk.startLine;
-    for (const rep of chunk.reps) {
-      // Context before this replacement
-      for (let i = cursor; i < rep.oldStartLine; i++) {
+    let lastOutputLine = 0;
+    for (const { rep, view, beforeStart } of repViews) {
+      // Skip no-op reps (old_str === new_str): no changes to show, and
+      // emitting their context lines would mislead the reader.
+      if (view.operations.length === 0) continue;
+
+      // Context before this rep. Start from `lastOutputLine + 1` (not
+      // `beforeStart`) to avoid duplicating context lines that were
+      // already emitted by the previous rep's before-context window
+      // or operations (common when multiple reps are close together).
+      const ctxStart = Math.max(lastOutputLine + 1, beforeStart);
+      for (let i = ctxStart; i < rep.oldStartLine; i++) {
         const lineText = neededLines.get(i);
         if (lineText !== undefined) {
           parts.push(` ${String(i).padStart(numWidth, " ")} ${lineText}`);
+          lastOutputLine = i;
         }
       }
-      // Removed lines
-      for (let i = 0; i < rep.oldLines.length; i++) {
-        parts.push(`-${String(rep.oldStartLine + i).padStart(numWidth, " ")} ${rep.oldLines[i]}`);
-      }
-      // Added lines
-      for (let i = 0; i < rep.newLines.length; i++) {
-        parts.push(`+${String(rep.oldStartLine + i).padStart(numWidth, " ")} ${rep.newLines[i]}`);
+
+      for (const op of view.operations) {
+        // Use the new-file line number for context and added lines so
+        // they don't conflict with the original-file line numbers used by
+        // the trailing-context loop. Removed lines keep the original.
+        const newNum = op.newLine !== undefined
+          ? String(op.newLine).padStart(numWidth, " ")
+          : String(op.line).padStart(numWidth, " ");
+        const origNum = String(op.line).padStart(numWidth, " ");
+        if (op.type === "context") {
+          parts.push(` ${newNum} ${op.text}`);
+          lastOutputLine = op.line;
+        }
+        // For removed lines, use the file's actual content (not the LLM's
+        // old_str) so leading whitespace is preserved even if the LLM
+        // stripped it from the old_str.
+        else if (op.type === "removed") {
+          const fileLine = neededLines.get(op.line) ?? op.text;
+          parts.push(`-${origNum} ${fileLine}`);
+          lastOutputLine = op.line;
+        }
+        else {
+          parts.push(`+${newNum} ${op.text}`);
+          // Don't bump lastOutputLine for added (no original line to consume)
+        }
       }
-      cursor = rep.oldEndLine + 1;
     }
-    // Trailing context
-    for (let i = cursor; i <= chunk.endLine; i++) {
-      const lineText = neededLines.get(i);
-      if (lineText !== undefined) {
-        parts.push(` ${String(i).padStart(numWidth, " ")} ${lineText}`);
+
+    // Trailing context after the LAST NON-NOOP rep (a no-op's trailing
+    // context would be based on the no-op's line range, not the real
+    // change's end, which would skip past the real change's after-context).
+    // Use new-file line numbers (offset from the last operation's newLine)
+    // so trailing context doesn't collide with added lines.
+    let lastRealEntry: typeof repViews[number] | undefined;
+    for (const rv of repViews) {
+      if (rv.view.operations.length > 0) lastRealEntry = rv;
+    }
+    if (lastRealEntry) {
+      const lastOp = lastRealEntry.view.operations[lastRealEntry.view.operations.length - 1];
+      const lastNewLine = lastOp?.newLine ?? lastOp?.line ?? lastRealEntry.rep.oldEndLine;
+      const lastOrigLine = lastOp?.line ?? lastRealEntry.rep.oldEndLine;
+      // Start from lastOutputLine + 1 to avoid duplicating context
+      // already emitted (e.g., when the rep's operations ended with a
+      // context op and then we'd otherwise re-emit the same line).
+      const ctxStart = Math.max(lastOutputLine + 1, lastRealEntry.rep.oldEndLine + 1);
+      for (let i = ctxStart; i <= lastRealEntry.afterEnd; i++) {
+        const lineText = neededLines.get(i);
+        if (lineText !== undefined) {
+          const newLine = lastNewLine + (i - lastOrigLine);
+          parts.push(` ${String(newLine).padStart(numWidth, " ")} ${lineText}`);
+        }
       }
     }
   }