pim-agent 0.0.1 → 0.9.0

package/packages/core/src/shared/DiffLines.ts

@@ -0,0 +1,304 @@
+import * as Diff from "diff";
+
+export type ToolDiffLineKind = "context" | "added" | "removed";
+
+export type IntraLineRange = {
+  readonly start: number;
+  readonly end: number;
+};
+
+export type ToolDiffLine = {
+  readonly kind: ToolDiffLineKind;
+  readonly oldLine?: number;
+  readonly newLine?: number;
+  readonly text: string;
+  readonly emphasis?: readonly IntraLineRange[];
+};
+
+export type ToolDiffHunk = {
+  readonly oldStart: number;
+  readonly oldLines: number;
+  readonly newStart: number;
+  readonly newLines: number;
+  readonly lines: readonly ToolDiffLine[];
+};
+
+export type ToolDiff = {
+  readonly path: string;
+  readonly hunks: readonly ToolDiffHunk[];
+};
+
+// Keep the EOF-newline flag out of `lines`, or `joinComparable` emits a phantom blank line.
+export type ToolDiffSide = {
+  readonly lines: readonly string[];
+  readonly hasTrailingNewline: boolean;
+};
+
+function buildToolDiff(
+  path: string,
+  oldSide: ToolDiffSide,
+  newSide: ToolDiffSide,
+  contextSize: number
+): ToolDiff | undefined {
+  if (contextSize < 0 || !Number.isFinite(contextSize)) {
+    throw new Error(
+      `contextSize must be a non-negative finite number, got ${contextSize}.`
+    );
+  }
+
+  const lines = build(oldSide.lines, newSide.lines);
+
+  if (!lines.some((line) => line.kind !== "context")) {
+    return undefined;
+  }
+
+  const emphasized = attachEmphasis(lines);
+
+  return {
+    path,
+    hunks: buildHunks(emphasized, contextSize),
+  };
+}
+
+function fromText(text: string): ToolDiffSide {
+  if (text.length === 0) {
+    return emptySide;
+  }
+
+  const hasTrailingNewline = text.endsWith("\n");
+  const parts = text.split("\n");
+
+  if (hasTrailingNewline) {
+    parts.pop();
+  }
+
+  return { lines: parts, hasTrailingNewline };
+}
+
+function attachEmphasis(
+  lines: readonly ToolDiffLine[]
+): readonly ToolDiffLine[] {
+  const result: ToolDiffLine[] = [...lines];
+  let i = 0;
+
+  while (i < result.length) {
+    if (result[i]?.kind !== "removed") {
+      i += 1;
+      continue;
+    }
+
+    let removedEnd = i;
+    while (
+      removedEnd < result.length &&
+      result[removedEnd]?.kind === "removed"
+    ) {
+      removedEnd += 1;
+    }
+
+    let addedEnd = removedEnd;
+    while (addedEnd < result.length && result[addedEnd]?.kind === "added") {
+      addedEnd += 1;
+    }
+
+    const removedCount = removedEnd - i;
+    const addedCount = addedEnd - removedEnd;
+
+    if (removedCount > 0 && removedCount === addedCount) {
+      for (let k = 0; k < removedCount; k += 1) {
+        const removed = result[i + k];
+        const added = result[removedEnd + k];
+
+        if (removed === undefined || added === undefined) {
+          continue;
+        }
+
+        const ranges = computeIntraLineRanges(removed.text, added.text);
+
+        if (ranges === undefined) {
+          continue;
+        }
+
+        result[i + k] = { ...removed, emphasis: ranges.removed };
+        result[removedEnd + k] = { ...added, emphasis: ranges.added };
+      }
+    }
+
+    i = addedEnd > i ? addedEnd : i + 1;
+  }
+
+  return result;
+}
+
+function computeIntraLineRanges(
+  oldText: string,
+  newText: string
+):
+  | {
+      readonly removed: readonly IntraLineRange[];
+      readonly added: readonly IntraLineRange[];
+    }
+  | undefined {
+  const parts = Diff.diffWords(oldText, newText);
+  const removedRanges: IntraLineRange[] = [];
+  const addedRanges: IntraLineRange[] = [];
+  let oldPos = 0;
+  let newPos = 0;
+  let sharedLen = 0;
+  let firstRemoved = true;
+  let firstAdded = true;
+
+  for (const part of parts) {
+    const len = part.value.length;
+
+    if (part.added === true) {
+      const leading = firstAdded ? leadingWsLen(part.value) : 0;
+      firstAdded = false;
+      if (len - leading > 0) {
+        addedRanges.push({ start: newPos + leading, end: newPos + len });
+      }
+      newPos += len;
+      continue;
+    }
+
+    if (part.removed === true) {
+      const leading = firstRemoved ? leadingWsLen(part.value) : 0;
+      firstRemoved = false;
+      if (len - leading > 0) {
+        removedRanges.push({ start: oldPos + leading, end: oldPos + len });
+      }
+      oldPos += len;
+      continue;
+    }
+
+    sharedLen += len;
+    oldPos += len;
+    newPos += len;
+  }
+
+  if (sharedLen === 0) {
+    return undefined;
+  }
+
+  return { removed: removedRanges, added: addedRanges };
+}
+
+function build(
+  oldLines: readonly string[],
+  newLines: readonly string[]
+): readonly ToolDiffLine[] {
+  const parts = Diff.diffLines(
+    joinComparable(oldLines),
+    joinComparable(newLines)
+  );
+  const lines: ToolDiffLine[] = [];
+  let oldLine = 1;
+  let newLine = 1;
+
+  for (const part of parts) {
+    const values = partLines(part.value);
+
+    for (const text of values) {
+      if (part.added === true) {
+        lines.push({ kind: "added", newLine, text });
+        newLine += 1;
+        continue;
+      }
+
+      if (part.removed === true) {
+        lines.push({ kind: "removed", oldLine, text });
+        oldLine += 1;
+        continue;
+      }
+
+      lines.push({ kind: "context", oldLine, newLine, text });
+      oldLine += 1;
+      newLine += 1;
+    }
+  }
+
+  return lines;
+}
+
+function buildHunks(
+  lines: readonly ToolDiffLine[],
+  contextSize: number
+): readonly ToolDiffHunk[] {
+  const changeIndexes = lines
+    .map((line, index) => (line.kind === "context" ? -1 : index))
+    .filter((index) => index >= 0);
+  const hunks: ToolDiffHunk[] = [];
+  let firstChange = changeIndexes[0];
+  let lastChange = changeIndexes[0];
+
+  if (firstChange === undefined || lastChange === undefined) {
+    return hunks;
+  }
+
+  const pushHunk = (startChange: number, endChange: number): void => {
+    const hunkLines = lines.slice(
+      Math.max(0, startChange - contextSize),
+      Math.min(lines.length, endChange + contextSize + 1)
+    );
+    const oldNumbers = hunkLines.flatMap((line) =>
+      line.oldLine === undefined ? [] : [line.oldLine]
+    );
+    const newNumbers = hunkLines.flatMap((line) =>
+      line.newLine === undefined ? [] : [line.newLine]
+    );
+    const oldStart =
+      oldNumbers.length === 0
+        ? Math.max(0, (newNumbers[0] ?? 1) - 1)
+        : Math.min(...oldNumbers);
+    const newStart =
+      newNumbers.length === 0
+        ? Math.max(0, (oldNumbers[0] ?? 1) - 1)
+        : Math.min(...newNumbers);
+
+    hunks.push({
+      oldStart,
+      oldLines:
+        oldNumbers.length === 0 ? 0 : Math.max(...oldNumbers) - oldStart + 1,
+      newStart,
+      newLines:
+        newNumbers.length === 0 ? 0 : Math.max(...newNumbers) - newStart + 1,
+      lines: hunkLines,
+    });
+  };
+
+  for (const changeIndex of changeIndexes.slice(1)) {
+    if (changeIndex - lastChange <= contextSize * 2 + 1) {
+      lastChange = changeIndex;
+      continue;
+    }
+
+    pushHunk(firstChange, lastChange);
+    firstChange = changeIndex;
+    lastChange = changeIndex;
+  }
+
+  pushHunk(firstChange, lastChange);
+
+  return hunks;
+}
+
+function leadingWsLen(value: string): number {
+  return value.match(/^\s*/)?.[0].length ?? 0;
+}
+
+function joinComparable(lines: readonly string[]): string {
+  return lines.length === 0 ? "" : `${lines.join("\n")}\n`;
+}
+
+function partLines(value: string): readonly string[] {
+  const lines = value.split("\n");
+
+  if (lines.at(-1) === "") {
+    lines.pop();
+  }
+
+  return lines;
+}
+
+const emptySide: ToolDiffSide = { lines: [], hasTrailingNewline: false };
+
+export const DiffLines = { buildToolDiff, fromText, emptySide };

