dsh-hashline-edit 0.1.0 → 0.2.0

package/src/apply-patch/render.ts

@@ -0,0 +1,137 @@
+/**
+ * apply_patch v4 — renderer.
+ *
+ * One renderer owns both surfaces:
+ *
+ * - success: file-level summary lines first (`A`/`M`/`R`/`D`), then the
+ *   changed-line anchor rows (`HASH│content`) per file, so a second call needs
+ *   no `read`;
+ * - rejection: every problem as `- patch line N ([E_*], path): message`,
+ *   followed by each problem file's current rows.
+ *
+ * @module dsh-hashline-edit/apply-patch/render
+ */
+import type {
+  ApplyPatchFailure,
+  ApplyPatchResult,
+  ApplyPatchSuccess,
+  ApplyPatchToolResult,
+  AppliedFileSummary,
+  PatchMetrics,
+  PatchProblem,
+  ServedFileBlock,
+} from "./types.js";
+
+const ZERO_METRICS: PatchMetrics = {
+  files: 0,
+  hunks: 0,
+  addedLines: 0,
+  removedLines: 0,
+};
+
+/**
+ * Render one apply_patch outcome into the model-facing tool envelope.
+ * @param result - the committed success or the collected rejection.
+ * @returns `{ content, details }` ready for the dsh tool registry.
+ */
+export function renderApplyPatchResult(result: ApplyPatchResult): ApplyPatchToolResult {
+  return result.ok ? renderSuccess(result) : renderFailure(result);
+}
+
+/**
+ * Render a successful outcome.
+ * @param success - committed file facts plus new anchor rows.
+ * @returns the model-facing envelope.
+ */
+export function renderSuccess(success: ApplyPatchSuccess): ApplyPatchToolResult {
+  const summary = renderFileSummary(success.files);
+  const servedText = renderServedBlocks(success.served);
+  const text = servedText === "" ? summary : `${summary}\n\n${servedText}`;
+  return {
+    content: [{ type: "text", text }],
+    details: {
+      summary,
+      diff: success.diff,
+      files: success.files,
+      servedByPath: success.served,
+      warnings: success.warnings,
+      metrics: success.metrics,
+    },
+  };
+}
+
+/**
+ * Render a rejected outcome: all problems first, then the served rows.
+ * @param failure - the collected problems and current rows.
+ * @returns the model-facing envelope (as an `isError` tool result at the host seam).
+ */
+export function renderFailure(failure: ApplyPatchFailure): ApplyPatchToolResult {
+  const count = failure.problems.length;
+  const headline =
+    failure.changedNothing && failure.recovery === undefined
+      ? count === 0
+        ? failure.message
+        : `Error: nothing changed (${count} problem${count === 1 ? "" : "s"})`
+      : failure.message;
+  const problemLines = failure.problems.map((problem) => formatPatchProblem(problem));
+  const problemText = problemLines.join("\n");
+  const servedText = renderServedBlocks(failure.served);
+  const head = [headline, problemText].filter((section) => section !== "").join("\n");
+  const text = servedText === "" ? head : `${head}\n\n${servedText}`;
+  return {
+    content: [{ type: "text", text }],
+    details: {
+      summary:
+        failure.changedNothing && failure.recovery === undefined
+          ? count === 0
+            ? failure.message
+            : `Nothing changed (${count} problem${count === 1 ? "" : "s"})`
+          : failure.message,
+      diff: "",
+      files: [],
+      servedByPath: failure.served,
+      warnings: [],
+      metrics: ZERO_METRICS,
+    },
+  };
+}
+
+/**
+ * Render the file-level summary block: `Updated N files:` then one status line
+ * per file (`R src/old.ts -> src/new.ts` for a rename).
+ * @param files - the committed file summaries.
+ * @returns the summary text.
+ */
+export function renderFileSummary(files: readonly AppliedFileSummary[]): string {
+  const count = files.length;
+  const header = `Updated ${count} file${count === 1 ? "" : "s"}:`;
+  const lines = files.map((file) => {
+    if (file.status === "R") {
+      return `R ${file.fromPath ?? ""} -> ${file.path}`;
+    }
+    return `${file.status} ${file.path}`;
+  });
+  return [header, ...lines].join("\n");
+}
+
+/**
+ * Render the new-anchor blocks for every changed file.
+ * @param blocks - per-file served rows.
+ * @returns one `<path>\nHASH│content` section per block.
+ */
+export function renderServedBlocks(blocks: readonly ServedFileBlock[]): string {
+  return blocks
+    .filter((block) => block.text !== "")
+    .map((block) => `${block.path}\n${block.text}`)
+    .join("\n\n");
+}
+
+/**
+ * Render one problem line: `- patch line N ([E_*], path): message`.
+ * @param problem - one collected problem.
+ * @returns the single-line rendering, without a trailing newline.
+ */
+export function formatPatchProblem(problem: PatchProblem): string {
+  const location = problem.path === undefined ? "" : `, ${problem.path}`;
+  return `- patch line ${problem.patchLine} ([${problem.code}]${location}): ${problem.message}`;
+}

