@aaroncql/pim-agent 0.0.1 → 0.2.0

package/src/extensions/apply-patch/model.ts

@@ -0,0 +1,34 @@
+type ModelLike = {
+  readonly provider?: string;
+  readonly api?: string;
+  readonly id?: string;
+};
+
+/**
+ * Conservative GPT/Codex-family detection. False positives demote a model to a
+ * tool it wasn't trained on, so misses beat false positives. Must NOT trigger
+ * for anthropic, nor for GPT-*named* non-OpenAI models served by aggregators
+ * (e.g. `eleutherai/gpt-neo`). It DOES trigger for a real OpenAI model routed
+ * through a gateway, identified by a vendor-namespaced id (`openai/gpt-4o`).
+ */
+export function isGptModel(model: ModelLike | undefined): boolean {
+  const provider = (model?.provider ?? "").toLowerCase();
+  const api = (model?.api ?? "").toLowerCase();
+  const id = (model?.id ?? "").toLowerCase();
+
+  // OpenAI is identified by the provider, or by a vendor-namespaced id used by
+  // aggregators (openrouter / vercel gateway serve "openai/gpt-4o"). Requiring
+  // the explicit "openai/" prefix still excludes GPT-named non-OpenAI models
+  // routed through the same aggregators.
+  const isOpenAi = provider.includes("openai") || id.startsWith("openai/");
+
+  return (
+    provider.includes("codex") ||
+    api.includes("codex") ||
+    id.includes("codex") ||
+    (isOpenAi && id.includes("gpt")) ||
+    (isOpenAi && /(^|\/)o\d/.test(id)) ||
+    ((provider.includes("copilot") || api.includes("copilot")) &&
+      id.includes("gpt"))
+  );
+}

package/src/extensions/apply-patch/parser.ts