package/packages/core/src/shared/DiffRenderer.ts

@@ -0,0 +1,283 @@
+import { highlightCode, type Theme } from "@earendil-works/pi-coding-agent";
+import { DiffLayout } from "../view/DiffLayout";
+import type {
+  IntraLineRange,
+  ToolDiff,
+  ToolDiffHunk,
+  ToolDiffLine,
+} from "./DiffLines";
+import { Languages } from "./Languages";
+
+export type DiffRenderOptions = {
+  readonly toolDiff: ToolDiff;
+  readonly theme: Theme;
+};
+
+export type DiffHighlighter = (block: string) => readonly string[];
+
+type DiffBackgrounds = {
+  readonly added: string;
+  readonly removed: string;
+  readonly addedEmph: string;
+  readonly removedEmph: string;
+};
+
+const DARK_BG: DiffBackgrounds = {
+  added: "\x1b[48;2;13;40;24m",
+  removed: "\x1b[48;2;58;20;20m",
+  addedEmph: "\x1b[48;2;26;81;47m",
+  removedEmph: "\x1b[48;2;100;35;35m",
+};
+const LIGHT_BG: DiffBackgrounds = {
+  added: "\x1b[48;2;218;251;225m",
+  removed: "\x1b[48;2;255;235;233m",
+  addedEmph: "\x1b[48;2;172;238;187m",
+  removedEmph: "\x1b[48;2;255;195;188m",
+};
+const CLEAR_TO_EOL = "\x1b[K";
+const BG_RESET = "\x1b[49m";
+
+const KINDS = {
+  context: { sign: " ", role: "toolDiffContext" },
+  added: {
+    sign: "+",
+    role: "toolDiffAdded",
+    bg: "added",
+    emph: "addedEmph",
+  },
+  removed: {
+    sign: "−",
+    role: "toolDiffRemoved",
+    bg: "removed",
+    emph: "removedEmph",
+  },
+} as const satisfies Record<
+  ToolDiffLine["kind"],
+  {
+    readonly sign: string;
+    readonly role: string;
+    readonly bg?: keyof DiffBackgrounds;
+    readonly emph?: keyof DiffBackgrounds;
+  }
+>;
+
+function renderLines(options: DiffRenderOptions): string[] {
+  const { toolDiff, theme } = options;
+
+  if (toolDiff.hunks.length === 0) {
+    return [];
+  }
+
+  const highlighter = makeHighlighter(Languages.fromPath(toolDiff.path));
+  const numberWidth = DiffLayout.gutterWidth(toolDiff.hunks);
+  const backgrounds = backgroundsFor(theme);
+  const separator = renderHunkSeparator(theme, numberWidth);
+  const lines: string[] = [];
+
+  for (const [index, hunk] of toolDiff.hunks.entries()) {
+    if (index > 0) {
+      lines.push(separator);
+    }
+
+    lines.push(
+      ...renderHunk(hunk, highlighter, theme, numberWidth, backgrounds)
+    );
+  }
+
+  return lines;
+}
+
+function render(options: DiffRenderOptions): string {
+  return renderLines(options).join("\n");
+}
+
+function highlightHunkLines(
+  hunk: ToolDiffHunk,
+  highlighter: DiffHighlighter
+): readonly string[] {
+  const highlighted = DiffLayout.mapSides(hunk, highlighter);
+  return hunk.lines.map((line, index) => highlighted[index] ?? line.text);
+}
+
+function makeHighlighter(lang: string | undefined): DiffHighlighter {
+  if (lang === undefined) {
+    return (block) => DiffLayout.detab(block).split("\n");
+  }
+
+  return (block) => highlightCode(DiffLayout.detab(block), lang);
+}
+
+function backgroundsFor(theme: Theme): DiffBackgrounds {
+  return isLightTheme(theme) ? LIGHT_BG : DARK_BG;
+}
+
+function isLightTheme(theme: Theme): boolean {
+  const name = theme.name?.toLowerCase() ?? "";
+  return name === "light" || name.includes("light");
+}
+
+function renderHunk(
+  hunk: ToolDiffHunk,
+  highlighter: DiffHighlighter,
+  theme: Theme,
+  numberWidth: number,
+  backgrounds: DiffBackgrounds
+): readonly string[] {
+  const highlightedLines = highlightHunkLines(hunk, highlighter);
+
+  return hunk.lines.map((line, i) =>
+    renderLine(
+      line,
+      highlightedLines[i] ?? line.text,
+      theme,
+      numberWidth,
+      backgrounds
+    )
+  );
+}
+
+function renderLine(
+  line: ToolDiffLine,
+  content: string,
+  theme: Theme,
+  numberWidth: number,
+  backgrounds: DiffBackgrounds
+): string {
+  const prefix = formatPrefix(line, theme, numberWidth);
+  const emphasized = applyLineEmphasis(line, content, backgrounds);
+  return applyBackground(line.kind, ` ${prefix}${emphasized}`, backgrounds);
+}
+
+function applyLineEmphasis(
+  line: ToolDiffLine,
+  content: string,
+  backgrounds: DiffBackgrounds
+): string {
+  const ranges = line.emphasis;
+  const kind = KINDS[line.kind];
+
+  if (ranges === undefined || ranges.length === 0 || !("emph" in kind)) {
+    return content;
+  }
+
+  return applyEmphasis(
+    content,
+    ranges,
+    backgrounds[kind.bg],
+    backgrounds[kind.emph]
+  );
+}
+
+function applyEmphasis(
+  text: string,
+  ranges: readonly IntraLineRange[],
+  lineBg: string,
+  emphBg: string
+): string {
+  if (ranges.length === 0) {
+    return text;
+  }
+
+  const starts = new Set<number>();
+  const ends = new Set<number>();
+
+  for (const range of ranges) {
+    if (range.end > range.start) {
+      starts.add(range.start);
+      ends.add(range.end);
+    }
+  }
+
+  if (starts.size === 0) {
+    return text;
+  }
+
+  let result = "";
+  let visiblePos = 0;
+  let i = 0;
+  let segStart = 0;
+
+  while (i < text.length) {
+    if (text.charCodeAt(i) === 0x1b && text[i + 1] === "[") {
+      const escEnd = text.indexOf("m", i + 2);
+
+      if (escEnd === -1) {
+        return result + text.slice(segStart);
+      }
+
+      i = escEnd + 1;
+      continue;
+    }
+
+    if (ends.has(visiblePos) || starts.has(visiblePos)) {
+      if (i > segStart) {
+        result += text.slice(segStart, i);
+      }
+      if (ends.has(visiblePos)) {
+        result += lineBg;
+      }
+      if (starts.has(visiblePos)) {
+        result += emphBg;
+      }
+      segStart = i;
+    }
+
+    visiblePos += 1;
+    i += 1;
+  }
+
+  if (i > segStart) {
+    result += text.slice(segStart, i);
+  }
+  if (ends.has(visiblePos)) {
+    result += lineBg;
+  }
+  if (starts.has(visiblePos)) {
+    result += emphBg;
+  }
+
+  return result;
+}
+
+function applyBackground(
+  kind: ToolDiffLine["kind"],
+  text: string,
+  backgrounds: DiffBackgrounds
+): string {
+  const spec = KINDS[kind];
+
+  return "bg" in spec
+    ? `${backgrounds[spec.bg]}${text}${CLEAR_TO_EOL}${BG_RESET}`
+    : text;
+}
+
+function formatPrefix(
+  line: ToolDiffLine,
+  theme: Theme,
+  numberWidth: number
+): string {
+  const numLabel = formatLineNumber(DiffLayout.lineNumber(line), numberWidth);
+  const kind = KINDS[line.kind];
+
+  return theme.fg(kind.role, `${numLabel} ${kind.sign} `);
+}
+
+function formatLineNumber(value: number | undefined, width: number): string {
+  if (value === undefined) {
+    return " ".repeat(width);
+  }
+
+  return String(value).padStart(width, " ");
+}
+
+function renderHunkSeparator(theme: Theme, numberWidth: number): string {
+  const filler = " ".repeat(numberWidth);
+  return theme.fg("toolDiffContext", ` ${filler}   ⋯`);
+}
+
+export const DiffRenderer = {
+  render,
+  renderLines,
+  highlightHunkLines,
+  applyEmphasis,
+};

