@aaroncql/pim-agent 0.0.1 → 0.2.0

package/src/extensions/bash/run.test.ts

@@ -1,262 +0,0 @@
-import { afterAll, beforeAll, describe, expect, test } from "bun:test";
-import { mkdtemp, rm, stat } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { SpillCache } from "../../shared/SpillCache";
-import { killAllActiveBashGroups, runBashCommand } from "./run";
-import {
-  DRAIN_GRACE_MS,
-  KILL_GRACE_MS,
-  STREAM_HEAD_BYTES,
-  STREAM_TAIL_BYTES,
-} from "./schema";
-
-let previousPimHomeDir: string | undefined;
-let testPimHomeDir: string | undefined;
-
-beforeAll(async () => {
-  previousPimHomeDir = process.env.PIM_HOME_DIR;
-  testPimHomeDir = await mkdtemp(join(tmpdir(), "pim-bash-home-"));
-  process.env.PIM_HOME_DIR = testPimHomeDir;
-});
-
-afterAll(async () => {
-  if (previousPimHomeDir === undefined) {
-    delete process.env.PIM_HOME_DIR;
-  } else {
-    process.env.PIM_HOME_DIR = previousPimHomeDir;
-  }
-  if (testPimHomeDir) {
-    await rm(testPimHomeDir, { recursive: true, force: true });
-  }
-});
-
-function shellQuote(value: string): string {
-  return `'${value.replaceAll("'", `'"'"'`)}'`;
-}
-
-async function waitForFile(path: string, timeoutMs: number): Promise<void> {
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() < deadline) {
-    if (await Bun.file(path).exists()) {
-      return;
-    }
-    await Bun.sleep(10);
-  }
-  throw new Error(`Timed out waiting for ${path}`);
-}
-
-async function waitForNoProcess(
-  marker: string,
-  timeoutMs: number
-): Promise<void> {
-  const deadline = Date.now() + timeoutMs;
-  while (true) {
-    const probe = Bun.spawnSync({ cmd: ["pgrep", "-f", marker] });
-    if (probe.exitCode !== 0) {
-      return;
-    }
-    if (Date.now() >= deadline) {
-      throw new Error(`Process still running for marker ${marker}`);
-    }
-    await Bun.sleep(25);
-  }
-}
-
-describe("runBashCommand (integration)", () => {
-  test("captures stdout from a successful command", async () => {
-    const r = await runBashCommand(
-      "echo hello",
-      5000,
-      undefined,
-      process.cwd()
-    );
-    expect(r.exitCode).toBe(0);
-    expect(r.aborted).toBe(false);
-    expect(r.timedOut).toBe(false);
-    expect(r.stdout.text.trim()).toBe("hello");
-    expect(r.stderr.totalBytes).toBe(0);
-  });
-
-  test("captures stderr and non-zero exit", async () => {
-    const r = await runBashCommand(
-      "echo oops 1>&2; exit 3",
-      5000,
-      undefined,
-      process.cwd()
-    );
-    expect(r.exitCode).toBe(3);
-    expect(r.stderr.text.trim()).toBe("oops");
-  });
-
-  test("respects cwd", async () => {
-    const r = await runBashCommand("pwd", 5000, undefined, "/tmp");
-    expect(r.exitCode).toBe(0);
-    expect(r.stdout.text.trim()).toBe("/tmp");
-  });
-
-  test("times out and reports timedOut", async () => {
-    const r = await runBashCommand("sleep 5", 25, undefined, process.cwd());
-    expect(r.timedOut).toBe(true);
-    expect(r.exitCode === null || r.exitCode !== 0).toBe(true);
-  });
-
-  test("aborts when signal fires", async () => {
-    const ctrl = new AbortController();
-    const promise = runBashCommand("sleep 5", 5000, ctrl.signal, process.cwd());
-    ctrl.abort();
-    const r = await promise;
-    expect(r.aborted).toBe(true);
-  });
-
-  test("returns promptly when a backgrounded child inherits the pipe", async () => {
-    const startedAt = Date.now();
-    const r = await runBashCommand(
-      "nohup sleep 47 > /dev/null 2>&1 & disown; echo done",
-      5000,
-      undefined,
-      process.cwd()
-    );
-    const elapsed = Date.now() - startedAt;
-    expect(r.exitCode).toBe(0);
-    expect(r.timedOut).toBe(false);
-    expect(r.stdout.text.trim()).toBe("done");
-    expect(elapsed).toBeLessThan(2000);
-    // clean up the orphaned sleep so it doesn't linger
-    try {
-      Bun.spawnSync({ cmd: ["pkill", "-f", "sleep 47"] });
-    } catch {}
-  });
-
-  test("timeout kills the whole process group", async () => {
-    const marker = `pim-test-timeout-${Date.now()}`;
-    const startedAt = Date.now();
-    const r = await runBashCommand(
-      `bash -c ${shellQuote(`exec -a ${marker} sleep 60`)}`,
-      50,
-      undefined,
-      process.cwd()
-    );
-    const elapsed = Date.now() - startedAt;
-    expect(r.timedOut).toBe(true);
-    expect(r.exitCode === null || r.exitCode !== 0).toBe(true);
-    expect(elapsed).toBeLessThan(KILL_GRACE_MS + 2000);
-    await waitForNoProcess(marker, KILL_GRACE_MS + 500);
-  });
-
-  test("does not crash on timeout while drains still hold readers", async () => {
-    // Regression: stream.cancel() on a locked stream rejects (Bun throws
-    // synchronously). Drains run fire-and-forget, so when a quiet command
-    // times out (no output → drain blocked on read), the finally hits
-    // cancel before drain has released. Unhandled rejection would crash Bun.
-    const rejections: unknown[] = [];
-    const onRejection = (err: unknown) => rejections.push(err);
-    process.on("unhandledRejection", onRejection);
-    try {
-      const r = await runBashCommand("sleep 5", 25, undefined, process.cwd());
-      expect(r.timedOut).toBe(true);
-      await Bun.sleep(25);
-      expect(rejections).toEqual([]);
-    } finally {
-      process.off("unhandledRejection", onRejection);
-    }
-  });
-
-  test("bounded drain returns even when a daemon escapes our process group", async () => {
-    // A child that calls setsid itself leaves our pgid and survives killGroup.
-    // If it keeps the pipe open, drain would block forever; the DRAIN_GRACE_MS
-    // bound forces us to return anyway. The marker lets us clean up after.
-    const marker = `pim-test-detached-${Date.now()}`;
-    const startedAt = Date.now();
-    const r = await runBashCommand(
-      `setsid bash -c 'sleep 60; echo ${marker}' > /tmp/${marker}.out 2>&1 < /dev/null & disown; echo done`,
-      5000,
-      undefined,
-      process.cwd()
-    );
-    const elapsed = Date.now() - startedAt;
-    expect(r.exitCode).toBe(0);
-    expect(r.stdout.text.trim()).toBe("done");
-    expect(elapsed).toBeLessThan(DRAIN_GRACE_MS + 2000);
-    try {
-      Bun.spawnSync({ cmd: ["pkill", "-f", marker] });
-      Bun.spawnSync({ cmd: ["rm", "-f", `/tmp/${marker}.out`] });
-    } catch {}
-  });
-
-  test("killAllActiveBashGroups sweeps in-flight subtrees", async () => {
-    const id = Date.now();
-    const marker = `/tmp/pim-test-active-${id}.marker`;
-    const ready = `/tmp/pim-test-active-${id}.ready`;
-    const processMarker = `pim-test-active-${id}`;
-    const pending = runBashCommand(
-      `touch ${shellQuote(ready)}; bash -c ${shellQuote(`exec -a ${processMarker} sleep 30`)} && touch ${shellQuote(marker)}`,
-      30_000,
-      undefined,
-      process.cwd()
-    );
-    try {
-      await waitForFile(ready, 1000);
-      killAllActiveBashGroups("SIGTERM");
-      const result = await pending;
-      expect(result.exitCode === null || result.exitCode !== 0).toBe(true);
-      await waitForNoProcess(processMarker, KILL_GRACE_MS + 500);
-      expect(await Bun.file(marker).exists()).toBe(false);
-    } finally {
-      Bun.spawnSync({ cmd: ["rm", "-f", marker, ready] });
-    }
-  });
-
-  test("truncates very large stdout", async () => {
-    const totalBytes = STREAM_HEAD_BYTES + STREAM_TAIL_BYTES + 1000;
-    const r = await runBashCommand(
-      `head -c ${totalBytes} /dev/zero | tr '\\0' 'A'`,
-      5000,
-      undefined,
-      process.cwd()
-    );
-    expect(r.exitCode).toBe(0);
-    expect(r.stdout.totalBytes).toBe(totalBytes);
-    expect(r.stdout.truncated).toBe(true);
-    expect(r.stdout.text).toContain("bytes truncated");
-  });
-
-  test("spills full stdout to ~/.pim/cache when truncated", async () => {
-    const totalBytes = STREAM_HEAD_BYTES + STREAM_TAIL_BYTES + 4096;
-    const r = await runBashCommand(
-      `head -c ${totalBytes} /dev/zero | tr '\\0' 'A'`,
-      5000,
-      undefined,
-      process.cwd()
-    );
-    try {
-      expect(r.exitCode).toBe(0);
-      expect(r.stdout.truncated).toBe(true);
-      expect(r.stdout.path).toBeTruthy();
-      expect(r.stdout.path!.startsWith(join(SpillCache.dir(), "bash-"))).toBe(
-        true
-      );
-      expect(r.stdout.path!.endsWith(".out")).toBe(true);
-      const cacheMode = (await stat(SpillCache.dir())).mode & 0o777;
-      const spillMode = (await stat(r.stdout.path!)).mode & 0o777;
-      expect(cacheMode).toBe(0o700);
-      expect(spillMode).toBe(0o600);
-      const spilled = await Bun.file(r.stdout.path!).text();
-      expect(spilled.length).toBe(totalBytes);
-      expect(spilled).toBe("A".repeat(totalBytes));
-    } finally {
-      if (r.stdout.path) {
-        try {
-          Bun.spawnSync({ cmd: ["rm", "-f", r.stdout.path] });
-        } catch {}
-      }
-    }
-  });
-
-  test("omits spill path when stream is empty", async () => {
-    const r = await runBashCommand("true", 5000, undefined, process.cwd());
-    expect(r.exitCode).toBe(0);
-    expect(r.stdout.path).toBeNull();
-    expect(r.stderr.path).toBeNull();
-  });
-});

