pim-agent 0.13.0 → 0.14.0

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

@@ -28,7 +28,7 @@ export type ToolDiff = {
   readonly hunks: readonly ToolDiffHunk[];
 };
 
-// Keep the EOF-newline flag out of `lines`, or `joinComparable` emits a phantom blank line.
+// The EOF newline is a flag, not an empty last line, or diffs gain a phantom blank line.
 export type ToolDiffSide = {
   readonly lines: readonly string[];
   readonly hasTrailingNewline: boolean;
@@ -48,16 +48,11 @@ function buildToolDiff(
 
   const lines = build(oldSide.lines, newSide.lines);
 
-  if (!lines.some((line) => line.kind !== "context")) {
+  if (lines.every((line) => line.kind === "context")) {
     return undefined;
   }
 
-  const emphasized = attachEmphasis(lines);
-
-  return {
-    path,
-    hunks: buildHunks(emphasized, contextSize),
-  };
+  return { path, hunks: buildHunks(attachEmphasis(lines), contextSize) };
 }
 
 function fromText(text: string): ToolDiffSide {
@@ -82,48 +77,35 @@ function attachEmphasis(
   let i = 0;
 
   while (i < result.length) {
-    if (result[i]?.kind !== "removed") {
+    if (result[i]!.kind !== "removed") {
       i += 1;
       continue;
     }
 
     let removedEnd = i;
-    while (
-      removedEnd < result.length &&
-      result[removedEnd]?.kind === "removed"
-    ) {
+    while (result[removedEnd]?.kind === "removed") {
       removedEnd += 1;
     }
-
     let addedEnd = removedEnd;
-    while (addedEnd < result.length && result[addedEnd]?.kind === "added") {
+    while (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;
-        }
-
+    // Only pair lines when the removed and added runs are the same length.
+    const count = removedEnd - i;
+    if (count === addedEnd - removedEnd) {
+      for (let k = 0; k < count; k += 1) {
+        const removed = result[i + k]!;
+        const added = result[removedEnd + k]!;
         const ranges = computeIntraLineRanges(removed.text, added.text);
-
-        if (ranges === undefined) {
-          continue;
+        if (ranges !== undefined) {
+          result[i + k] = { ...removed, emphasis: ranges.removed };
+          result[removedEnd + k] = { ...added, emphasis: ranges.added };
         }
-
-        result[i + k] = { ...removed, emphasis: ranges.removed };
-        result[removedEnd + k] = { ...added, emphasis: ranges.added };
       }
     }
 
-    i = addedEnd > i ? addedEnd : i + 1;
+    i = addedEnd;
   }
 
   return result;

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

@@ -112,8 +112,7 @@ function backgroundsFor(theme: Theme): DiffBackgrounds {
 }
 
 function isLightTheme(theme: Theme): boolean {
-  const name = theme.name?.toLowerCase() ?? "";
-  return name === "light" || name.includes("light");
+  return theme.name?.toLowerCase().includes("light") ?? false;
 }
 
 function renderHunk(
@@ -174,10 +173,6 @@ function applyEmphasis(
   lineBg: string,
   emphBg: string
 ): string {
-  if (ranges.length === 0) {
-    return text;
-  }
-
   const starts = new Set<number>();
   const ends = new Set<number>();
 
@@ -192,6 +187,9 @@ function applyEmphasis(
     return text;
   }
 
+  const marker = (pos: number): string =>
+    (ends.has(pos) ? lineBg : "") + (starts.has(pos) ? emphBg : "");
+
   let result = "";
   let visiblePos = 0;
   let i = 0;
@@ -209,16 +207,9 @@ function applyEmphasis(
       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;
-      }
+    const mark = marker(visiblePos);
+    if (mark !== "") {
+      result += text.slice(segStart, i) + mark;
       segStart = i;
     }
 
@@ -226,17 +217,7 @@ function applyEmphasis(
     i += 1;
   }
 
-  if (i > segStart) {
-    result += text.slice(segStart, i);
-  }
-  if (ends.has(visiblePos)) {
-    result += lineBg;
-  }
-  if (starts.has(visiblePos)) {
-    result += emphBg;
-  }
-
-  return result;
+  return result + text.slice(segStart) + marker(visiblePos);
 }
 
 function applyBackground(

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

@@ -10,11 +10,11 @@ export type DirectoryEntry = {
 };
 
 export type DirectoryListing = {
-  /** What was read: absolute, resolved, and with `~` expanded. */
+  /** Absolute, resolved, `~` expanded. */
   readonly path: string;
-  /** Absent at the root of the filesystem, which is its own parent. */
+  /** Absent at the filesystem root. */
   readonly parent?: string;
-  /** The directories inside it, name-sorted, hidden ones included. */
+  /** Subdirectories only, name-sorted, hidden included. */
   readonly entries: readonly DirectoryEntry[];
 };
 
@@ -78,7 +78,7 @@ function refusal(error: unknown, path: string): string {
   }
 }
 
-/** Makes one directory inside an existing one. Never recursive: a parent that is missing is said so, not invented. */
+/** Not recursive: a missing parent is an error. */
 async function create(path: string): Promise<void> {
   const name = basename(Paths.expandHome(path));
   if (name === "" || name === "." || name === "..") {

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

@@ -81,7 +81,9 @@ function resolve(
 
     if (replaceAll) {
       return {
-        ranges: sortRanges(candidates.map((candidate) => candidate.range)),
+        ranges: candidates
+          .map((candidate) => candidate.range)
+          .sort((left, right) => left[0] - right[0]),
         strategy: strategy.name,
         matchCount: candidates.length,
       };
@@ -441,25 +443,10 @@ function unicodeNormalized({
   content,
   oldString,
 }: MatchInput): readonly Candidate[] {
-  // normalizeUnicode substitutions must stay 1:1 by UTF-16 code unit, or offsets desync.
-  const normalizedContent = normalizeUnicode(content);
-  const normalizedOld = normalizeUnicode(oldString);
-  const candidates: Candidate[] = [];
-  let index = 0;
-
-  while (true) {
-    const start = normalizedContent.indexOf(normalizedOld, index);
-
-    if (start === -1) {
-      break;
-    }
-
-    const end = start + oldString.length;
-    candidates.push({ range: [start, end], text: content.slice(start, end) });
-    index = Math.max(start + 1, end);
-  }
-
-  return candidates;
+  // normalizeUnicode must map 1:1 by UTF-16 code unit, or offsets desync.
+  return findAll(normalizeUnicode(content), normalizeUnicode(oldString)).map(
+    ({ range }) => ({ range, text: content.slice(...range) })
+  );
 }
 
 function blockAnchor(input: MatchInput): readonly Candidate[] {
@@ -477,7 +464,7 @@ function blockAnchor(input: MatchInput): readonly Candidate[] {
         ) / middleCount;
     }
 
-    // 0.3 floor filters anchor coincidence on unrelated blocks sharing first/last line text.
+    // Rejects unrelated blocks that merely share first and last lines.
     return similarity >= 0.3;
   });
 }
@@ -598,10 +585,6 @@ function dedupeCandidates(
   return deduped;
 }
 
-function sortRanges(ranges: readonly EditRange[]): readonly EditRange[] {
-  return [...ranges].sort((left, right) => left[0] - right[0]);
-}
-
 function logicalLines(content: string): readonly string[] {
   if (content.length === 0) {
     return [];
@@ -653,31 +636,17 @@ function offsetLines(content: string): readonly OffsetLine[] {
   return lines;
 }
 
+const CONTROL_ESCAPES: Readonly<Record<string, string>> = {
+  n: "\n",
+  t: "\t",
+  r: "\r",
+};
+
 function unescapeString(text: string): string {
-  return text.replace(/\\(n|t|r|'|"|`|\\|\n|\$)/gu, (match, value) => {
-    switch (value) {
-      case "n":
-        return "\n";
-      case "t":
-        return "\t";
-      case "r":
-        return "\r";
-      case "'":
-        return "'";
-      case '"':
-        return '"';
-      case "`":
-        return "`";
-      case "\\":
-        return "\\";
-      case "\n":
-        return "\n";
-      case "$":
-        return "$";
-      default:
-        return match;
-    }
-  });
+  return text.replace(
+    /\\(n|t|r|'|"|`|\\|\n|\$)/gu,
+    (_, value: string) => CONTROL_ESCAPES[value] ?? value
+  );
 }
 
 function escapeSequences(text: string): readonly string[] {
@@ -763,5 +732,4 @@ export const EditMatcher = {
   renderNotFound,
   lineRangeFor,
   NotFoundError,
-  MultipleMatchesError,
 };

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

@@ -2,7 +2,7 @@ import type { ExtensionFactory } from "@earendil-works/pi-coding-agent";
 
 import { PimSettings } from "./PimSettings";
 
-// Pi's `enabled` filter covers disk paths only, never inline factories: pim owns this roster.
+// Pi's `enabled` filter skips inline factories, so pim keeps its own roster.
 const EXTENSIONS = {
   _init: "Splash screen, runtime guard, /clear",
   "apply-patch": "apply_patch tool",
@@ -34,8 +34,7 @@ const DEFAULT_DISABLED: readonly PimExtensionName[] = ["todo", "tps"];
 
 const REQUIRED: readonly PimExtensionName[] = ["_init", "pim", "session-lease"];
 
-// Hardcoded, never derived: the browser switches these and nothing else, under
-// the label it gives them — the terminal menu names them by key, this does not.
+// The only toggles the browser shows.
 const WEB = [{ name: "todo", label: "Todo Tool" }] as const satisfies readonly {
   name: PimExtensionName;
   label: string;
@@ -53,7 +52,7 @@ function describe(name: PimExtensionName): string {
   return EXTENSIONS[name];
 }
 
-// Gate inside the factory, not around the roster: pi re-invokes factories on `ctx.reload()`.
+// Checked inside the factory because pi re-runs factories on `ctx.reload()`.
 function gate(
   name: PimExtensionName,
   factory: ExtensionFactory
@@ -79,7 +78,6 @@ async function isDisabled(name: string): Promise<boolean> {
   return !enabled(name, toggles);
 }
 
-// Serialized: each call is a read-modify-write of the same record.
 async function setDisabled(name: string, isOff: boolean): Promise<void> {
   if (!isKnown(name)) {
     throw new Error(`Unknown pim extension "${name}"`);
@@ -128,7 +126,6 @@ export const ExtensionToggles = {
   NAMES,
   WEB,
   isRequired,
-  isKnown,
   describe,
   gate,
   disabled,

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

@@ -1,4 +1,4 @@
-import { readdir } from "node:fs/promises";
+import { readdir, stat } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import ignore, { type Ignore } from "ignore";
 
@@ -86,8 +86,8 @@ function pushRules(out: string[], content: string): void {
   }
 }
 
-// Gitignore anchoring: a pattern containing a non-trailing slash only gains the prefix; one
-// without also gains `**/`, or it stops matching below its own directory.
+// Rewrites a nested .gitignore relative to the repo root. Slash-free patterns gain `**/`
+// so they still match at any depth below their directory.
 function reanchorRules(
   content: string,
   basePrefix: string,
@@ -122,10 +122,30 @@ function reanchorRules(
   }
 }
 
+function addDirRules(
+  out: string[],
+  content: string,
+  dirAbs: string,
+  repoRootAbs: string
+): void {
+  const dirRel = relFromBase(dirAbs, repoRootAbs);
+  if (dirRel === undefined || dirRel === "") {
+    pushRules(out, content);
+  } else {
+    reanchorRules(content, `${dirRel}/`, out);
+  }
+}
+
 async function findRepoRoot(start: string): Promise<string | undefined> {
   let dir = start;
   for (;;) {
-    if (await Bun.file(join(dir, ".git")).exists()) {
+    // `.git` is a directory in a normal repo and a file in a worktree.
+    if (
+      await stat(join(dir, ".git")).then(
+        () => true,
+        () => false
+      )
+    ) {
       return dir;
     }
     const parent = dirname(dir);
@@ -177,7 +197,7 @@ async function processDir(
   if (ctx.useIgnore) {
     const hasDotGit = entries.some((e) => e.name === ".git");
     if (hasDotGit) {
-      // A .git is a repo boundary: a child repo must not inherit its parent's rules.
+      // A nested repo does not inherit its parent's rules.
       inRepo = true;
       repoRootAbs = currentDir.abs;
       rules = await repoBaseRules(currentDir.abs, ctx.globalGitIgnore);
@@ -191,14 +211,8 @@ async function processDir(
           join(currentDir.abs, ".gitignore")
         );
         if (content !== undefined) {
-          const dirRel = relFromBase(currentDir.abs, repoRootAbs);
-          const next = rules.slice();
-          if (dirRel === undefined || dirRel === "") {
-            pushRules(next, content);
-          } else {
-            reanchorRules(content, `${dirRel}/`, next);
-          }
-          rules = next;
+          rules = rules.slice();
+          addDirRules(rules, content, currentDir.abs, repoRootAbs);
           matcher = ignore().add(rules);
         }
       }
@@ -255,13 +269,11 @@ async function processDir(
 
     if (entry.isFile() || isSymlink) {
       ctx.result.push(relPath);
-      continue;
     }
   }
 }
 
-// Refill from the shared stack on each completion; N worker loops would exit on the root-only
-// stack before any child was pushed and silently return a partial listing.
+// Refill on each completion: fixed workers would exit early while the stack holds only the root.
 function drain(ctx: WalkContext): Promise<void> {
   let inFlight = 0;
   return new Promise<void>((resolve, reject) => {
@@ -282,6 +294,41 @@ function drain(ctx: WalkContext): Promise<void> {
   });
 }
 
+/** Rules from a repo strictly above `root`; `root`'s own .gitignore is read by processDir. */
+async function enclosingRepo(
+  root: string,
+  globalGitIgnore: string | undefined
+): Promise<
+  { readonly repoRoot: string; readonly rules: string[] } | undefined
+> {
+  const repoRoot = await findRepoRoot(root);
+  if (repoRoot === undefined || repoRoot === root) {
+    return undefined;
+  }
+  const rules = await repoBaseRules(repoRoot, globalGitIgnore);
+
+  // Shallowest first: gitignore precedence is by depth.
+  const intermediates: string[] = [];
+  let dir = dirname(root);
+  while (dir !== repoRoot && dir.length > repoRoot.length) {
+    intermediates.push(dir);
+    const parent = dirname(dir);
+    if (parent === dir) {
+      break;
+    }
+    dir = parent;
+  }
+  intermediates.reverse();
+
+  for (const dirAbs of intermediates) {
+    const content = await readIgnoreFile(join(dirAbs, ".gitignore"));
+    if (content !== undefined) {
+      addDirRules(rules, content, dirAbs, repoRoot);
+    }
+  }
+  return { repoRoot, rules };
+}
+
 /** All files under `root` as root-relative POSIX paths; `.gitignore` is honored only inside a repo. */
 async function enumerate(
   root: string,
@@ -298,43 +345,9 @@ async function enumerate(
       pathname === undefined ? undefined : await readIgnoreFile(pathname);
   }
 
-  // Seed rules from a repo enclosing `root`; `root`'s own .gitignore is added by processDir.
-  let initialInRepo = false;
-  let initialRepoRootAbs = root;
-  let initialRules: string[] = [];
-  if (useIgnore) {
-    const repoRoot = await findRepoRoot(root);
-    if (repoRoot !== undefined && repoRoot !== root) {
-      initialInRepo = true;
-      initialRepoRootAbs = repoRoot;
-      initialRules = await repoBaseRules(repoRoot, globalGitIgnore);
-
-      // Shallowest first: gitignore precedence is by depth.
-      const intermediates: string[] = [];
-      let dir = dirname(root);
-      while (dir !== repoRoot && dir.length > repoRoot.length) {
-        intermediates.push(dir);
-        const parent = dirname(dir);
-        if (parent === dir) {
-          break;
-        }
-        dir = parent;
-      }
-      intermediates.reverse();
-
-      for (const dirAbs of intermediates) {
-        const content = await readIgnoreFile(join(dirAbs, ".gitignore"));
-        if (content !== undefined) {
-          const dirRel = relFromBase(dirAbs, repoRoot);
-          if (dirRel === undefined || dirRel === "") {
-            pushRules(initialRules, content);
-          } else {
-            reanchorRules(content, `${dirRel}/`, initialRules);
-          }
-        }
-      }
-    }
-  }
+  const enclosing = useIgnore
+    ? await enclosingRepo(root, globalGitIgnore)
+    : undefined;
 
   const ctx: WalkContext = {
     includeDotfiles,
@@ -344,10 +357,13 @@ async function enumerate(
       {
         abs: root,
         rel: "",
-        inRepo: initialInRepo,
-        repoRootAbs: initialRepoRootAbs,
-        ignoreRules: initialRules,
-        matcher: initialInRepo ? ignore().add(initialRules) : EMPTY_MATCHER,
+        inRepo: enclosing !== undefined,
+        repoRootAbs: enclosing?.repoRoot ?? root,
+        ignoreRules: enclosing?.rules ?? [],
+        matcher:
+          enclosing === undefined
+            ? EMPTY_MATCHER
+            : ignore().add(enclosing.rules),
       },
     ],
     result: [],

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

@@ -21,19 +21,11 @@ async function scan(
   });
   const matcher = new Bun.Glob(await expandDirectory(absoluteRoot, pattern));
   const excludes = GlobExclusions.compile(options.exclude);
-  const files: string[] = [];
-
-  for (const relativePath of relativePaths) {
-    if (!matcher.match(relativePath)) {
-      continue;
-    }
-    if (GlobExclusions.ignores(excludes, relativePath)) {
-      continue;
-    }
-    files.push(join(absoluteRoot, relativePath));
-  }
-
-  return files;
+  return relativePaths
+    .filter(
+      (path) => matcher.match(path) && !GlobExclusions.ignores(excludes, path)
+    )
+    .map((path) => join(absoluteRoot, path));
 }
 
 async function expandDirectory(

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

@@ -8,10 +8,7 @@ import { basename, dirname, join } from "node:path";
 
 const POLL_MS = 1_000;
 
-/**
- * A burst coalesces into one event, and the read it triggers can land inside
- * the burst — so look once more after it, or the last write waits on the poll.
- */
+/** A burst arrives as one event, so look again shortly after to catch its last write. */
 const SETTLE_MS = 25;
 
 function signatureOf(path: string): string {
@@ -21,7 +18,7 @@ function signatureOf(path: string): string {
     : `${stats.mtimeMs}:${stats.size}:${stats.ino}`;
 }
 
-/** Reports a change only once the path itself moved, so a watcher firing for its neighbours costs nothing. */
+/** Calls `onChange` only when the path's stat signature changed. */
 function tracker(path: string, onChange: () => void): () => void {
   let signature = signatureOf(path);
   return (): void => {
@@ -34,11 +31,7 @@ function tracker(path: string, onChange: () => void): () => void {
   };
 }
 
-/**
- * `fs.watch` reports nothing at all on some filesystems and network mounts, so
- * the poll beside it is not optional. The poll also re-arms the watcher, which
- * a directory that does not exist yet refuses to give.
- */
+/** `fs.watch` is silent on some filesystems, so a poll always runs too and re-arms a watcher that failed. */
 function follow(
   watched: string,
   entry: string | undefined,
@@ -86,27 +79,31 @@ function follow(
   };
 }
 
-/** Fires when one file appears, grows, or goes away; the directory is watched, so the file need not exist yet. */
+/** Watches the parent directory, so the file need not exist yet. `onLook` sees every stat, changed or not. */
 function file(
   path: string,
   onChange: () => void,
-  pollMs: number = POLL_MS
+  pollMs: number = POLL_MS,
+  onLook?: () => void
 ): () => void {
-  const check = tracker(path, onChange);
+  const track = tracker(path, onChange);
+  const check = (): void => {
+    track();
+    onLook?.();
+  };
   return follow(dirname(path), basename(path), check, check, pollMs);
 }
 
-/** Fires when a directory gains or loses an entry, or when anything inside it is written. */
+/** Fires on entries added, removed or written. The poll only sees adds and removes. */
 function directory(
   path: string,
   onChange: () => void,
   pollMs: number = POLL_MS
 ): () => void {
-  // Writing a file moves nothing on the directory holding it, so the poll answers only for entries coming and going.
   return follow(path, undefined, onChange, tracker(path, onChange), pollMs);
 }
 
-/** The directories directly inside `path`, or none when it does not exist. */
+/** Empty when `path` is missing. */
 function subdirectories(path: string): readonly string[] {
   try {
     return readdirSync(path, { withFileTypes: true })
@@ -117,5 +114,4 @@ function subdirectories(path: string): readonly string[] {
   }
 }
 
-/** Watching paths other processes write: an `fs.watch` that may do nothing, backed by a poll that always does. */
 export const FileWatch = { file, directory, subdirectories };

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

@@ -26,7 +26,6 @@ function formatElapsed(ms: number): string {
       : `${seconds}s`;
 }
 
-/** How full the context window reads, as a verdict each frontend colours. */
 export type ContextFill = "ok" | "warn" | "full";
 
 function contextFill(percent: number): ContextFill {
@@ -46,7 +45,7 @@ function scaleBytes(total: number): readonly [string, string] {
   return [value.toFixed(2).replace(/\.?0+$/u, ""), unit];
 }
 
-/** A byte count as a person reads it, unit spaced: `40 bytes`, `240 KB`, `1.5 MB`. */
+/** `40 bytes`, `240 KB`, `1.5 MB`. */
 function bytes(total: number): string {
   if (total < 1024) {
     return `${total} bytes`;
@@ -55,7 +54,7 @@ function bytes(total: number): string {
   return `${value} ${unit}`;
 }
 
-/** The same count where a title has no room for the space: `40B`, `240KB`, `1.5MB`. */
+/** `40B`, `240KB`, `1.5MB`. */
 function bytesCompact(total: number): string {
   if (total < 1024) {
     return `${total}B`;