package/src/apply-patch/resolve.ts

@@ -0,0 +1,470 @@
+/**
+ * apply_patch v4 — resolution layer.
+ *
+ * Two addressing families meet here:
+ *
+ * - **fragment mode** is content matching against the pre-call baseline. The
+ *   `oldLines` sequence (' ' and '-' lines) must match exactly one place in the
+ *   hunk's window; `@@ <context>` must itself match exactly one line and moves
+ *   the window start after it. Zero or multiple hits reject with candidate rows.
+ * - **identity mode** is served-lease addressing. Both anchors must belong to
+ *   the `(session, file, anchor)` served set; a missing, retired or foreign
+ *   anchor rejects with the file's current rows served back.
+ *
+ * The layer is pure over `FileBaseline` + served anchors: no I/O, no store
+ * access. `plan.ts` supplies the baselines and the lease source.
+ *
+ * @module dsh-hashline-edit/apply-patch/resolve
+ */
+import {
+  resolveLineIdentity,
+  uniqueServedPosition,
+  type LeaseSpanSource,
+} from "../hashline/resolve.js";
+import { splitLines } from "../utils.js";
+import type {
+  Anchor,
+  FileBaseline,
+  FragmentHunk,
+  IdentityHunk,
+  LineRange,
+  PatchCandidate,
+  PatchPath,
+  PatchProblem,
+  PlannedMutation,
+  PlannedReferenceUse,
+  ReferenceHunk,
+} from "./types.js";
+
+/** A file's served anchors, parallel to its baseline lines; `null` = never served. */
+export type ServedAnchors = readonly (string | null)[];
+
+/** The inputs one hunk resolution reads. */
+export interface ResolveContext {
+  readonly baseline: FileBaseline;
+  readonly served: ServedAnchors;
+  /**
+   * Read-only lease identity source for identity mode. When present it is
+   * authoritative (MVCC lease identity, including rebasing); the `served`
+   * mirror is only the fallback for tests/callers with no store lease view.
+   */
+  readonly identity?: LeaseSpanSource;
+  /**
+   * Session-wide anchor homes — other files that served this anchor. Used only
+   * to diagnose a foreign anchor; a cross-file anchor is refused either way.
+   */
+  readonly homesOf?: (anchor: Anchor) => readonly PatchPath[];
+}
+
+/** A successful fragment match in baseline coordinates. */
+export interface FragmentMatch {
+  /** Inclusive range covering the hunk's oldLines (' ' + '-'); zero-width when oldLines is empty. */
+  readonly range: LineRange;
+  /** 1-based line where the search window began (after `@@ <context>`, else 1). */
+  readonly windowStart: number;
+}
+
+/** Fragment match failure: no occurrence or more than one, with candidate rows. */
+export type FragmentMatchResult =
+  | { readonly ok: true; readonly match: FragmentMatch }
+  | {
+      readonly ok: false;
+      readonly reason: "no-match" | "ambiguous";
+      readonly candidates: readonly PatchCandidate[];
+    };
+
+/** Identity resolution outcome. */
+export type IdentityResolveResult =
+  | { readonly ok: true; readonly range: LineRange }
+  | { readonly ok: false; readonly problems: readonly PatchProblem[] };
+
+/** Reference resolution outcome. */
+export type ReferenceResolveResult =
+  | {
+      readonly ok: true;
+      readonly reference: PlannedReferenceUse;
+      /** The destination replacement this reference materializes. */
+      readonly mutation: PlannedMutation;
+    }
+  | { readonly ok: false; readonly problems: readonly PatchProblem[] };
+
+/** The baseline's lines; an empty file is zero lines, never one empty line. */
+export function baselineLinesOf(baseline: FileBaseline): string[] {
+  return baseline.text === "" ? [] : splitLines(baseline.text);
+}
+
+function oldLinesOf(hunk: FragmentHunk): string[] {
+  return hunk.lines.filter((line) => line.op !== "add").map((line) => line.text);
+}
+
+function candidateRows(
+  baseline: FileBaseline,
+  fileLines: readonly string[],
+  matchIndex: number,
+  oldLines: readonly string[],
+): PatchCandidate[] {
+  const rows: PatchCandidate[] = [];
+  for (let offset = 0; offset < oldLines.length; offset++) {
+    const line = matchIndex + offset + 1;
+    rows.push({
+      line,
+      hash: baseline.hashes[matchIndex + offset] ?? "",
+      text: fileLines[matchIndex + offset] ?? oldLines[offset] ?? "",
+    });
+  }
+  return rows;
+}
+
+function uniqueContextRows(
+  baseline: FileBaseline,
+  fileLines: readonly string[],
+  indexes: readonly number[],
+  text: string,
+): PatchCandidate[] {
+  return indexes.map((index) => ({
+    line: index + 1,
+    hash: baseline.hashes[index] ?? "",
+    text: fileLines[index] ?? text,
+  }));
+}
+
+/**
+ * Match one fragment hunk against its baseline.
+ *
+ * Byte-exact: no whitespace, Unicode or newline normalization. The window is
+ * `[windowStart, end]` and every subsequent hunk's window begins after the
+ * previous hunk's end (the planner enforces the monotonic cursor).
+ *
+ * @param hunk - the parsed fragment hunk.
+ * @param context - baseline plus served anchors (served is unused here; kept for one call shape).
+ * @param windowStart - 1-based line the search starts at; defaults to 1.
+ * @returns the unique match or the rejection with candidates.
+ */
+export function matchFragmentHunk(
+  hunk: FragmentHunk,
+  context: ResolveContext,
+  windowStart?: number,
+): FragmentMatchResult {
+  const baseline = context.baseline;
+  const fileLines = baselineLinesOf(baseline);
+  const requestedStart = windowStart ?? 1;
+  let startLine = Math.max(1, Math.min(requestedStart, fileLines.length + 1));
+
+  if (hunk.address.kind === "context") {
+    const contextText = hunk.address.text;
+    const hits: number[] = [];
+    for (let index = startLine - 1; index < fileLines.length; index++) {
+      if (fileLines[index] === contextText) hits.push(index);
+    }
+    if (hits.length === 0) {
+      return { ok: false, reason: "no-match", candidates: [] };
+    }
+    if (hits.length > 1) {
+      return {
+        ok: false,
+        reason: "ambiguous",
+        candidates: uniqueContextRows(baseline, fileLines, hits, contextText),
+      };
+    }
+    startLine = hits[0]! + 2;
+  }
+
+  const oldLines = oldLinesOf(hunk);
+  if (oldLines.length === 0) {
+    // WHY: `*** End of File` with no removable lines means append at the real end of the file;
+    // WHY: the plain window start would insert at the beginning and silently change the patch.
+    const point = hunk.endOfFile !== undefined ? fileLines.length : startLine - 1;
+    return {
+      ok: true,
+      match: {
+        range: { startLine: point + 1, endLine: point },
+        windowStart: startLine,
+      },
+    };
+  }
+
+  const matches: number[] = [];
+  const lastStart = fileLines.length - oldLines.length;
+  for (let index = startLine - 1; index <= lastStart; index++) {
+    let matched = true;
+    for (let offset = 0; offset < oldLines.length; offset++) {
+      if (fileLines[index + offset] !== oldLines[offset]) {
+        matched = false;
+        break;
+      }
+    }
+    if (matched) matches.push(index);
+  }
+
+  const eofPinned = hunk.endOfFile !== undefined;
+  const eligible = eofPinned
+    ? matches.filter((index) => index + oldLines.length === fileLines.length)
+    : matches;
+
+  if (eligible.length === 0) {
+    const candidates =
+      eofPinned && matches.length > 0
+        ? matches.flatMap((index) => candidateRows(baseline, fileLines, index, oldLines))
+        : [];
+    return { ok: false, reason: "no-match", candidates };
+  }
+  if (eligible.length > 1) {
+    return {
+      ok: false,
+      reason: "ambiguous",
+      candidates: eligible.flatMap((index) => candidateRows(baseline, fileLines, index, oldLines)),
+    };
+  }
+
+  const matchIndex = eligible[0]!;
+  return {
+    ok: true,
+    match: {
+      range: { startLine: matchIndex + 1, endLine: matchIndex + oldLines.length },
+      windowStart: startLine,
+    },
+  };
+}
+
+type AnchorLocation =
+  | { readonly kind: "line"; readonly line: number }
+  | { readonly kind: "missing"; readonly homes: readonly PatchPath[] }
+  | { readonly kind: "stale"; readonly servedLine: number };
+
+function locateAnchor(anchor: Anchor, context: ResolveContext): AnchorLocation {
+  const identity = context.identity;
+  if (identity !== undefined) {
+    const lease = identity.leaseFor(anchor);
+    if (lease === undefined) {
+      return { kind: "missing", homes: identity.anchorHomes?.(anchor) ?? [] };
+    }
+    const decision = resolveLineIdentity(lease, identity);
+    if (decision.kind === "stale") {
+      return { kind: "stale", servedLine: lease.servedLineNumber };
+    }
+    return { kind: "line", line: decision.line };
+  }
+  const position = uniqueServedPosition(context.served, anchor);
+  if (position === undefined) {
+    return { kind: "missing", homes: context.homesOf?.(anchor) ?? [] };
+  }
+  return { kind: "line", line: position };
+}
+
+function anchorProblem(
+  anchor: Anchor,
+  location: AnchorLocation,
+  context: ResolveContext,
+  patchLine: number,
+): PatchProblem {
+  const path = context.baseline.path;
+  if (location.kind === "missing") {
+    const homes = [...new Set(location.homes)];
+    const message =
+      homes.length > 0
+        ? `anchor "${anchor}" was served for ${homes.join(", ")}, not for ${path}`
+        : `anchor "${anchor}" was not served for ${path} in this session`;
+    return { code: "E_STALE_ANCHOR", patchLine, path, message };
+  }
+  return {
+    code: "E_STALE_ANCHOR",
+    patchLine,
+    path,
+    message: `anchor "${anchor}" is stale: its line identity was retired or no longer resolves`,
+    ...(location.kind === "stale" ? { line: location.servedLine } : {}),
+  };
+}
+
+/**
+ * Resolve one identity hunk (`@@<a>` / `@@<a>-<b>`) against the served set.
+ *
+ * The anchors must be present in `context.served` at exactly one position each
+ * (or hold a live lease when `context.identity` is present), `from` not after
+ * `to`. Every failure uses `E_STALE_ANCHOR` with the anchor named, so the
+ * planner can serve the file's current rows for a retry.
+ *
+ * @param hunk - the parsed identity hunk.
+ * @param context - baseline plus served anchors / lease source.
+ * @returns the resolved inclusive range, or all problems for this hunk.
+ */
+export function resolveIdentityHunk(
+  hunk: IdentityHunk,
+  context: ResolveContext,
+): IdentityResolveResult {
+  const anchors = [...new Set([hunk.span.from, hunk.span.to])];
+  const problems: PatchProblem[] = [];
+  const locations = new Map<Anchor, AnchorLocation>();
+  for (const anchor of anchors) {
+    const location = locateAnchor(anchor, context);
+    locations.set(anchor, location);
+    if (location.kind !== "line") {
+      problems.push(anchorProblem(anchor, location, context, hunk.headerLine));
+    }
+  }
+  if (problems.length > 0) return { ok: false, problems };
+
+  const fromLine = (locations.get(hunk.span.from) as { line: number }).line;
+  const toLine = (locations.get(hunk.span.to) as { line: number }).line;
+  if (fromLine > toLine) {
+    return {
+      ok: false,
+      problems: [
+        {
+          code: "E_PATCH_SYNTAX",
+          patchLine: hunk.headerLine,
+          path: context.baseline.path,
+          message: `identity span is reversed: anchor "${hunk.span.from}" resolves after "${hunk.span.to}"`,
+          line: fromLine,
+        },
+      ],
+    };
+  }
+  return { ok: true, range: { startLine: fromLine, endLine: toLine } };
+}
+
+/**
+ * Resolve one `*** Copy From:` / `*** Cut From:` hunk.
+ *
+ * The target addressing must be identity mode (`@@<a>` / `@@<a>-<b>`): a
+ * fragment-mode reference hunk is refused with `E_PATCH_SYNTAX` at the
+ * reference line. The source span must be served for the declared source file;
+ * the destination is replaced by the source bytes. A `cut` also plans the
+ * source retirement, in the same transaction, as a deletion over the same
+ * anchors.
+ *
+ * @param hunk - the parsed reference hunk.
+ * @param destination - the target file's baseline + served anchors / lease source.
+ * @param source - the source file's baseline + served anchors / lease source.
+ * @returns the materialized reference and destination mutation, or the problems.
+ */
+export function resolveReferenceHunk(
+  hunk: ReferenceHunk,
+  destination: ResolveContext,
+  source: ResolveContext | FileBaseline,
+  sourceServed?: ServedAnchors,
+): ReferenceResolveResult {
+  const sourceContext: ResolveContext =
+    "baseline" in source ? source : { baseline: source, served: sourceServed ?? [] };
+  if (hunk.address.kind !== "anchors") {
+    return {
+      ok: false,
+      problems: [
+        {
+          code: "E_PATCH_SYNTAX",
+          patchLine: hunk.headerLine,
+          path: destination.baseline.path,
+          message:
+            "Copy From / Cut From requires an identity target (@@<a> or @@<a>-<b>); fragment addressing is not allowed",
+        },
+      ],
+    };
+  }
+  const destinationResolved = resolveIdentityHunk(
+    {
+      kind: "identity",
+      span: hunk.address.span,
+      headerLine: hunk.headerLine,
+      addedLines: [],
+    },
+    destination,
+  );
+  if (!destinationResolved.ok) return { ok: false, problems: destinationResolved.problems };
+
+  const sourceResolved = resolveIdentityHunk(
+    {
+      kind: "identity",
+      span: hunk.source.span,
+      headerLine: hunk.source.line,
+      addedLines: [],
+    },
+    sourceContext,
+  );
+  if (!sourceResolved.ok) return { ok: false, problems: sourceResolved.problems };
+
+  const sourceLines = baselineLinesOf(sourceContext.baseline).slice(
+    sourceResolved.range.startLine - 1,
+    sourceResolved.range.endLine,
+  );
+  return {
+    ok: true,
+    reference: {
+      mode: hunk.source.mode,
+      path: sourceContext.baseline.path,
+      absolutePath: sourceContext.baseline.absolutePath,
+      range: sourceResolved.range,
+      lines: sourceLines,
+      patchLine: hunk.source.line,
+    },
+    mutation: {
+      kind: "replace",
+      range: destinationResolved.range,
+      lines: sourceLines,
+      patchLine: hunk.headerLine,
+    },
+  };
+}
+
+function isZeroWidth(range: LineRange): boolean {
+  return range.startLine > range.endLine;
+}
+
+function insertionPoint(range: LineRange): number {
+  return range.startLine - 1;
+}
+
+function rangesIntersect(left: LineRange, right: LineRange): boolean {
+  if (isZeroWidth(left) && isZeroWidth(right)) {
+    // WHY: multiple insertions at one point are ordered by submission, never an overlap.
+    return false;
+  }
+  if (isZeroWidth(left)) {
+    const point = insertionPoint(left);
+    return right.startLine <= point && point <= right.endLine;
+  }
+  if (isZeroWidth(right)) {
+    const point = insertionPoint(right);
+    return left.startLine <= point && point <= left.endLine;
+  }
+  return Math.max(left.startLine, right.startLine) <= Math.min(left.endLine, right.endLine);
+}
+
+function rangeLabel(range: LineRange): string {
+  return isZeroWidth(range)
+    ? `insertion after line ${insertionPoint(range)}`
+    : `lines ${range.startLine}-${range.endLine}`;
+}
+
+/**
+ * Check one file's resolved mutations for overlap.
+ *
+ * Two mutations whose target ranges intersect reject the whole call with
+ * `E_BATCH_ABORT`-shaped evidence (both patch lines named). Zero-width
+ * insertions at the same point are ordered by submission, not treated as
+ * overlap; every other intersection is a rejection.
+ *
+ * @param mutations - one file's mutations, in submission order.
+ * @param path - the target file for the problem's path field.
+ * @returns every overlap problem found (empty when disjoint).
+ */
+export function checkMutationOverlaps(
+  mutations: readonly PlannedMutation[],
+  path?: PatchPath,
+): readonly PatchProblem[] {
+  const problems: PatchProblem[] = [];
+  for (let left = 0; left < mutations.length; left++) {
+    for (let right = left + 1; right < mutations.length; right++) {
+      const a = mutations[left]!;
+      const b = mutations[right]!;
+      if (!rangesIntersect(a.range, b.range)) continue;
+      problems.push({
+        code: "E_BATCH_ABORT",
+        patchLine: b.patchLine,
+        ...(path !== undefined ? { path } : {}),
+        message:
+          `overlapping spans: mutation at patch line ${a.patchLine} (${rangeLabel(a.range)}) ` +
+          `overlaps mutation at patch line ${b.patchLine} (${rangeLabel(b.range)}); nothing was written`,
+      });
+    }
+  }
+  return problems;
+}