@@ -0,0 +1,381 @@
+import type { Hunk, Patch, UpdateChunk } from "./types";
+
+const BEGIN_PATCH_MARKER = "*** Begin Patch";
+const END_PATCH_MARKER = "*** End Patch";
+export const ADD_FILE_MARKER = "*** Add File: ";
+export const DELETE_FILE_MARKER = "*** Delete File: ";
+export const UPDATE_FILE_MARKER = "*** Update File: ";
+const MOVE_TO_PREFIX = "*** Move to:";
+const EOF_MARKER = "*** End of File";
+const CHANGE_CONTEXT_MARKER = "@@ ";
+const EMPTY_CHANGE_CONTEXT_MARKER = "@@";
+
+type ParseErrorDetails =
+  | { readonly type: "patch"; readonly message: string }
+  | {
+      readonly type: "hunk";
+      readonly message: string;
+      readonly lineNumber: number;
+    };
+
+/**
+ * Match Codex's ParseError Display formats verbatim so GPT models see the exact
+ * error strings they were trained to recover from.
+ */
+function formatParseError(error: ParseErrorDetails): string {
+  switch (error.type) {
+    case "patch":
+      return `invalid patch: ${error.message}`;
+    case "hunk":
+      return `invalid hunk at line ${error.lineNumber}, ${error.message}`;
+  }
+}
+
+/**
+ * Strict envelope + hunk parser, faithfully ported from Codex's
+ * `parse_patch_text` (strict mode). The envelope check trims the whole text,
+ * requires the first line to start with `*** Begin Patch` and the last line to
+ * trim to exactly `*** End Patch`. Paths have a leading `@` and surrounding
+ * quotes stripped.
+ */
+export function parsePatch(text: string): Patch {
+  const lines = text.trim().split("\n");
+  checkBoundaries(lines);
+
+  const hunkLines = lines.slice(1, lines.length - 1);
+  const hunks: Hunk[] = [];
+  let remaining = hunkLines;
+  let lineNumber = 2;
+
+  while (remaining.length > 0) {
+    const { hunk, consumed } = parseOneHunk(remaining, lineNumber);
+    hunks.push(hunk);
+    lineNumber += consumed;
+    remaining = remaining.slice(consumed);
+  }
+
+  return { hunks };
+}
+
+function checkBoundaries(lines: readonly string[]): void {
+  const first = lines[0]?.trim();
+  const last = lines.at(-1)?.trim();
+
+  if (first === undefined || !lines[0]!.trim().startsWith(BEGIN_PATCH_MARKER)) {
+    throw new Error(
+      formatParseError({
+        type: "patch",
+        message:
+          "The first line of the patch must be '*** Begin Patch'. Do not include Markdown fences, prose, or shell heredoc text before it.",
+      })
+    );
+  }
+
+  if (last !== END_PATCH_MARKER) {
+    throw new Error(
+      formatParseError({
+        type: "patch",
+        message:
+          "The last line of the patch must be '*** End Patch'. Do not include Markdown fences or trailing prose after it.",
+      })
+    );
+  }
+}
+
+function parseOneHunk(
+  lines: readonly string[],
+  lineNumber: number
+): { readonly hunk: Hunk; readonly consumed: number } {
+  const firstLine = lines[0]!.trim();
+
+  const addPath = stripPrefix(firstLine, ADD_FILE_MARKER);
+  if (addPath !== undefined) {
+    let contents = "";
+    let consumed = 1;
+    for (const line of lines.slice(1)) {
+      if (line.startsWith("+")) {
+        contents += `${line.slice(1)}\n`;
+        consumed += 1;
+      } else {
+        break;
+      }
+    }
+    const nextLine = lines[consumed];
+    if (
+      nextLine !== undefined &&
+      !isHunkHeader(nextLine) &&
+      !nextLine.trim().startsWith("*")
+    ) {
+      throw new Error(
+        formatParseError({
+          type: "hunk",
+          lineNumber: lineNumber + consumed,
+          message: `Invalid Add File body: '${nextLine}' must start with '+'. Added file content lines must start with '+'.`,
+        })
+      );
+    }
+    return {
+      hunk: { kind: "add", path: cleanPath(addPath), contents },
+      consumed,
+    };
+  }
+
+  const deletePath = stripPrefix(firstLine, DELETE_FILE_MARKER);
+  if (deletePath !== undefined) {
+    const nextLine = lines[1];
+    if (nextLine !== undefined && !isHunkHeader(nextLine)) {
+      if (nextLine.trim().startsWith("*")) {
+        return {
+          hunk: { kind: "delete", path: cleanPath(deletePath) },
+          consumed: 1,
+        };
+      }
+      throw new Error(
+        formatParseError({
+          type: "hunk",
+          lineNumber: lineNumber + 1,
+          message: `Delete File hunks must not contain content lines, got: '${nextLine}'.`,
+        })
+      );
+    }
+    return {
+      hunk: { kind: "delete", path: cleanPath(deletePath) },
+      consumed: 1,
+    };
+  }
+
+  const updatePath = stripPrefix(firstLine, UPDATE_FILE_MARKER);
+  if (updatePath !== undefined) {
+    let remaining = lines.slice(1);
+    let consumed = 1;
+
+    let movePath: string | undefined;
+    const moveLine = remaining[0]?.trim();
+    if (moveLine?.startsWith(MOVE_TO_PREFIX)) {
+      const rawMovePath = moveLine.slice(MOVE_TO_PREFIX.length);
+      if (rawMovePath.length === 0) {
+        throw new Error(
+          formatParseError({
+            type: "hunk",
+            lineNumber: lineNumber + consumed,
+            message:
+              "Invalid *** Move to directive: destination path is required.",
+          })
+        );
+      }
+      if (!rawMovePath.startsWith(" ")) {
+        throw new Error(
+          formatParseError({
+            type: "hunk",
+            lineNumber: lineNumber + consumed,
+            message: `Invalid *** Move to directive: use '*** Move to: {path}'.`,
+          })
+        );
+      }
+      if (cleanPath(rawMovePath).length === 0) {
+        throw new Error(
+          formatParseError({
+            type: "hunk",
+            lineNumber: lineNumber + consumed,
+            message:
+              "Invalid *** Move to directive: destination path is required.",
+          })
+        );
+      }
+      movePath = rawMovePath;
+    } else if (moveLine?.startsWith("*** Move")) {
+      throw new Error(
+        formatParseError({
+          type: "hunk",
+          lineNumber: lineNumber + consumed,
+          message: `Invalid move directive '${moveLine}'. Use '*** Move to: {path}'.`,
+        })
+      );
+    }
+    if (movePath !== undefined) {
+      remaining = remaining.slice(1);
+      consumed += 1;
+    }
+
+    const chunks: UpdateChunk[] = [];
+    while (remaining.length > 0) {
+      if (remaining[0]!.trim() === "") {
+        consumed += 1;
+        remaining = remaining.slice(1);
+        continue;
+      }
+      if (remaining[0]!.startsWith("*")) {
+        break;
+      }
+
+      const { chunk, consumed: chunkLines } = parseUpdateChunk(
+        remaining,
+        lineNumber + consumed,
+        chunks.length === 0
+      );
+      chunks.push(chunk);
+      consumed += chunkLines;
+      remaining = remaining.slice(chunkLines);
+    }
+
+    // An Update with a Move to and no hunks is a valid pure rename; only an
+    // Update with neither a move nor any hunks is truly empty.
+    if (chunks.length === 0 && movePath === undefined) {
+      throw new Error(
+        formatParseError({
+          type: "hunk",
+          lineNumber,
+          message: `Update file hunk for path '${cleanPath(updatePath)}' is empty. Include @@ plus at least one context, added, or removed line, or add *** Move to for a pure rename.`,
+        })
+      );
+    }
+
+    return {
+      hunk: {
+        kind: "update",
+        path: cleanPath(updatePath),
+        movePath: movePath === undefined ? undefined : cleanPath(movePath),
+        chunks,
+      },
+      consumed,
+    };
+  }
+
+  throw new Error(
+    formatParseError({
+      type: "hunk",
+      lineNumber,
+      message:
+        `'${firstLine}' is not a valid hunk header. ` +
+        "Valid hunk headers: '*** Add File: {path}', '*** Delete File: {path}', '*** Update File: {path}'. " +
+        "Do not use unified-diff file headers like '---' or '+++' as hunk headers.",
+    })
+  );
+}
+
+function parseUpdateChunk(
+  lines: readonly string[],
+  lineNumber: number,
+  allowMissingContext: boolean
+): { readonly chunk: UpdateChunk; readonly consumed: number } {
+  let changeContext: string | undefined;
+  let startIndex: number;
+
+  if (lines[0] === EMPTY_CHANGE_CONTEXT_MARKER) {
+    changeContext = undefined;
+    startIndex = 1;
+  } else {
+    const ctx = stripPrefix(lines[0]!, CHANGE_CONTEXT_MARKER);
+    if (ctx !== undefined) {
+      changeContext = ctx;
+      startIndex = 1;
+    } else {
+      if (!allowMissingContext) {
+        throw new Error(
+          formatParseError({
+            type: "hunk",
+            lineNumber,
+            message: `Expected update hunk to start with a @@ context marker, got: '${lines[0]}'. Start each additional edit chunk with @@ or @@ followed by nearby context.`,
+          })
+        );
+      }
+      changeContext = undefined;
+      startIndex = 0;
+    }
+  }
+
+  if (startIndex >= lines.length) {
+    throw new Error(
+      formatParseError({
+        type: "hunk",
+        lineNumber,
+        message:
+          "Update hunk does not contain any context, added, or removed lines. Include at least one line starting with ' ', '+', or '-'.",
+      })
+    );
+  }
+
+  const oldLines: string[] = [];
+  const newLines: string[] = [];
+  let isEndOfFile = false;
+  let parsed = 0;
+
+  for (const line of lines.slice(startIndex)) {
+    if (line === EOF_MARKER) {
+      if (parsed === 0) {
+        throw new Error(
+          formatParseError({
+            type: "hunk",
+            lineNumber,
+            message:
+              "Update hunk does not contain any context, added, or removed lines. Include at least one line starting with ' ', '+', or '-'.",
+          })
+        );
+      }
+      isEndOfFile = true;
+      parsed += 1;
+      break;
+    }
+
+    const marker = line[0];
+    if (marker === undefined) {
+      oldLines.push("");
+      newLines.push("");
+    } else if (marker === " ") {
+      oldLines.push(line.slice(1));
+      newLines.push(line.slice(1));
+    } else if (marker === "+") {
+      newLines.push(line.slice(1));
+    } else if (marker === "-") {
+      oldLines.push(line.slice(1));
+    } else {
+      if (parsed === 0) {
+        throw new Error(
+          formatParseError({
+            type: "hunk",
+            lineNumber,
+            message:
+              `Unexpected line found in update hunk: '${line}'. ` +
+              "Every line should start with ' ' (context line), '+' (added line), or '-' (removed line). " +
+              "Unchanged context lines must be prefixed with a single space.",
+          })
+        );
+      }
+      break;
+    }
+    parsed += 1;
+  }
+
+  return {
+    chunk: { changeContext, oldLines, newLines, isEndOfFile },
+    consumed: parsed + startIndex,
+  };
+}
+
+function stripPrefix(value: string, prefix: string): string | undefined {
+  return value.startsWith(prefix) ? value.slice(prefix.length) : undefined;
+}
+
+function isHunkHeader(line: string): boolean {
+  const trimmed = line.trim();
+  return (
+    trimmed.startsWith(ADD_FILE_MARKER) ||
+    trimmed.startsWith(DELETE_FILE_MARKER) ||
+    trimmed.startsWith(UPDATE_FILE_MARKER)
+  );
+}
+
+export function cleanPath(raw: string): string {
+  let path = raw.trim();
+  if (path.startsWith("@")) {
+    path = path.slice(1).trim();
+  }
+  if (path.length >= 2) {
+    const first = path[0]!;
+    const last = path.at(-1)!;
+    if ((first === '"' || first === "'" || first === "`") && first === last) {
+      path = path.slice(1, -1);
+    }
+  }
+  return path;
+}