package/packages/core/src/shared/DiffView.ts

@@ -0,0 +1,29 @@
+import type { ToolDiff } from "./DiffLines";
+
+export type DiffStats = {
+  readonly added: number;
+  readonly removed: number;
+};
+
+function countStats(diff: ToolDiff | undefined): DiffStats {
+  if (!diff) {
+    return { added: 0, removed: 0 };
+  }
+
+  let added = 0;
+  let removed = 0;
+
+  for (const hunk of diff.hunks) {
+    for (const line of hunk.lines) {
+      if (line.kind === "added") {
+        added += 1;
+      } else if (line.kind === "removed") {
+        removed += 1;
+      }
+    }
+  }
+
+  return { added, removed };
+}
+
+export const DiffView = { countStats };

package/packages/core/src/shared/Directories.ts

@@ -0,0 +1,61 @@
+import { readdir, stat } from "node:fs/promises";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+
+import { FsErrors } from "./FsErrors";
+import { Paths } from "./Paths";
+
+export type DirectoryEntry = {
+  readonly name: string;
+  readonly path: string;
+};
+
+export type DirectoryListing = {
+  /** What was read: absolute, resolved, and with `~` expanded. */
+  readonly path: string;
+  /** Absent at the root of the filesystem, which is its own parent. */
+  readonly parent?: string;
+  /** The directories inside it, name-sorted, hidden ones included. */
+  readonly entries: readonly DirectoryEntry[];
+};
+
+async function check(path: string): Promise<string | undefined> {
+  try {
+    const found = await stat(path);
+    return found.isDirectory() ? undefined : `not a directory: ${path}`;
+  } catch (err) {
+    return FsErrors.code(err) === "ENOENT"
+      ? `path does not exist: ${path}`
+      : `stat failed: ${(err as Error).message}`;
+  }
+}
+
+async function list(path: string): Promise<DirectoryListing> {
+  const expanded = Paths.expandHome(path);
+  if (!isAbsolute(expanded)) {
+    throw new Error(`not an absolute path: ${path}`);
+  }
+  const resolved = resolve(expanded);
+  const reason = await check(resolved);
+  if (reason !== undefined) {
+    throw new Error(reason);
+  }
+  const found = await Promise.all(
+    (await readdir(resolved, { withFileTypes: true })).map(async (entry) => {
+      const child = join(resolved, entry.name);
+      const directory = entry.isSymbolicLink()
+        ? ((await stat(child).catch(() => undefined))?.isDirectory() ?? false)
+        : entry.isDirectory();
+      return directory ? { name: entry.name, path: child } : undefined;
+    })
+  );
+  const parent = dirname(resolved);
+  return {
+    path: resolved,
+    ...(parent === resolved ? {} : { parent }),
+    entries: found
+      .filter((entry): entry is DirectoryEntry => entry !== undefined)
+      .sort((a, b) => a.name.localeCompare(b.name)),
+  };
+}
+
+export const Directories = { check, list };