package/src/extensions/command-picker/ranker.test.ts

@@ -1,46 +0,0 @@
-import { expect, test } from "bun:test";
-import type { AutocompleteItem } from "@earendil-works/pi-tui";
-import { rank } from "./ranker";
-
-const item = (name: string, description?: string): AutocompleteItem => ({
-  value: name,
-  label: name,
-  ...(description !== undefined && { description }),
-});
-
-test("empty query returns items alphabetically by label", () => {
-  const items = rank("", [
-    item("rename", "Rename the session."),
-    item("clear", "Clear the session."),
-    item("help", "Show help."),
-  ]);
-
-  expect(items.map((i) => i.value)).toEqual(["clear", "help", "rename"]);
-});
-
-test("query ranks fuzzy matches by score", () => {
-  const items = rank("cl", [
-    item("rename", "Rename the session."),
-    item("clear", "Clear the session."),
-    item("help", "Show help."),
-  ]);
-
-  expect(items[0]?.value).toBe("clear");
-});
-
-test("matches against description when label doesn't contain query", () => {
-  const items = rank("rename", [
-    item("noop", "fully unrelated"),
-    item("x", "rename the session"),
-  ]);
-
-  expect(items[0]?.value).toBe("x");
-});
-
-test("limit caps the returned items", () => {
-  const items = rank("", [item("c"), item("a"), item("b"), item("d")], {
-    limit: 2,
-  });
-
-  expect(items.map((i) => i.value)).toEqual(["a", "b"]);
-});