package/src/extensions/apply-patch/render.ts

@@ -0,0 +1,261 @@
+import type {
+  AgentToolResult,
+  Theme,
+  ToolRenderResultOptions,
+} from "@earendil-works/pi-coding-agent";
+import { type Component, Container } from "@earendil-works/pi-tui";
+import type { ToolDiff } from "../../shared/DiffLines";
+import {
+  type DiffRenderState,
+  type DiffStats,
+  DiffView,
+} from "../../shared/DiffView";
+import { Paths } from "../../shared/Paths";
+import { PatchSummary } from "../../shared/PatchSummary";
+import { type RenderContext, Renderer } from "../../shared/Renderer";
+import type { ApplyEntry } from "./executor";
+
+const ERROR_PREVIEW_LINES = 12;
+// Rename separator. ➝ (U+279D) reads more vertically centered than → in most
+// terminal fonts; swap here if a font renders it double-width.
+const ARROW = "➝";
+
+type ApplyPatchDetails = {
+  readonly entries?: readonly ApplyEntry[];
+};
+
+type ApplyPatchRenderContext = RenderContext & {
+  readonly cwd: string;
+  readonly state: DiffRenderState;
+};
+
+type EntryView = {
+  readonly label: string;
+  readonly title: string;
+  readonly stats: DiffStats;
+  // Body to render under the title; undefined => title only (delete, rename).
+  readonly body: ToolDiff | undefined;
+};
+
+// Draw an "Edit: <path>" title as soon as the call starts (mirroring the edit
+// tool) so there's never a blank row and an error still gets a header. The
+// title is for the first file and is updated in place on result.
+export function renderApplyPatchCall(
+  args: Record<string, unknown> | undefined,
+  theme: Theme,
+  context: ApplyPatchRenderContext
+): Component {
+  const input = typeof args?.input === "string" ? args.input : undefined;
+  const firstPath = input ? PatchSummary.firstPath(input) : undefined;
+  return DiffView.renderDiffCall({
+    label: "Edit",
+    rawPath: firstPath ? Paths.resolve(firstPath, context.cwd) : undefined,
+    theme,
+    context,
+  });
+}
+
+function blankLine(): Component {
+  return {
+    render: () => [""],
+    invalidate() {},
+  };
+}
+
+function describeEntry(
+  entry: ApplyEntry,
+  cwd: string,
+  theme: Theme
+): EntryView {
+  const rel = (p: string): string =>
+    Paths.toForwardSlashes(Paths.displayRelative(Paths.resolve(p, cwd), cwd));
+  const stats = DiffView.countStats(entry.diff);
+
+  switch (entry.action.kind) {
+    case "add":
+      // A new file: reuse the write-tool look (green content body).
+      return {
+        label: "Write",
+        title: rel(entry.action.path),
+        stats,
+        body: entry.diff,
+      };
+    case "delete":
+      // Title only with a -N stat; don't dump the removed file as a red diff.
+      return {
+        label: "Delete",
+        title: rel(entry.action.path),
+        stats,
+        body: undefined,
+      };
+    case "move":
+      // A pure move has no body; a move with content changes still renders as an edit.
+      return {
+        label: entry.diff ? "Edit" : "Move",
+        title: formatMoveTitle(
+          rel(entry.action.path),
+          rel(entry.action.movePath ?? entry.action.path),
+          theme
+        ),
+        stats,
+        body: entry.diff,
+      };
+    default:
+      return {
+        label: "Edit",
+        title: rel(entry.action.path),
+        stats,
+        body: entry.diff,
+      };
+  }
+}
+
+function formatMoveTitle(
+  oldPath: string,
+  newPath: string,
+  theme: Theme
+): string {
+  const oldParts = oldPath.split("/");
+  const newParts = newPath.split("/");
+  let commonPrefix = 0;
+
+  while (
+    commonPrefix < oldParts.length &&
+    commonPrefix < newParts.length &&
+    oldParts[commonPrefix] === newParts[commonPrefix]
+  ) {
+    commonPrefix += 1;
+  }
+
+  let commonSuffix = 0;
+  while (
+    commonSuffix < oldParts.length - commonPrefix &&
+    commonSuffix < newParts.length - commonPrefix &&
+    oldParts[oldParts.length - commonSuffix - 1] ===
+      newParts[newParts.length - commonSuffix - 1]
+  ) {
+    commonSuffix += 1;
+  }
+
+  const oldChanged = oldParts.slice(
+    commonPrefix,
+    oldParts.length - commonSuffix
+  );
+  const newChanged = newParts.slice(
+    commonPrefix,
+    newParts.length - commonSuffix
+  );
+
+  if (
+    oldChanged.length > 0 &&
+    newChanged.length > 0 &&
+    (commonPrefix > 0 ||
+      commonSuffix > 0 ||
+      (oldParts.length === 1 && newParts.length === 1))
+  ) {
+    const prefix =
+      commonPrefix > 0 ? `${oldParts.slice(0, commonPrefix).join("/")}/` : "";
+    const suffix =
+      commonSuffix > 0 ? `/${oldParts.slice(-commonSuffix).join("/")}` : "";
+
+    return (
+      prefix +
+      dim(theme, "{") +
+      dim(theme, theme.strikethrough(oldChanged.join("/"))) +
+      dim(theme, ` ${ARROW} `) +
+      normalTitle(theme, newChanged.join("/")) +
+      dim(theme, "}") +
+      normalTitle(theme, suffix)
+    );
+  }
+
+  return `${dim(theme, theme.strikethrough(oldPath))} ${dim(
+    theme,
+    ARROW
+  )} ${normalTitle(theme, newPath)}`;
+}
+
+function dim(theme: Theme, text: string): string {
+  return theme.fg("dim", text);
+}
+
+function normalTitle(theme: Theme, text: string): string {
+  return text === "" ? "" : theme.fg("toolTitle", text);
+}
+
+export function renderApplyPatchResult(
+  result: AgentToolResult<unknown>,
+  options: ToolRenderResultOptions,
+  theme: Theme,
+  context: ApplyPatchRenderContext
+): Component {
+  const state = context.state;
+  const container =
+    (context.lastComponent as Container | undefined) ?? new Container();
+  container.clear();
+
+  if (options.isPartial) {
+    return container;
+  }
+
+  if (context.isError) {
+    return Renderer.renderBorderedResult({
+      result,
+      options,
+      theme,
+      context: { ...context, isPartial: false },
+      previewLines: ERROR_PREVIEW_LINES,
+    });
+  }
+
+  const details = result.details as ApplyPatchDetails | undefined;
+  // A no-op update (rewrote identical content) has nothing to show; skip it.
+  const entries = (details?.entries ?? []).filter(
+    (entry) => !(entry.action.kind === "update" && entry.diff === undefined)
+  );
+  const markerColor = Renderer.markerColorFor(false, false);
+
+  entries.forEach((entry, index) => {
+    const view = describeEntry(entry, context.cwd, theme);
+
+    if (index === 0 && state?.titleComponent) {
+      // Reuse the call title for the first file, updating it in place.
+      DiffView.buildTitle({
+        label: view.label,
+        path: view.title,
+        stats: view.stats,
+        theme,
+        markerColor,
+        lastComponent: state.titleComponent,
+      });
+    } else {
+      // A blank padding row separates each file from the previous one.
+      if (index > 0) {
+        container.addChild(blankLine());
+      }
+      container.addChild(
+        DiffView.buildTitle({
+          label: view.label,
+          path: view.title,
+          stats: view.stats,
+          theme,
+          markerColor,
+          lastComponent: undefined,
+        })
+      );
+    }
+
+    if (view.body) {
+      container.addChild(
+        DiffView.buildBlock({
+          diff: view.body,
+          theme,
+          lastComponent: undefined,
+        })
+      );
+    }
+  });
+
+  container.invalidate();
+  return container;
+}