pim-agent 0.0.1 → 0.10.0

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

@@ -0,0 +1,379 @@
+import {
+  ADD_FILE_MARKER,
+  cleanPath,
+  DELETE_FILE_MARKER,
+  MOVE_TO_MARKER,
+  UPDATE_FILE_MARKER,
+} from "../../shared/PatchSummary";
+import type { Hunk, Patch, UpdateChunk } from "./types";
+
+const BEGIN_PATCH_MARKER = "*** Begin Patch";
+const END_PATCH_MARKER = "*** End Patch";
+const EOF_MARKER = "*** End of File";
+const CHANGE_CONTEXT_MARKER = "@@ ";
+const EMPTY_CHANGE_CONTEXT_MARKER = "@@";
+const MOVE_DESTINATION_REQUIRED =
+  "Invalid *** Move to directive: destination path is required.";
+
+type ParseErrorDetails =
+  | { readonly type: "patch"; readonly message: string }
+  | {
+      readonly type: "hunk";
+      readonly message: string;
+      readonly lineNumber: number;
+    };
+
+// Keep these formats byte-identical to Codex's ParseError Display; GPT models recover from them.
+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}`;
+  }
+}
+
+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) {
+    return parseAddHunk(lines, lineNumber, addPath);
+  }
+
+  const deletePath = stripPrefix(firstLine, DELETE_FILE_MARKER);
+  if (deletePath !== undefined) {
+    return parseDeleteHunk(lines, lineNumber, deletePath);
+  }
+
+  const updatePath = stripPrefix(firstLine, UPDATE_FILE_MARKER);
+  if (updatePath !== undefined) {
+    return parseUpdateHunk(lines, lineNumber, updatePath);
+  }
+
+  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 parseAddHunk(
+  lines: readonly string[],
+  lineNumber: number,
+  addPath: string
+): { readonly hunk: Hunk; readonly consumed: number } {
+  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,
+  };
+}
+
+function parseDeleteHunk(
+  lines: readonly string[],
+  lineNumber: number,
+  deletePath: string
+): { readonly hunk: Hunk; readonly consumed: number } {
+  const nextLine = lines[1];
+  if (
+    nextLine !== undefined &&
+    !isHunkHeader(nextLine) &&
+    !nextLine.trim().startsWith("*")
+  ) {
+    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,
+  };
+}
+
+function parseUpdateHunk(
+  lines: readonly string[],
+  lineNumber: number,
+  updatePath: string
+): { readonly hunk: Hunk; readonly consumed: number } {
+  let remaining = lines.slice(1);
+  let consumed = 1;
+
+  let movePath: string | undefined;
+  const moveLine = remaining[0]?.trim();
+  if (moveLine?.startsWith(MOVE_TO_MARKER)) {
+    const rawMovePath = moveLine.slice(MOVE_TO_MARKER.length);
+    if (rawMovePath.length === 0) {
+      throw new Error(
+        formatParseError({
+          type: "hunk",
+          lineNumber: lineNumber + consumed,
+          message: MOVE_DESTINATION_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: MOVE_DESTINATION_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);
+  }
+
+  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,
+  };
+}
+
+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)
+  );
+}

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

@@ -0,0 +1,177 @@
+import type { ToolDiff } from "../../shared/DiffLines";
+import { Paths } from "../../shared/Paths";
+import { PatchSummary } from "../../shared/PatchSummary";
+import type { ToolViewInput } from "../../shared/Tools";
+import { DiffBlocks } from "../../view/DiffBlocks";
+import { MovePath } from "../../view/MovePath";
+import type { Span, ToolIcon, ToolView, ViewBlock } from "../../view/ViewBlock";
+import type { ApplyEntry } from "./executor";
+import { type applyPatchSchema, prepareApplyPatchArguments } from "./schema";
+
+const ARROW = MovePath.ARROW;
+
+export type ApplyPatchDetails = {
+  readonly entries?: readonly ApplyEntry[];
+};
+
+export type ApplyPatchViewInput = ToolViewInput<
+  typeof applyPatchSchema,
+  ApplyPatchDetails
+>;
+
+type EntryView = {
+  readonly label: string;
+  readonly icon: ToolIcon;
+  readonly title: readonly Span[];
+  readonly path: string | undefined;
+  readonly stats: readonly Span[];
+  readonly body: ToolDiff | undefined;
+};
+
+export function applyPatchView({
+  args,
+  result,
+  cwd,
+}: ApplyPatchViewInput): ToolView {
+  const [first, ...rest] = visibleEntries(result?.details).map((entry) =>
+    describeEntry(entry, cwd)
+  );
+
+  if (first === undefined) {
+    return {
+      label: "Edit",
+      icon: "edit",
+      title: [{ kind: "file", path: callPath(args, cwd) }],
+    };
+  }
+
+  return {
+    label: first.label,
+    icon: first.icon,
+    title: [titleBlock(first), ...statsBlocks(first)],
+    body: [
+      ...DiffBlocks.body(first.body),
+      ...rest.flatMap((entry) => [
+        sectionBlock(entry),
+        ...DiffBlocks.body(entry.body),
+      ]),
+    ],
+  };
+}
+
+function visibleEntries(
+  details: ApplyPatchDetails | undefined
+): readonly ApplyEntry[] {
+  return (details?.entries ?? []).filter(
+    (entry) => !(entry.action.kind === "update" && entry.diff === undefined)
+  );
+}
+
+function callPath(
+  args: ApplyPatchViewInput["args"] | undefined,
+  cwd: string
+): string {
+  const prepared =
+    args === undefined ? undefined : prepareApplyPatchArguments(args);
+  const input =
+    typeof prepared?.input === "string" ? prepared.input : undefined;
+  const firstPath = input ? PatchSummary.firstPath(input) : undefined;
+  return Paths.titleOr(
+    firstPath ? Paths.resolve(firstPath, cwd) : undefined,
+    cwd
+  );
+}
+
+function describeEntry(entry: ApplyEntry, cwd: string): EntryView {
+  const rel = (p: string): string =>
+    Paths.toForwardSlashes(Paths.displayRelative(Paths.resolve(p, cwd), cwd));
+  const stats = DiffBlocks.statSpans(entry.diff);
+  const plain = (path: string): Pick<EntryView, "title" | "path"> => ({
+    title: [{ text: rel(path) }],
+    path: rel(path),
+  });
+
+  switch (entry.action.kind) {
+    case "add":
+      return {
+        label: "Write",
+        icon: "edit",
+        ...plain(entry.action.path),
+        stats,
+        body: entry.diff,
+      };
+    case "delete":
+      return {
+        label: "Delete",
+        icon: "trash",
+        ...plain(entry.action.path),
+        stats,
+        body: undefined,
+      };
+    case "move":
+      return {
+        label: entry.diff ? "Edit" : "Move",
+        icon: "edit",
+        title: moveTitle(
+          rel(entry.action.path),
+          rel(entry.action.movePath ?? entry.action.path)
+        ),
+        path: undefined,
+        stats,
+        body: entry.diff,
+      };
+    default:
+      return {
+        label: "Edit",
+        icon: "edit",
+        ...plain(entry.action.path),
+        stats,
+        body: entry.diff,
+      };
+  }
+}
+
+function titleBlock(entry: EntryView): ViewBlock {
+  return entry.path === undefined
+    ? { kind: "spans", spans: entry.title }
+    : { kind: "file", path: entry.path };
+}
+
+function statsBlocks(entry: EntryView): readonly ViewBlock[] {
+  return entry.stats.length === 0
+    ? []
+    : [{ kind: "spans", spans: entry.stats }];
+}
+
+function sectionBlock(entry: EntryView): ViewBlock {
+  return {
+    kind: "section",
+    label: entry.label,
+    icon: entry.icon,
+    content: [titleBlock(entry), ...statsBlocks(entry)],
+  };
+}
+
+function moveTitle(oldPath: string, newPath: string): readonly Span[] {
+  const folded = MovePath.fold(oldPath, newPath);
+
+  if (folded === undefined) {
+    return [
+      { text: oldPath, tone: "dim", strike: true },
+      { text: " " },
+      { text: ARROW, tone: "dim" },
+      { text: " " },
+      { text: newPath, tone: "title" },
+    ];
+  }
+
+  return [
+    { text: folded.prefix },
+    { text: "{", tone: "dim" },
+    { text: folded.from, tone: "dim", strike: true },
+    { text: ` ${ARROW} `, tone: "dim" },
+    { text: folded.to, tone: "title" },
+    { text: "}", tone: "dim" },
+    { text: folded.suffix, tone: "title" },
+  ];
+}

package/packages/core/src/extensions/apply-patch/schema.ts

@@ -0,0 +1,37 @@
+import { type Static, Type } from "typebox";
+
+export const applyPatchSchema = Type.Object({
+  input: Type.String({
+    description: "Patch text wrapped in *** Begin Patch / *** End Patch.",
+  }),
+});
+
+export type ApplyPatchInput = Static<typeof applyPatchSchema>;
+
+const ALIAS_KEYS = ["patch", "patchText", "patch_text"] as const;
+
+/** Normalize a bare string or a `patch`/`patchText`/`patch_text` key to `{input}`, dropping the alias. */
+export function prepareApplyPatchArguments(rawArgs: unknown): ApplyPatchInput {
+  if (typeof rawArgs === "string") {
+    return { input: rawArgs };
+  }
+
+  if (rawArgs === null || typeof rawArgs !== "object") {
+    return rawArgs as ApplyPatchInput;
+  }
+
+  const record = rawArgs as Record<string, unknown>;
+  if (typeof record.input === "string") {
+    return rawArgs as ApplyPatchInput;
+  }
+
+  for (const key of ALIAS_KEYS) {
+    const value = record[key];
+    if (typeof value === "string") {
+      const { [key]: _dropped, ...rest } = record;
+      return { ...rest, input: value } as ApplyPatchInput;
+    }
+  }
+
+  return rawArgs as ApplyPatchInput;
+}

package/packages/core/src/extensions/apply-patch/types.ts

@@ -0,0 +1,30 @@
+export type UpdateChunk = {
+  readonly changeContext: string | undefined;
+  readonly oldLines: readonly string[];
+  readonly newLines: readonly string[];
+  readonly isEndOfFile: boolean;
+};
+
+export type AddHunk = {
+  readonly kind: "add";
+  readonly path: string;
+  readonly contents: string;
+};
+
+export type DeleteHunk = {
+  readonly kind: "delete";
+  readonly path: string;
+};
+
+export type UpdateHunk = {
+  readonly kind: "update";
+  readonly path: string;
+  readonly movePath: string | undefined;
+  readonly chunks: readonly UpdateChunk[];
+};
+
+export type Hunk = AddHunk | DeleteHunk | UpdateHunk;
+
+export type Patch = {
+  readonly hunks: readonly Hunk[];
+};

package/packages/core/src/extensions/bash/capture.ts

@@ -0,0 +1,86 @@
+import { Lines } from "../../shared/Lines";
+import {
+  type CapturedStream,
+  STREAM_HEAD_BYTES,
+  STREAM_TAIL_BYTES,
+} from "./schema";
+
+export class StreamCapture {
+  private chunks: Uint8Array[] = [];
+  private totalBytesAccum = 0;
+  private fullBytes: Uint8Array | null = null;
+
+  push(chunk: Uint8Array): void {
+    if (chunk.byteLength === 0) {
+      return;
+    }
+    this.chunks.push(chunk);
+    this.totalBytesAccum += chunk.byteLength;
+  }
+
+  get totalBytes(): number {
+    return this.totalBytesAccum;
+  }
+
+  /** The first `n` bytes, read across however many chunks the kernel split them into. */
+  lead(n: number): Uint8Array {
+    if (this.fullBytes) {
+      return this.fullBytes.subarray(0, n);
+    }
+    const lead = new Uint8Array(Math.min(n, this.totalBytesAccum));
+    let at = 0;
+    for (const chunk of this.chunks) {
+      if (at === lead.byteLength) {
+        break;
+      }
+      const take = chunk.subarray(0, lead.byteLength - at);
+      lead.set(take, at);
+      at += take.byteLength;
+    }
+    return lead;
+  }
+
+  full(): Uint8Array {
+    if (!this.fullBytes) {
+      this.fullBytes = Buffer.concat(this.chunks, this.totalBytesAccum);
+      this.chunks = [];
+    }
+    return this.fullBytes;
+  }
+
+  /** Opaque bytes are not text: a half-image is worthless, so they are neither cut nor decoded. */
+  snapshot(opaque = false): CapturedStream {
+    if (this.totalBytesAccum === 0 || opaque) {
+      return {
+        text: "",
+        totalBytes: this.totalBytesAccum,
+        truncated: false,
+        path: null,
+        nextStart: null,
+      };
+    }
+    const dec = new TextDecoder();
+    const all = this.full();
+    if (this.totalBytesAccum <= STREAM_HEAD_BYTES + STREAM_TAIL_BYTES) {
+      return {
+        text: dec.decode(all),
+        totalBytes: this.totalBytesAccum,
+        truncated: false,
+        path: null,
+        nextStart: null,
+      };
+    }
+    const headText = dec.decode(all.subarray(0, STREAM_HEAD_BYTES));
+    const tailText = dec.decode(
+      all.subarray(all.byteLength - STREAM_TAIL_BYTES)
+    );
+    const middle = this.totalBytesAccum - STREAM_HEAD_BYTES - STREAM_TAIL_BYTES;
+    return {
+      text: `${headText}\n... ${middle} bytes truncated ...\n${tailText}`,
+      totalBytes: this.totalBytesAccum,
+      truncated: true,
+      path: null,
+      nextStart: Lines.continuationLine(headText),
+    };
+  }
+}