@aaroncql/pim-agent 0.0.1 → 0.2.0

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

@@ -1,263 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { mkdtemp, mkdir, rm, symlink, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import {
-  loadAbsolute,
-  loadRelative,
-  type GitSpawnResult,
-  type GitSpawner,
-} from "./catalog";
-
-let workspace: string;
-
-beforeEach(async () => {
-  workspace = await mkdtemp(join(tmpdir(), "pim-file-catalog-"));
-});
-
-afterEach(async () => {
-  await rm(workspace, { force: true, recursive: true });
-});
-
-const failingSpawner: GitSpawner = async () => ({
-  exitCode: 1,
-  stdout: "",
-});
-
-const succeedingSpawner = (files: readonly string[]): GitSpawner => {
-  return async () => ({
-    exitCode: 0,
-    stdout: files.join("\n"),
-  });
-};
-
-describe("loadRelative — fast path (git ls-files)", () => {
-  test("returns the listed files as forward-slash relative paths", async () => {
-    const candidates = await loadRelative({
-      root: workspace,
-      gitSpawner: succeedingSpawner([
-        "src/foo.ts",
-        "src/bar/baz.ts",
-        "README.md",
-      ]),
-    });
-
-    const paths = candidates.map((c) => c.displayPath);
-    expect(paths).toContain("README.md");
-    expect(paths).toContain("src/foo.ts");
-    expect(paths).toContain("src/bar/baz.ts");
-    for (const candidate of candidates) {
-      expect(candidate.isDirectory).toBe(false);
-      expect(candidate.insertPath).toBe(candidate.displayPath);
-      expect(candidate.matchHaystack).toBe(candidate.displayPath);
-    }
-  });
-
-  test("sorts ascending by relative path", async () => {
-    const candidates = await loadRelative({
-      root: workspace,
-      gitSpawner: succeedingSpawner(["zeta.ts", "alpha.ts", "mu.ts"]),
-    });
-
-    expect(candidates.map((c) => c.displayPath)).toEqual([
-      "alpha.ts",
-      "mu.ts",
-      "zeta.ts",
-    ]);
-  });
-
-  test("limit truncates after sort", async () => {
-    const candidates = await loadRelative({
-      root: workspace,
-      gitSpawner: succeedingSpawner(["c.ts", "a.ts", "b.ts", "d.ts"]),
-      limit: 2,
-    });
-
-    expect(candidates.map((c) => c.displayPath)).toEqual(["a.ts", "b.ts"]);
-  });
-});
-
-describe("loadRelative — fallback (Bun.Glob)", () => {
-  test("walks the directory and skips gitignored entries", async () => {
-    await writeFile(join(workspace, ".gitignore"), "ignored.txt\n");
-    await writeFile(join(workspace, "kept.ts"), "kept");
-    await writeFile(join(workspace, "ignored.txt"), "ignored");
-    await mkdir(join(workspace, "nested"), { recursive: true });
-    await writeFile(join(workspace, "nested", "deep.ts"), "deep");
-    await mkdir(join(workspace, "node_modules"), { recursive: true });
-    await writeFile(join(workspace, "node_modules", "junk.js"), "junk");
-
-    const candidates = await loadRelative({
-      root: workspace,
-      gitSpawner: failingSpawner,
-    });
-
-    const paths = candidates.map((c) => c.displayPath);
-    expect(paths).toContain("kept.ts");
-    expect(paths).toContain("nested/deep.ts");
-    expect(paths).not.toContain("ignored.txt");
-    expect(paths.some((p) => p.includes("node_modules"))).toBe(false);
-  });
-
-  test("empty workspace produces an empty list", async () => {
-    const candidates = await loadRelative({
-      root: workspace,
-      gitSpawner: failingSpawner,
-    });
-
-    expect(candidates).toEqual([]);
-  });
-});
-
-describe("loadRelative — coalescing", () => {
-  test("two concurrent calls with the same root share one spawn", async () => {
-    let invocations = 0;
-    const spawner: GitSpawner = async () => {
-      invocations += 1;
-      await new Promise((resolveSleep) => setTimeout(resolveSleep, 10));
-      return { exitCode: 0, stdout: "x.ts\n" } satisfies GitSpawnResult;
-    };
-
-    const [a, b] = await Promise.all([
-      loadRelative({ root: workspace, gitSpawner: spawner }),
-      loadRelative({ root: workspace, gitSpawner: spawner }),
-    ]);
-
-    expect(invocations).toBe(1);
-    expect(a).toBe(b);
-  });
-
-  test("subsequent call after settle re-runs the spawner", async () => {
-    let invocations = 0;
-    const spawner: GitSpawner = async () => {
-      invocations += 1;
-      return { exitCode: 0, stdout: "x.ts\n" };
-    };
-
-    await loadRelative({ root: workspace, gitSpawner: spawner });
-    await loadRelative({ root: workspace, gitSpawner: spawner });
-
-    expect(invocations).toBe(2);
-  });
-});
-
-describe("loadAbsolute", () => {
-  test("anchor at exact directory lists its children", async () => {
-    await mkdir(join(workspace, "sub"), { recursive: true });
-    await writeFile(join(workspace, "sub", "alpha.ts"), "a");
-    await writeFile(join(workspace, "sub", "beta.ts"), "b");
-    await mkdir(join(workspace, "sub", "child"), { recursive: true });
-
-    const result = await loadAbsolute({
-      query: `${join(workspace, "sub")}/`,
-    });
-
-    expect(result.residualQuery).toBe("");
-    const names = result.candidates.map((c) => c.matchHaystack);
-    expect(names).toEqual(["child", "alpha.ts", "beta.ts"]);
-    const child = result.candidates.find((c) => c.matchHaystack === "child");
-    expect(child?.isDirectory).toBe(true);
-    const alpha = result.candidates.find((c) => c.matchHaystack === "alpha.ts");
-    expect(alpha?.isDirectory).toBe(false);
-    expect(alpha?.insertPath).toBe(join(workspace, "sub", "alpha.ts"));
-  });
-
-  test("anchor at deepest existing prefix produces residual", async () => {
-    await mkdir(join(workspace, "sub"), { recursive: true });
-    await writeFile(join(workspace, "sub", "partial.ts"), "p");
-
-    const result = await loadAbsolute({
-      query: `${join(workspace, "sub")}/parti`,
-    });
-
-    expect(result.residualQuery).toBe("parti");
-    expect(result.candidates.map((c) => c.matchHaystack)).toEqual([
-      "partial.ts",
-    ]);
-  });
-
-  test("walks past a file that is an exact prefix to the parent directory", async () => {
-    await mkdir(join(workspace, "etc"), { recursive: true });
-    await writeFile(join(workspace, "etc", "passwd"), "fake");
-
-    const result = await loadAbsolute({
-      query: `${join(workspace, "etc", "passwd")}/foo`,
-    });
-
-    expect(result.residualQuery).toBe("passwd/foo");
-    expect(result.candidates.map((c) => c.matchHaystack)).toEqual(["passwd"]);
-  });
-
-  test("normalizes .. segments before walking", async () => {
-    await mkdir(join(workspace, "alpha"), { recursive: true });
-    await writeFile(join(workspace, "alpha", "x.ts"), "x");
-    await mkdir(join(workspace, "beta"), { recursive: true });
-
-    const result = await loadAbsolute({
-      query: `${join(workspace, "beta")}/../alpha/`,
-    });
-
-    expect(result.residualQuery).toBe("");
-    expect(result.candidates.map((c) => c.matchHaystack)).toEqual(["x.ts"]);
-  });
-
-  test("nonexistent suffix walks up to the deepest existing ancestor", async () => {
-    await mkdir(join(workspace, "real"), { recursive: true });
-    await writeFile(join(workspace, "real", "kept.ts"), "k");
-
-    const result = await loadAbsolute({
-      query: `${join(workspace, "real")}/nope/foo`,
-    });
-
-    expect(result.residualQuery).toBe("nope/foo");
-    expect(result.candidates.map((c) => c.matchHaystack)).toEqual(["kept.ts"]);
-  });
-
-  test("symlinked directory is treated as a directory anchor", async () => {
-    await mkdir(join(workspace, "real"), { recursive: true });
-    await writeFile(join(workspace, "real", "x.ts"), "x");
-    await symlink(join(workspace, "real"), join(workspace, "link"));
-
-    const result = await loadAbsolute({
-      query: `${join(workspace, "link")}/`,
-    });
-
-    expect(result.candidates.map((c) => c.matchHaystack)).toEqual(["x.ts"]);
-  });
-
-  test("dotfiles hidden unless residual starts with a dot", async () => {
-    await mkdir(join(workspace, "sub"), { recursive: true });
-    await writeFile(join(workspace, "sub", "visible.ts"), "v");
-    await writeFile(join(workspace, "sub", ".hidden"), "h");
-
-    const without = await loadAbsolute({
-      query: `${join(workspace, "sub")}/`,
-    });
-    expect(without.candidates.map((c) => c.matchHaystack)).toEqual([
-      "visible.ts",
-    ]);
-
-    const withDot = await loadAbsolute({
-      query: `${join(workspace, "sub")}/.h`,
-    });
-    expect(withDot.candidates.map((c) => c.matchHaystack)).toContain(".hidden");
-    expect(withDot.residualQuery).toBe(".h");
-  });
-
-  test("directories sort before files within the same anchor", async () => {
-    await mkdir(join(workspace, "sub"), { recursive: true });
-    await writeFile(join(workspace, "sub", "z-file.ts"), "z");
-    await mkdir(join(workspace, "sub", "a-dir"), { recursive: true });
-    await writeFile(join(workspace, "sub", "a-file.ts"), "a");
-
-    const result = await loadAbsolute({
-      query: `${join(workspace, "sub")}/`,
-    });
-
-    expect(result.candidates.map((c) => c.matchHaystack)).toEqual([
-      "a-dir",
-      "a-file.ts",
-      "z-file.ts",
-    ]);
-  });
-});

package/src/extensions/file-picker/index.test.ts

@@ -1,168 +0,0 @@
-import { expect, test } from "bun:test";
-import { mkdtemp, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import type { AutocompleteProvider } from "@earendil-works/pi-tui";
-import type { FileCandidate } from "./catalog";
-import { createFilePickerProviderFactory } from "./index";
-
-const file = (path: string): FileCandidate => ({
-  insertPath: path,
-  displayPath: path,
-  matchHaystack: path,
-  isDirectory: false,
-});
-
-const currentProvider: AutocompleteProvider = {
-  async getSuggestions() {
-    return null;
-  },
-
-  applyCompletion(lines, cursorLine, cursorCol) {
-    return { lines, cursorLine, cursorCol };
-  },
-};
-
-const autocompleteOptions = (): { readonly signal: AbortSignal } => ({
-  signal: new AbortController().signal,
-});
-
-const flushPromises = async (): Promise<void> => {
-  await Promise.resolve();
-  await Promise.resolve();
-};
-
-test("relative @ autocomplete refreshes in the background after using the session cache", async () => {
-  let catalog: readonly FileCandidate[] = [file("old.ts")];
-  let loads = 0;
-  const factory = createFilePickerProviderFactory({
-    loadRelativeCatalog: async () => {
-      loads += 1;
-      return catalog;
-    },
-  });
-  const provider = factory(currentProvider);
-
-  await flushPromises();
-  expect(loads).toBe(1);
-
-  catalog = [file("new.ts")];
-  const stale = await provider.getSuggestions(
-    ["@new"],
-    0,
-    4,
-    autocompleteOptions()
-  );
-
-  expect(stale).toBeNull();
-  expect(loads).toBe(2);
-
-  await flushPromises();
-  const fresh = await provider.getSuggestions(
-    ["@new"],
-    0,
-    4,
-    autocompleteOptions()
-  );
-
-  expect(fresh?.items.map((item) => item.value)).toContain("@new.ts");
-});
-
-test("relative catalog cache survives provider rebuilds", async () => {
-  let catalog: readonly FileCandidate[] = [file("old.ts")];
-  const factory = createFilePickerProviderFactory({
-    loadRelativeCatalog: async () => catalog,
-  });
-  const firstProvider = factory(currentProvider);
-
-  await flushPromises();
-  catalog = [file("new.ts")];
-  await firstProvider.getSuggestions(["@new"], 0, 4, autocompleteOptions());
-  await flushPromises();
-
-  const rebuiltProvider = factory(currentProvider);
-  const fresh = await rebuiltProvider.getSuggestions(
-    ["@new"],
-    0,
-    4,
-    autocompleteOptions()
-  );
-
-  expect(fresh?.items.map((item) => item.value)).toContain("@new.ts");
-});
-
-test("relative catalog refreshes are coalesced", async () => {
-  let resolveLoad: ((catalog: readonly FileCandidate[]) => void) | undefined;
-  let loads = 0;
-  const factory = createFilePickerProviderFactory({
-    loadRelativeCatalog: () => {
-      loads += 1;
-      return new Promise((resolve) => {
-        resolveLoad = resolve;
-      });
-    },
-  });
-  const provider = factory(currentProvider);
-
-  await provider.getSuggestions(["@a"], 0, 2, autocompleteOptions());
-  await provider.getSuggestions(["@ab"], 0, 3, autocompleteOptions());
-
-  expect(loads).toBe(1);
-  resolveLoad?.([file("ab.ts")]);
-  await flushPromises();
-});
-
-test("refresh failure preserves the last good relative cache", async () => {
-  let shouldFail = false;
-  const factory = createFilePickerProviderFactory({
-    loadRelativeCatalog: async () => {
-      if (shouldFail) {
-        throw new Error("boom");
-      }
-      return [file("old.ts")];
-    },
-  });
-  const provider = factory(currentProvider);
-
-  await flushPromises();
-  shouldFail = true;
-  await provider.getSuggestions(["@old"], 0, 4, autocompleteOptions());
-  await flushPromises();
-
-  const result = await provider.getSuggestions(
-    ["@old"],
-    0,
-    4,
-    autocompleteOptions()
-  );
-
-  expect(result?.items.map((item) => item.value)).toContain("@old.ts");
-});
-
-test("absolute @ autocomplete also refreshes the relative catalog", async () => {
-  const workspace = await mkdtemp(join(tmpdir(), "pim-file-picker-absolute-"));
-  try {
-    let loads = 0;
-    const factory = createFilePickerProviderFactory({
-      loadRelativeCatalog: async () => {
-        loads += 1;
-        return [file("old.ts")];
-      },
-    });
-    const provider = factory(currentProvider);
-
-    await flushPromises();
-    expect(loads).toBe(1);
-
-    await provider.getSuggestions(
-      [`@${workspace}`],
-      0,
-      workspace.length + 1,
-      autocompleteOptions()
-    );
-
-    expect(loads).toBe(2);
-  } finally {
-    await rm(workspace, { force: true, recursive: true });
-  }
-});

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

@@ -1,94 +0,0 @@
-import { afterEach, beforeEach, expect, test } from "bun:test";
-import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import type { FileCandidate } from "./catalog";
-import { rank } from "./ranker";
-
-let workspace: string;
-
-beforeEach(async () => {
-  workspace = await mkdtemp(join(tmpdir(), "pim-file-ranker-"));
-});
-
-afterEach(async () => {
-  await rm(workspace, { force: true, recursive: true });
-});
-
-const file = (path: string): FileCandidate => ({
-  insertPath: path,
-  displayPath: path,
-  matchHaystack: path,
-  isDirectory: false,
-});
-
-test("relative query with no cache returns undefined (fallback)", async () => {
-  const result = await rank("foo", { cachedRelative: undefined });
-
-  expect(result).toBeUndefined();
-});
-
-test("relative query with cache fuzzy-ranks the cached catalog", async () => {
-  const cachedRelative: readonly FileCandidate[] = [
-    file("src/util/log.ts"),
-    file("src/util/clock.ts"),
-    file("README.md"),
-  ];
-
-  const result = await rank("clk", { cachedRelative });
-
-  expect(result).toBeDefined();
-  expect(result?.[0]?.value).toBe("src/util/clock.ts");
-});
-
-test("empty relative query returns cached catalog in given order", async () => {
-  const cachedRelative: readonly FileCandidate[] = [
-    file("a.ts"),
-    file("b.ts"),
-    file("c.ts"),
-  ];
-
-  const result = await rank("", {
-    cachedRelative,
-    limit: 2,
-  });
-
-  expect(result?.map((item) => item.value)).toEqual(["a.ts", "b.ts"]);
-});
-
-test("absolute query lists the resolved directory", async () => {
-  await mkdir(join(workspace, "sub"), { recursive: true });
-  await writeFile(join(workspace, "sub", "alpha.ts"), "a");
-  await writeFile(join(workspace, "sub", "beta.ts"), "b");
-
-  const result = await rank(`${join(workspace, "sub")}/`, {
-    cachedRelative: undefined,
-  });
-
-  expect(result?.map((item) => item.label)).toEqual(["alpha.ts", "beta.ts"]);
-});
-
-test("absolute query with residual fuzzy-ranks within the directory", async () => {
-  await mkdir(join(workspace, "sub"), { recursive: true });
-  await writeFile(join(workspace, "sub", "alpha.ts"), "a");
-  await writeFile(join(workspace, "sub", "beta.ts"), "b");
-
-  const result = await rank(`${join(workspace, "sub")}/be`, {
-    cachedRelative: undefined,
-  });
-
-  expect(result?.[0]?.label).toBe("beta.ts");
-});
-
-test("directory candidates carry trailing slash in value and label", async () => {
-  await mkdir(join(workspace, "sub"), { recursive: true });
-  await mkdir(join(workspace, "sub", "child"), { recursive: true });
-
-  const result = await rank(`${join(workspace, "sub")}/`, {
-    cachedRelative: undefined,
-  });
-
-  const child = result?.find((item) => item.label === "child/");
-  expect(child).toBeDefined();
-  expect(child?.value.endsWith("/child/")).toBe(true);
-});

package/src/extensions/footer/git.test.ts

@@ -1,76 +0,0 @@
-import { mkdtemp, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterAll, describe, expect, test } from "bun:test";
-import { EMPTY_GIT, fetchGitStatus, parseGitStatus } from "./git";
-
-const tempRoots: string[] = [];
-
-const tempRoot = async (): Promise<string> => {
-  const root = await mkdtemp(join(tmpdir(), "pim-footer-git-"));
-  tempRoots.push(root);
-  return root;
-};
-
-afterAll(async () => {
-  await Promise.all(
-    tempRoots.map((root) => rm(root, { force: true, recursive: true }))
-  );
-});
-
-describe("parseGitStatus", () => {
-  test("parses clean branch status", () => {
-    expect(
-      parseGitStatus(
-        [
-          "# branch.oid 123456",
-          "# branch.head main",
-          "# branch.upstream origin/main",
-          "# branch.ab +0 -0",
-        ].join("\n")
-      )
-    ).toEqual({
-      branch: "main",
-      dirty: false,
-      ahead: 0,
-      behind: 0,
-    });
-  });
-
-  test("parses dirty state and ahead/behind counts", () => {
-    expect(
-      parseGitStatus(
-        [
-          "# branch.oid 123456",
-          "# branch.head feature/footer",
-          "# branch.upstream origin/feature/footer",
-          "# branch.ab +12 -3",
-          "1 .M N... 100644 100644 100644 abc abc src/file.ts",
-          "? scratch.txt",
-        ].join("\n")
-      )
-    ).toEqual({
-      branch: "feature/footer",
-      dirty: true,
-      ahead: 12,
-      behind: 3,
-    });
-  });
-
-  test("labels detached heads explicitly", () => {
-    expect(parseGitStatus("# branch.head (detached)\n")).toEqual({
-      branch: "detached",
-      dirty: false,
-      ahead: 0,
-      behind: 0,
-    });
-  });
-});
-
-describe("fetchGitStatus", () => {
-  test("returns empty git state outside a git repository", async () => {
-    const root = await tempRoot();
-
-    expect(await fetchGitStatus(root)).toEqual(EMPTY_GIT);
-  });
-});