@aaroncql/pim-agent 0.1.0 → 0.3.0

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

@@ -0,0 +1,43 @@
+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;
+
+/**
+ * Forgive the JSON-key choice, trust the grammar. Accepts `{input}` (canonical,
+ * handled above), `{patch}`, `{patchText}`/`{patch_text}`, or a bare string,
+ * normalizing to `{input}` and stripping the alias key so the unknown-key
+ * rejection in `Tools.wrap` passes. Validation of the actual envelope happens
+ * in the parser.
+ */
+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/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/src/extensions/bash/index.ts

@@ -37,9 +37,9 @@ export default function (pi: ExtensionAPI): void {
     name: "bash",
     label: "bash",
     description:
-      `Execute a bash command in the cwd. ` +
-      `Returns exit code, signal (if any), and stdout/stderr captured separately. ` +
-      `Prefer commands that emit only what you need; keep output as small as possible.`,
+      "Execute a bash command in the cwd. " +
+      "Returns exit code, signal (if any), and stdout/stderr captured separately. " +
+      "Prefer commands that emit only what you need; keep output as small as possible.",
     parameters: bashSchema,
     renderShell: "self",
     executionMode: "sequential",

package/src/extensions/edit/index.ts

@@ -12,7 +12,8 @@ export default function (pi: ExtensionAPI): void {
     name: "edit",
     label: "edit",
     description:
-      "Replace strings in a UTF-8 text file. Prefer edit over write for changes to existing files.",
+      "Replace strings in a UTF-8 text file. " +
+      "Prefer edit over write for changes to existing files.",
     parameters: editSchema,
     renderShell: "self",
     executionMode: "sequential",

package/src/extensions/file-picker/FilePickerSuggestionEngine.ts

@@ -0,0 +1,14 @@
+import type { AutocompleteItem } from "@earendil-works/pi-tui";
+
+export type RankFilePickerOptions = {
+  readonly limit?: number;
+  readonly signal?: AbortSignal;
+};
+
+export type FilePickerSuggestionEngine = {
+  readonly refreshRelative: () => Promise<void>;
+  readonly rank: (
+    query: string,
+    options: RankFilePickerOptions
+  ) => Promise<readonly AutocompleteItem[] | undefined>;
+};

package/src/extensions/file-picker/InProcessFilePickerSuggestionEngine.ts

@@ -0,0 +1,52 @@
+import type { AutocompleteItem } from "@earendil-works/pi-tui";
+import type { FileCandidate } from "./catalog";
+import type {
+  FilePickerSuggestionEngine,
+  RankFilePickerOptions,
+} from "./FilePickerSuggestionEngine";
+import { rank } from "./ranker";
+
+export type InProcessFilePickerSuggestionEngineOptions = {
+  readonly loadRelativeCatalog: () => Promise<readonly FileCandidate[]>;
+};
+
+export class InProcessFilePickerSuggestionEngine implements FilePickerSuggestionEngine {
+  private cachedRelative: readonly FileCandidate[] | undefined;
+  private refresh: Promise<void> | undefined;
+
+  public constructor(
+    private readonly options: InProcessFilePickerSuggestionEngineOptions
+  ) {}
+
+  public refreshRelative(): Promise<void> {
+    this.refresh ??= this.options
+      .loadRelativeCatalog()
+      .then((catalog) => {
+        this.cachedRelative = catalog;
+      })
+      .catch(() => {
+        if (this.cachedRelative === undefined) {
+          this.cachedRelative = [];
+        }
+      })
+      .finally(() => {
+        this.refresh = undefined;
+      });
+
+    return this.refresh;
+  }
+
+  public async rank(
+    query: string,
+    options: RankFilePickerOptions
+  ): Promise<readonly AutocompleteItem[] | undefined> {
+    if (options.signal?.aborted === true) {
+      return [];
+    }
+
+    return rank(query, {
+      cachedRelative: this.cachedRelative,
+      limit: options.limit,
+    });
+  }
+}

package/src/extensions/file-picker/WorkerFilePickerSuggestionEngine.ts

@@ -0,0 +1,268 @@
+import type { AutocompleteItem } from "@earendil-works/pi-tui";
+import type {
+  FilePickerSuggestionEngine,
+  RankFilePickerOptions,
+} from "./FilePickerSuggestionEngine";
+import type {
+  FilePickerWorkerRequest,
+  FilePickerWorkerResponse,
+} from "./filePickerWorkerMessages";
+
+type PendingRefresh = {
+  readonly resolve: () => void;
+};
+
+type RankRequest = {
+  readonly id: number;
+  readonly query: string;
+  readonly limit: number | undefined;
+  readonly resolve: (items: readonly AutocompleteItem[] | undefined) => void;
+  readonly reject: (error: unknown) => void;
+  readonly signal: AbortSignal | undefined;
+  readonly abortListener: (() => void) | undefined;
+  settled: boolean;
+};
+
+export class WorkerFilePickerSuggestionEngine implements FilePickerSuggestionEngine {
+  private worker: Worker | undefined;
+  private nextRequestId = 0;
+  private refresh: Promise<void> | undefined;
+  private activeRank: RankRequest | undefined;
+  private queuedRank: RankRequest | undefined;
+  private readonly pendingRefreshes = new Map<number, PendingRefresh>();
+
+  public constructor(private readonly root: string) {}
+
+  public refreshRelative(): Promise<void> {
+    this.refresh ??= this.sendRefreshRelative().finally(() => {
+      this.refresh = undefined;
+    });
+    return this.refresh;
+  }
+
+  public rank(
+    query: string,
+    options: RankFilePickerOptions
+  ): Promise<readonly AutocompleteItem[] | undefined> {
+    if (options.signal?.aborted === true) {
+      return Promise.resolve([]);
+    }
+
+    const id = this.nextRequestId++;
+    return new Promise((resolve, reject) => {
+      let request: RankRequest;
+      const abortListener = (): void => {
+        this.abortRank(request);
+      };
+      request = {
+        id,
+        query,
+        limit: options.limit,
+        resolve,
+        reject,
+        signal: options.signal,
+        abortListener: options.signal === undefined ? undefined : abortListener,
+        settled: false,
+      };
+
+      if (options.signal !== undefined) {
+        options.signal.addEventListener("abort", abortListener, { once: true });
+      }
+
+      this.enqueueRank(request);
+    });
+  }
+
+  public dispose(): void {
+    this.worker?.terminate();
+    this.worker = undefined;
+    this.failPending(new Error("file picker worker disposed"));
+  }
+
+  private enqueueRank(request: RankRequest): void {
+    if (this.activeRank === undefined) {
+      this.sendRank(request);
+      return;
+    }
+
+    this.resolveRank(this.activeRank, []);
+    if (this.queuedRank !== undefined) {
+      this.resolveRank(this.queuedRank, []);
+    }
+    this.queuedRank = request;
+  }
+
+  private sendRank(request: RankRequest): void {
+    this.activeRank = request;
+    try {
+      this.post({
+        id: request.id,
+        type: "rank",
+        query: request.query,
+        limit: request.limit,
+      });
+    } catch (error) {
+      if (this.activeRank === request) {
+        this.activeRank = undefined;
+      }
+      this.rejectRank(request, error);
+      this.sendQueuedRank();
+    }
+  }
+
+  private sendQueuedRank(): void {
+    const request = this.queuedRank;
+    if (request === undefined || this.activeRank !== undefined) {
+      return;
+    }
+
+    this.queuedRank = undefined;
+    if (request.settled) {
+      this.sendQueuedRank();
+      return;
+    }
+
+    this.sendRank(request);
+  }
+
+  private abortRank(request: RankRequest): void {
+    if (this.queuedRank === request) {
+      this.queuedRank = undefined;
+    }
+    this.resolveRank(request, []);
+  }
+
+  private resolveRank(
+    request: RankRequest,
+    items: readonly AutocompleteItem[] | undefined
+  ): void {
+    if (request.settled) {
+      return;
+    }
+
+    request.settled = true;
+    this.removeAbortListener(request);
+    request.resolve(items);
+  }
+
+  private rejectRank(request: RankRequest, error: unknown): void {
+    if (request.settled) {
+      return;
+    }
+
+    request.settled = true;
+    this.removeAbortListener(request);
+    request.reject(error);
+  }
+
+  private sendRefreshRelative(): Promise<void> {
+    const id = this.nextRequestId++;
+    return new Promise((resolve) => {
+      this.pendingRefreshes.set(id, { resolve });
+      try {
+        this.post({
+          id,
+          type: "refreshRelative",
+          root: this.root,
+        });
+      } catch {
+        this.pendingRefreshes.delete(id);
+        resolve();
+      }
+    });
+  }
+
+  private post(message: FilePickerWorkerRequest): void {
+    this.currentWorker().postMessage(message);
+  }
+
+  private currentWorker(): Worker {
+    if (this.worker !== undefined) {
+      return this.worker;
+    }
+
+    const worker = new Worker(
+      new URL("./filePickerWorker.ts", import.meta.url),
+      {
+        type: "module",
+      }
+    );
+    worker.onmessage = (
+      event: MessageEvent<FilePickerWorkerResponse>
+    ): void => {
+      this.handleMessage(event.data);
+    };
+    worker.onerror = (event): void => {
+      this.worker = undefined;
+      worker.terminate();
+      this.failPending(new Error(event.message));
+    };
+    this.worker = worker;
+    return worker;
+  }
+
+  private handleMessage(message: FilePickerWorkerResponse): void {
+    switch (message.type) {
+      case "refreshRelative":
+        this.handleRefreshRelativeMessage(message);
+        break;
+      case "rank":
+        this.handleRankMessage(message);
+        break;
+    }
+  }
+
+  private handleRefreshRelativeMessage(
+    message: Extract<
+      FilePickerWorkerResponse,
+      { readonly type: "refreshRelative" }
+    >
+  ): void {
+    const pending = this.pendingRefreshes.get(message.id);
+    if (pending === undefined) {
+      return;
+    }
+
+    this.pendingRefreshes.delete(message.id);
+    pending.resolve();
+  }
+
+  private handleRankMessage(
+    message: Extract<FilePickerWorkerResponse, { readonly type: "rank" }>
+  ): void {
+    const request = this.activeRank;
+    if (request === undefined || request.id !== message.id) {
+      return;
+    }
+
+    this.activeRank = undefined;
+    if (message.ok) {
+      this.resolveRank(request, message.items);
+    } else {
+      this.rejectRank(request, new Error(message.error));
+    }
+    this.sendQueuedRank();
+  }
+
+  private failPending(error: unknown): void {
+    for (const [id, pending] of this.pendingRefreshes) {
+      this.pendingRefreshes.delete(id);
+      pending.resolve();
+    }
+
+    if (this.activeRank !== undefined) {
+      this.rejectRank(this.activeRank, error);
+      this.activeRank = undefined;
+    }
+    if (this.queuedRank !== undefined) {
+      this.rejectRank(this.queuedRank, error);
+      this.queuedRank = undefined;
+    }
+  }
+
+  private removeAbortListener(request: RankRequest): void {
+    if (request.signal !== undefined && request.abortListener !== undefined) {
+      request.signal.removeEventListener("abort", request.abortListener);
+    }
+  }
+}

package/src/extensions/file-picker/catalog.ts

@@ -1,6 +1,6 @@
 import { readdir, stat } from "node:fs/promises";
-import { isAbsolute, join, parse, relative, resolve, sep } from "node:path";
-import { GitignoreFilter } from "../../shared/GitignoreFilter";
+import { isAbsolute, join, parse, resolve, sep } from "node:path";
+import { FileEnumerator } from "../../shared/FileEnumerator";
 import { Paths } from "../../shared/Paths";
 
 export type FileCandidate = {
@@ -27,7 +27,6 @@ export type GitSpawner = (
 
 export type LoadRelativeOptions = {
   readonly root: string;
-  readonly limit?: number;
   readonly gitSpawner?: GitSpawner;
 };
 
@@ -35,8 +34,6 @@ export type LoadAbsoluteOptions = {
   readonly query: string;
 };
 
-const DEFAULT_LIMIT = 10_000;
-
 const defaultGitSpawner: GitSpawner = async (args, options) => {
   try {
     const child = Bun.spawn(["git", ...args], {
@@ -126,16 +123,15 @@ async function runLoadRelative(
   root: string,
   options: LoadRelativeOptions
 ): Promise<readonly FileCandidate[]> {
-  const limit = options.limit ?? DEFAULT_LIMIT;
   const spawner = options.gitSpawner ?? defaultGitSpawner;
 
   const fastPath = await tryGitListFiles(root, spawner);
   if (fastPath !== undefined) {
-    return finalizeRelative(fastPath, limit);
+    return finalizeRelative(fastPath);
   }
 
   const fallback = await scanWithGlob(root);
-  return finalizeRelative(fallback, limit);
+  return finalizeRelative(fallback);
 }
 
 async function tryGitListFiles(
@@ -155,39 +151,48 @@ async function tryGitListFiles(
 }
 
 async function scanWithGlob(root: string): Promise<readonly string[]> {
-  const filter = await GitignoreFilter.for(root);
-  const glob = new Bun.Glob("**/*");
-  const matches: string[] = [];
-
-  for await (const absolutePath of glob.scan({
-    cwd: root,
-    absolute: true,
-    onlyFiles: true,
-    dot: false,
-  })) {
-    if (!filter.ignores(absolutePath)) {
-      matches.push(Paths.toForwardSlashes(relative(root, absolutePath)));
+  // FileEnumerator already returns ignore-respecting, root-relative POSIX file
+  // paths; directories are recovered from prefixes in finalizeRelative.
+  return FileEnumerator.enumerate(root, {
+    includeDotfiles: false,
+    includeIgnored: false,
+  });
+}
+
+function finalizeRelative(paths: readonly string[]): readonly FileCandidate[] {
+  const normalized = paths.map(Paths.toForwardSlashes);
+
+  // git ls-files only emits files; recover directories from their prefixes.
+  const directories = new Set<string>();
+  for (const path of normalized) {
+    for (
+      let slash = path.indexOf("/");
+      slash !== -1;
+      slash = path.indexOf("/", slash + 1)
+    ) {
+      directories.add(path.slice(0, slash));
     }
   }
 
-  return matches;
-}
+  const candidates = [
+    ...[...directories].map((path) => toRelativeCandidate(path, true)),
+    ...normalized.map((path) => toRelativeCandidate(path, false)),
+  ];
+  candidates.sort((a, b) => a.insertPath.localeCompare(b.insertPath));
 
-function finalizeRelative(
-  paths: readonly string[],
-  limit: number
-): readonly FileCandidate[] {
-  const normalized = paths.map(Paths.toForwardSlashes);
-  normalized.sort((a, b) => a.localeCompare(b));
+  return candidates;
+}
 
-  const truncated =
-    normalized.length > limit ? normalized.slice(0, limit) : normalized;
-  return truncated.map((path) => ({
+function toRelativeCandidate(
+  path: string,
+  isDirectory: boolean
+): FileCandidate {
+  return {
     insertPath: path,
     displayPath: path,
     matchHaystack: path,
-    isDirectory: false,
-  }));
+    isDirectory,
+  };
 }
 
 async function findAnchor(absolutePath: string): Promise<string> {

package/src/extensions/file-picker/filePickerWorker.ts

@@ -0,0 +1,72 @@
+import type { FileCandidate } from "./catalog";
+import { loadRelative } from "./catalog";
+import type {
+  FilePickerWorkerRequest,
+  FilePickerWorkerResponse,
+} from "./filePickerWorkerMessages";
+import { rank } from "./ranker";
+
+let cachedRelative: readonly FileCandidate[] | undefined;
+
+const toErrorMessage = (error: unknown): string => {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+};
+
+const refreshRelative = async (id: number, root: string): Promise<void> => {
+  try {
+    cachedRelative = await loadRelative({ root });
+    self.postMessage({
+      id,
+      type: "refreshRelative",
+      ok: true,
+    } satisfies FilePickerWorkerResponse);
+  } catch (error) {
+    if (cachedRelative === undefined) {
+      cachedRelative = [];
+    }
+    self.postMessage({
+      id,
+      type: "refreshRelative",
+      ok: false,
+      error: toErrorMessage(error),
+    } satisfies FilePickerWorkerResponse);
+  }
+};
+
+const rankSuggestions = async (
+  id: number,
+  query: string,
+  limit: number | undefined
+): Promise<void> => {
+  try {
+    const items = await rank(query, { cachedRelative, limit });
+    self.postMessage({
+      id,
+      type: "rank",
+      ok: true,
+      items,
+    } satisfies FilePickerWorkerResponse);
+  } catch (error) {
+    self.postMessage({
+      id,
+      type: "rank",
+      ok: false,
+      error: toErrorMessage(error),
+    } satisfies FilePickerWorkerResponse);
+  }
+};
+
+self.onmessage = (event: MessageEvent<FilePickerWorkerRequest>): void => {
+  const message = event.data;
+  switch (message.type) {
+    case "refreshRelative":
+      void refreshRelative(message.id, message.root);
+      break;
+    case "rank":
+      void rankSuggestions(message.id, message.query, message.limit);
+      break;
+  }
+};

package/src/extensions/file-picker/filePickerWorkerMessages.ts

@@ -0,0 +1,39 @@
+import type { AutocompleteItem } from "@earendil-works/pi-tui";
+
+export type FilePickerWorkerRequest =
+  | {
+      readonly id: number;
+      readonly type: "refreshRelative";
+      readonly root: string;
+    }
+  | {
+      readonly id: number;
+      readonly type: "rank";
+      readonly query: string;
+      readonly limit?: number;
+    };
+
+export type FilePickerWorkerResponse =
+  | {
+      readonly id: number;
+      readonly type: "refreshRelative";
+      readonly ok: true;
+    }
+  | {
+      readonly id: number;
+      readonly type: "refreshRelative";
+      readonly ok: false;
+      readonly error: string;
+    }
+  | {
+      readonly id: number;
+      readonly type: "rank";
+      readonly ok: true;
+      readonly items: readonly AutocompleteItem[] | undefined;
+    }
+  | {
+      readonly id: number;
+      readonly type: "rank";
+      readonly ok: false;
+      readonly error: string;
+    };