package/src/extensions/edit/edit.test.ts

@@ -1,285 +0,0 @@
-import {
-  chmod,
-  link,
-  mkdtemp,
-  readFile,
-  rm,
-  stat,
-  symlink,
-  writeFile,
-} from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterAll, describe, expect, test } from "bun:test";
-import { editFile, formatEditSummary } from "./edit";
-import type { RawEdit } from "./schema";
-
-const tempRoots: string[] = [];
-
-const tempRoot = async (): Promise<string> => {
-  const root = await mkdtemp(join(tmpdir(), "pim-edit-tool-"));
-  tempRoots.push(root);
-  return root;
-};
-
-afterAll(async () => {
-  await Promise.all(
-    tempRoots.map((root) => rm(root, { force: true, recursive: true }))
-  );
-});
-
-describe("editFile", () => {
-  test("applies exact single edit", async () => {
-    const root = await tempRoot();
-    const path = join(root, "notes.txt");
-    await writeFile(path, "alpha\nbeta\ngamma", "utf8");
-
-    const outcome = await editFile(path, [
-      { oldString: "beta", newString: "delta" },
-    ]);
-
-    expect(await readFile(path, "utf8")).toBe("alpha\ndelta\ngamma");
-    expect(outcome.editCount).toBe(1);
-    expect(outcome.noops).toEqual([]);
-    expect(outcome.resolvedEdits[0]?.strategy).toBe("simple");
-    expect(formatEditSummary(path, outcome)).toBe(
-      `1 edit made to ${path}: lines 2.`
-    );
-  });
-
-  test("applies multi-edit batch against pre-batch content", async () => {
-    const root = await tempRoot();
-    const path = join(root, "notes.txt");
-    await writeFile(path, "alpha\nbeta\ngamma\ndelta", "utf8");
-
-    await editFile(path, [
-      { oldString: "beta", newString: "BETA" },
-      { oldString: "delta", newString: "DELTA" },
-    ]);
-
-    expect(await readFile(path, "utf8")).toBe("alpha\nBETA\ngamma\nDELTA");
-  });
-
-  test("rejects sequential transformations in one batch", async () => {
-    const root = await tempRoot();
-    const path = join(root, "notes.txt");
-    await writeFile(path, "alpha\nbeta", "utf8");
-
-    await expect(
-      editFile(path, [
-        { oldString: "beta", newString: "delta" },
-        { oldString: "delta", newString: "omega" },
-      ])
-    ).rejects.toThrow(/oldString was not found/);
-    expect(await readFile(path, "utf8")).toBe("alpha\nbeta");
-  });
-
-  test("rejects overlapping resolved ranges", async () => {
-    const root = await tempRoot();
-    const path = join(root, "notes.txt");
-    await writeFile(path, "alpha\nbeta\ngamma", "utf8");
-
-    await expect(
-      editFile(path, [
-        { oldString: "beta\ngamma", newString: "merged" },
-        { oldString: "gamma", newString: "changed" },
-      ])
-    ).rejects.toThrow(/target overlapping byte ranges/);
-    expect(await readFile(path, "utf8")).toBe("alpha\nbeta\ngamma");
-  });
-
-  test("replaceAll replaces all occurrences and lists every range", async () => {
-    const root = await tempRoot();
-    const path = join(root, "notes.txt");
-    await writeFile(path, "foo\nbar\nfoo", "utf8");
-
-    const outcome = await editFile(path, [
-      { oldString: "foo", newString: "baz", replaceAll: true },
-    ]);
-
-    expect(await readFile(path, "utf8")).toBe("baz\nbar\nbaz");
-    expect(outcome.ranges).toEqual(["1", "3"]);
-    expect(formatEditSummary(path, outcome)).toBe(
-      `1 edit made to ${path}: lines 1 and 3.`
-    );
-  });
-
-  test("replaceAll overlap with another edit is rejected", async () => {
-    const root = await tempRoot();
-    const path = join(root, "notes.txt");
-    await writeFile(path, "foo\nbar\nfoo", "utf8");
-
-    await expect(
-      editFile(path, [
-        { oldString: "foo", newString: "baz", replaceAll: true },
-        { oldString: "foo\nbar", newString: "merged" },
-      ])
-    ).rejects.toThrow(/target overlapping byte ranges/);
-  });
-
-  test("rejects duplicate edits", async () => {
-    const root = await tempRoot();
-    const path = join(root, "notes.txt");
-    await writeFile(path, "alpha\nbeta", "utf8");
-
-    const edit: RawEdit = { oldString: "beta", newString: "delta" };
-
-    await expect(editFile(path, [edit, edit])).rejects.toThrow(
-      /Edits 0 and 1 are identical/
-    );
-  });
-
-  test("rejects all-noop fuzzy batches and tracks partial noops", async () => {
-    const root = await tempRoot();
-    const noopPath = join(root, "noop.txt");
-    const partialPath = join(root, "partial.txt");
-    await writeFile(noopPath, "  beta", "utf8");
-    await writeFile(partialPath, "alpha\n  beta", "utf8");
-
-    await expect(
-      editFile(noopPath, [{ oldString: "beta ", newString: "  beta" }])
-    ).rejects.toThrow(/All edits were no-ops/);
-
-    const outcome = await editFile(partialPath, [
-      { oldString: "alpha", newString: "ALPHA" },
-      { oldString: "beta ", newString: "  beta" },
-    ]);
-
-    expect(await readFile(partialPath, "utf8")).toBe("ALPHA\n  beta");
-    expect(outcome.noops).toEqual([{ index: 1, range: "2" }]);
-  });
-
-  test("reports closest regions when oldString is not found", async () => {
-    const root = await tempRoot();
-    const path = join(root, "notes.txt");
-    await writeFile(path, "alpha\nbeta\ngamma", "utf8");
-
-    await expect(
-      editFile(path, [{ oldString: "betx", newString: "delta" }])
-    ).rejects.toThrow(/oldString was not found[\s\S]*lines 2/);
-  });
-
-  test("reports bare not found when nothing is close", async () => {
-    const root = await tempRoot();
-    const path = join(root, "notes.txt");
-    await writeFile(path, "aaaa\nbbbb", "utf8");
-
-    await expect(
-      editFile(path, [{ oldString: "zzzz", newString: "delta" }])
-    ).rejects.toThrow("oldString was not found in the file.");
-  });
-
-  test("rejects multiple matches without replaceAll", async () => {
-    const root = await tempRoot();
-    const path = join(root, "notes.txt");
-    await writeFile(path, "foo\nbar\nfoo", "utf8");
-
-    await expect(
-      editFile(path, [{ oldString: "foo", newString: "baz" }])
-    ).rejects.toThrow(/matched multiple regions/);
-  });
-
-  test("rejects escape drift after fuzzy match", async () => {
-    const root = await tempRoot();
-    const path = join(root, "notes.txt");
-    await writeFile(path, "  beta", "utf8");
-
-    await expect(
-      editFile(path, [{ oldString: "beta ", newString: "new\\nvalue" }])
-    ).rejects.toThrow(/newString contains literal escape text/);
-  });
-
-  test("preserves UTF-8 BOM when editing", async () => {
-    const root = await tempRoot();
-    const path = join(root, "bom.txt");
-    await writeFile(path, "\uFEFFalpha\nbeta", "utf8");
-
-    await editFile(path, [{ oldString: "beta", newString: "delta" }]);
-
-    const bytes = await Bun.file(path).bytes();
-    expect(Array.from(bytes.slice(0, 3))).toEqual([0xef, 0xbb, 0xbf]);
-    expect(await readFile(path, "utf8")).toBe("\uFEFFalpha\ndelta");
-  });
-
-  test("preserves CRLF line endings when editing", async () => {
-    const root = await tempRoot();
-    const path = join(root, "crlf.txt");
-    await writeFile(path, "alpha\r\nbeta\r\n", "utf8");
-
-    await editFile(path, [{ oldString: "beta", newString: "delta" }]);
-
-    expect(await readFile(path, "utf8")).toBe("alpha\r\ndelta\r\n");
-  });
-
-  test("updates symlink targets and preserves hard-link inodes plus mode", async () => {
-    const root = await tempRoot();
-    const target = join(root, "target.txt");
-    const linked = join(root, "linked.txt");
-    const alias = join(root, "alias.txt");
-
-    await writeFile(target, "alpha\nbeta", "utf8");
-    await chmod(target, 0o640);
-    await link(target, linked);
-    await symlink(target, alias);
-
-    const before = await stat(target);
-
-    await editFile(alias, [{ oldString: "beta", newString: "delta" }]);
-
-    const after = await stat(target);
-    expect(await readFile(target, "utf8")).toBe("alpha\ndelta");
-    expect(await readFile(linked, "utf8")).toBe("alpha\ndelta");
-    expect(after.ino).toBe(before.ino);
-    expect(Number(after.mode) & 0o777).toBe(0o640);
-  });
-
-  test("serializes concurrent edits on the same path", async () => {
-    const root = await tempRoot();
-    const path = join(root, "notes.txt");
-    await writeFile(path, "0\n", "utf8");
-
-    const concurrent = await Promise.all([
-      editFile(path, [{ oldString: "0", newString: "0\n1" }]),
-      editFile(path, [{ oldString: "0", newString: "0\n2" }]),
-      editFile(path, [{ oldString: "0", newString: "0\n3" }]),
-    ]);
-
-    const final = await readFile(path, "utf8");
-    expect(final).toContain("0");
-    expect(concurrent).toHaveLength(3);
-  });
-
-  test("buildDiff splits distant edits into separate hunks", async () => {
-    const root = await tempRoot();
-    const path = join(root, "notes.txt");
-    const lines = Array.from(
-      { length: 200 },
-      (_, index) => `line ${index + 1}`
-    );
-    await writeFile(path, lines.join("\n"), "utf8");
-
-    const outcome = await editFile(path, [
-      { oldString: "line 1\nline 2", newString: "changed 1\nline 2" },
-      { oldString: "line 199\nline 200", newString: "line 199\nchanged 200" },
-    ]);
-
-    expect(outcome.diff?.hunks).toHaveLength(2);
-    expect(formatEditSummary(path, outcome)).toBe(
-      `2 edits made to ${path}: lines 1-2 and 199-200.`
-    );
-  });
-
-  test("rejects directories and binary files", async () => {
-    const root = await tempRoot();
-    const binary = join(root, "bin.dat");
-    await Bun.write(binary, new Uint8Array([0, 1, 2, 0, 4]));
-
-    await expect(
-      editFile(root, [{ oldString: "x", newString: "y" }])
-    ).rejects.toThrow(/Path is a directory/);
-
-    await expect(
-      editFile(binary, [{ oldString: "x", newString: "y" }])
-    ).rejects.toThrow(/binary file/);
-  });
-});