@aaroncql/pim-agent 0.0.1 → 0.1.0

package/src/extensions/grep/render.test.ts

@@ -1,269 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { OutputBudget } from "../../shared/OutputBudget";
-import type { GrepMatch } from "./grep";
-import { formatTitle, renderMatches } from "./render";
-
-const fixture: readonly GrepMatch[] = [
-  {
-    filePath: "/repo/older.ts",
-    mtime: 1_000,
-    fileLines: ["alpha"],
-    ranges: [{ startLineNumber: 1, endLineNumber: 1 }],
-    lines: [{ lineNumber: 1, text: "alpha" }],
-  },
-  {
-    filePath: "/repo/newer.ts",
-    mtime: 2_000,
-    fileLines: ["intro", "alpha", "middle", "tail", "alphabet"],
-    ranges: [
-      { startLineNumber: 2, endLineNumber: 2 },
-      { startLineNumber: 5, endLineNumber: 5 },
-    ],
-    lines: [
-      { lineNumber: 2, text: "alpha" },
-      { lineNumber: 5, text: "alphabet" },
-    ],
-  },
-];
-
-const relativeOptions = {
-  cwd: "/repo",
-  pathFormat: "relative",
-  context: 0,
-} as const;
-
-const absoluteOptions = {
-  cwd: "/repo",
-  pathFormat: "absolute",
-  context: 0,
-} as const;
-
-describe("renderMatches", () => {
-  test("files_with_matches sorts by recency desc and renders relative paths", () => {
-    const outcome = renderMatches(
-      fixture,
-      "files_with_matches",
-      1000,
-      relativeOptions
-    );
-    expect(outcome.body).toBe("newer.ts\nolder.ts");
-    expect(outcome.fileCount).toBe(2);
-    expect(outcome.totalMatches).toBe(3);
-    expect(outcome.totalItems).toBe(2);
-    expect(outcome.truncated).toBe(false);
-  });
-
-  test("can render absolute paths", () => {
-    const outcome = renderMatches(
-      fixture,
-      "files_with_matches",
-      1000,
-      absoluteOptions
-    );
-    expect(outcome.body).toBe("/repo/newer.ts\n/repo/older.ts");
-  });
-
-  test("content emits path:line:text lines without markers when context is omitted", () => {
-    const outcome = renderMatches(fixture, "content", 1000, relativeOptions);
-    expect(outcome.body).toBe(
-      ["newer.ts:2:alpha", "newer.ts:5:alphabet", "older.ts:1:alpha"].join("\n")
-    );
-    expect(outcome.totalItems).toBe(3);
-  });
-
-  test("content can include context lines and distinguish matches", () => {
-    const outcome = renderMatches(fixture, "content", 1000, {
-      ...relativeOptions,
-      context: 1,
-    });
-    expect(outcome.body).toBe(
-      [
-        "  newer.ts:1:intro",
-        "> newer.ts:2:alpha",
-        "  newer.ts:3:middle",
-        "  newer.ts:4:tail",
-        "> newer.ts:5:alphabet",
-        "> older.ts:1:alpha",
-      ].join("\n")
-    );
-  });
-
-  test("content inserts separators between non-overlapping context blocks", () => {
-    const outcome = renderMatches(
-      [
-        {
-          filePath: "/repo/gapped.ts",
-          mtime: 3_000,
-          fileLines: ["1", "2", "hit", "4", "5", "6", "hit", "8", "9"],
-          ranges: [
-            { startLineNumber: 3, endLineNumber: 3 },
-            { startLineNumber: 7, endLineNumber: 7 },
-          ],
-          lines: [
-            { lineNumber: 3, text: "hit" },
-            { lineNumber: 7, text: "hit" },
-          ],
-        },
-      ],
-      "content",
-      1000,
-      { ...relativeOptions, context: 1 }
-    );
-
-    expect(outcome.body).toBe(
-      [
-        "  gapped.ts:2:2",
-        "> gapped.ts:3:hit",
-        "  gapped.ts:4:4",
-        "--",
-        "  gapped.ts:6:6",
-        "> gapped.ts:7:hit",
-        "  gapped.ts:8:8",
-      ].join("\n")
-    );
-  });
-
-  test("count sorts by match count desc, then mtime desc, then path asc", () => {
-    const outcome = renderMatches(fixture, "count", 1000, relativeOptions);
-    expect(outcome.body).toBe("newer.ts:2\nolder.ts:1");
-  });
-
-  test("flags truncation when results exceed headLimit", () => {
-    const outcome = renderMatches(fixture, "content", 2, relativeOptions);
-    expect(outcome.body).toBe("newer.ts:2:alpha\nnewer.ts:5:alphabet");
-    expect(outcome.truncated).toBe(true);
-    expect(outcome.visibleItems).toBe(2);
-    expect(outcome.totalItems).toBe(3);
-  });
-
-  test("returns a no-match outcome when there are no results", () => {
-    const outcome = renderMatches([], "content", 1000, relativeOptions);
-    expect(outcome.body).toBe("No matches.");
-    expect(outcome.truncated).toBe(false);
-    expect(outcome.fileCount).toBe(0);
-    expect(outcome.totalMatches).toBe(0);
-  });
-
-  test("truncates matched lines from minified files so a single hit cannot blow up the body", () => {
-    const minified = "a".repeat(50_000);
-    const outcome = renderMatches(
-      [
-        {
-          filePath: "/repo/dist/bundle.js",
-          mtime: 1_000,
-          fileLines: [minified],
-          ranges: [{ startLineNumber: 1, endLineNumber: 1 }],
-          lines: [{ lineNumber: 1, text: minified }],
-        },
-      ],
-      "content",
-      1000,
-      relativeOptions
-    );
-
-    expect(outcome.body).toContain(
-      `(line truncated to ${OutputBudget.maxLineLength} chars)`
-    );
-    expect(Buffer.byteLength(outcome.body, "utf8")).toBeLessThanOrEqual(
-      OutputBudget.maxBytes
-    );
-  });
-
-  test("byte cap drops trailing rendered lines when many matches each push toward the cap", () => {
-    const longText = "x".repeat(OutputBudget.maxLineLength);
-    const fileLines = Array.from({ length: 40 }, () => longText);
-    const ranges = fileLines.map((_, index) => ({
-      startLineNumber: index + 1,
-      endLineNumber: index + 1,
-    }));
-    const lines = fileLines.map((text, index) => ({
-      lineNumber: index + 1,
-      text,
-    }));
-
-    const outcome = renderMatches(
-      [
-        {
-          filePath: "/repo/big.txt",
-          mtime: 1_000,
-          fileLines,
-          ranges,
-          lines,
-        },
-      ],
-      "content",
-      1000,
-      relativeOptions
-    );
-
-    expect(outcome.truncated).toBe(true);
-    expect(outcome.visibleItems).toBeLessThan(outcome.totalItems);
-    expect(Buffer.byteLength(outcome.body, "utf8")).toBeLessThanOrEqual(
-      OutputBudget.maxBytes
-    );
-  });
-});
-
-describe("formatTitle", () => {
-  test("uses relative path under cwd and includes glob", () => {
-    const title = formatTitle({
-      pattern: "alpha",
-      path: "/repo/src",
-      glob: "**/*.ts",
-      cwd: "/repo",
-    });
-    expect(title).toBe("/alpha/ in src **/*.ts");
-  });
-
-  test("formats regex patterns with slashes", () => {
-    const title = formatTitle({
-      pattern: "^alpha$",
-      path: "/repo/src",
-      glob: undefined,
-      cwd: "/repo",
-    });
-    expect(title).toBe("/^alpha$/ in src");
-  });
-
-  test("falls back to '.' when path is omitted", () => {
-    const title = formatTitle({
-      pattern: "alpha",
-      path: undefined,
-      glob: undefined,
-      cwd: "/repo",
-    });
-    expect(title).toBe("/alpha/ in .");
-  });
-
-  test("resolves relative paths in titles", () => {
-    const title = formatTitle({
-      pattern: "alpha",
-      path: "src",
-      glob: undefined,
-      cwd: "/repo",
-    });
-    expect(title).toBe("/alpha/ in src");
-  });
-
-  test("appends pluralized file count when provided", () => {
-    const title = formatTitle({
-      pattern: "alpha",
-      path: "/repo/src",
-      glob: "**/*.ts",
-      cwd: "/repo",
-      fileCount: 3,
-    });
-    expect(title).toBe("/alpha/ in src **/*.ts (3 files)");
-  });
-
-  test("uses singular noun for a single file", () => {
-    const title = formatTitle({
-      pattern: "alpha",
-      path: undefined,
-      glob: undefined,
-      cwd: "/repo",
-      fileCount: 1,
-    });
-    expect(title).toBe("/alpha/ in . (1 file)");
-  });
-});

package/src/extensions/read/read.test.ts

@@ -1,177 +0,0 @@
-import { chmod, mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterAll, describe, expect, test } from "bun:test";
-import { OutputBudget } from "../../shared/OutputBudget";
-import { buildReadRange, readFile } from "./read";
-
-const MAX_LINE_LENGTH = OutputBudget.maxLineLength;
-
-const tempRoots: string[] = [];
-
-const tempRoot = async (): Promise<string> => {
-  const root = await mkdtemp(join(tmpdir(), "pim-read-tool-"));
-  tempRoots.push(root);
-  return root;
-};
-
-afterAll(async () => {
-  await Promise.all(
-    tempRoots.map((root) => rm(root, { force: true, recursive: true }))
-  );
-});
-
-describe("readFile", () => {
-  test("emits inclusive LINE:CONTENT ranges", async () => {
-    const root = await tempRoot();
-    const path = join(root, "notes.txt");
-    await writeFile(path, "alpha\nbeta\ngamma", "utf8");
-
-    const outcome = await readFile(path, buildReadRange(2, 2));
-    expect(outcome.body).toBe("2:beta");
-    expect(outcome.totalLines).toBe(3);
-    expect(outcome.visibleStart).toBe(2);
-    expect(outcome.visibleEnd).toBe(2);
-    expect(outcome.truncatedByByteCap).toBe(false);
-    expect(outcome.truncatedByEnd).toBe(true);
-    expect(outcome.nextStart).toBe(3);
-  });
-
-  test("does not surface a phantom final line for files ending in a newline", async () => {
-    const root = await tempRoot();
-    const path = join(root, "notes.txt");
-    await writeFile(path, "alpha\nbeta\ngamma\n", "utf8");
-
-    const outcome = await readFile(path, buildReadRange(undefined, undefined));
-    expect(outcome.body).toBe(["1:alpha", "2:beta", "3:gamma"].join("\n"));
-    expect(outcome.totalLines).toBe(3);
-    expect(outcome.truncatedByEnd).toBe(false);
-  });
-
-  test("strips UTF-8 BOM from output and reports it in details", async () => {
-    const root = await tempRoot();
-    const path = join(root, "bom.txt");
-    await writeFile(path, "\uFEFFalpha\nbeta", "utf8");
-
-    const outcome = await readFile(path, buildReadRange(undefined, undefined));
-    expect(outcome.body).toBe("1:alpha\n2:beta");
-    expect(outcome.hadBom).toBe(true);
-  });
-
-  test("truncates very long individual lines", async () => {
-    const root = await tempRoot();
-    const path = join(root, "long-line.txt");
-    await writeFile(path, `${"x".repeat(MAX_LINE_LENGTH + 10)}\nshort`, "utf8");
-
-    const outcome = await readFile(path, buildReadRange(1, 1));
-    expect(outcome.body).toBe(
-      `1:${"x".repeat(MAX_LINE_LENGTH)}... (line truncated to ${MAX_LINE_LENGTH} chars)`
-    );
-  });
-
-  test("throws on empty files and out-of-range starts", async () => {
-    const root = await tempRoot();
-    const path = join(root, "empty.txt");
-    await writeFile(path, "", "utf8");
-
-    await expect(
-      readFile(path, buildReadRange(undefined, undefined))
-    ).rejects.toThrow("File is empty. Use the write tool to create content.");
-
-    const populated = join(root, "small.txt");
-    await writeFile(populated, "alpha\nbeta", "utf8");
-    await expect(
-      readFile(populated, buildReadRange(99, undefined))
-    ).rejects.toThrow(
-      "Start 99 is beyond end of file (2 lines total). Use start=1 to read from the beginning, or start=2 to read the last line."
-    );
-  });
-
-  test("rejects directories and binary files", async () => {
-    const root = await tempRoot();
-    const nested = join(root, "nested");
-    const binary = join(root, "data.bin");
-
-    await mkdir(nested);
-    await Bun.write(binary, new Uint8Array([1, 0, 2]));
-
-    await expect(
-      readFile(nested, buildReadRange(undefined, undefined))
-    ).rejects.toThrow(`Path is a directory: ${nested}`);
-
-    await expect(
-      readFile(binary, buildReadRange(undefined, undefined))
-    ).rejects.toThrow("Read only supports UTF-8 text files");
-  });
-
-  test("returns missing-file error with sibling suggestions", async () => {
-    const root = await tempRoot();
-    const missing = join(root, "note.txt");
-    await writeFile(join(root, "notes.txt"), "alpha", "utf8");
-
-    await expect(
-      readFile(missing, buildReadRange(undefined, undefined))
-    ).rejects.toThrow(/Did you mean one of these\?[\s\S]*notes\.txt/);
-  });
-
-  test("surfaces permission-denied as a structured error", async () => {
-    if (process.getuid?.() === 0) {
-      return;
-    }
-
-    const root = await tempRoot();
-    const path = join(root, "locked.txt");
-    await writeFile(path, "secret", "utf8");
-    await chmod(path, 0o000);
-
-    try {
-      await expect(
-        readFile(path, buildReadRange(undefined, undefined))
-      ).rejects.toThrow(`Permission denied reading ${path}.`);
-    } finally {
-      await chmod(path, 0o644);
-    }
-  });
-
-  test("applies a 32 KiB head-only byte cap and reports pagination metadata", async () => {
-    const root = await tempRoot();
-    const path = join(root, "long.txt");
-    const lines = Array.from(
-      { length: 80 },
-      (_, index) => `${index + 1}: ${"x".repeat(500)}`
-    );
-    await writeFile(path, lines.join("\n"), "utf8");
-
-    const outcome = await readFile(path, buildReadRange(undefined, undefined));
-    expect(Buffer.byteLength(outcome.body, "utf8")).toBeLessThanOrEqual(
-      32 * 1024
-    );
-    expect(outcome.truncatedByByteCap).toBe(true);
-    expect(outcome.truncatedByEnd).toBe(true);
-    expect(outcome.nextStart).toBe(outcome.visibleEnd + 1);
-    expect(outcome.totalLines).toBe(80);
-  });
-});
-
-describe("buildReadRange", () => {
-  test("rejects end before start", () => {
-    expect(() => buildReadRange(5, 4)).toThrow(
-      "Read end line 4 must be >= start line 5."
-    );
-  });
-
-  test("rejects non-positive integers", () => {
-    expect(() => buildReadRange(0, undefined)).toThrow(
-      "Read start 0 must be a positive integer."
-    );
-    expect(() => buildReadRange(undefined, -1)).toThrow(
-      "Read end -1 must be a positive integer."
-    );
-  });
-
-  test("defaults start to 1", () => {
-    expect(buildReadRange(undefined, undefined)).toEqual({
-      start: 1,
-    });
-  });
-});

package/src/extensions/read/render.test.ts

@@ -1,61 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { formatTitlePath } from "./render";
-
-describe("formatTitlePath", () => {
-  const cwd = "/work/repo";
-
-  test("renders relative path without format suffix", () => {
-    expect(
-      formatTitlePath({
-        path: "/work/repo/src/foo.ts",
-        cwd,
-        start: undefined,
-        end: undefined,
-      })
-    ).toBe("src/foo.ts");
-  });
-
-  test("renders explicit start-end range", () => {
-    expect(
-      formatTitlePath({
-        path: "/work/repo/src/foo.ts",
-        cwd,
-        start: 40,
-        end: 80,
-      })
-    ).toBe("src/foo.ts:40-80");
-  });
-
-  test("renders start-only range", () => {
-    expect(
-      formatTitlePath({
-        path: "/work/repo/src/foo.ts",
-        cwd,
-        start: 40,
-        end: undefined,
-      })
-    ).toBe("src/foo.ts:40");
-  });
-
-  test("falls back to absolute path when outside cwd", () => {
-    expect(
-      formatTitlePath({
-        path: "/etc/hosts",
-        cwd,
-        start: undefined,
-        end: undefined,
-      })
-    ).toBe("/etc/hosts");
-  });
-
-  test("placeholder when path is missing", () => {
-    expect(
-      formatTitlePath({
-        path: undefined,
-        cwd,
-        start: undefined,
-        end: undefined,
-      })
-    ).toBe("...");
-  });
-});

package/src/extensions/subagent/index.test.ts

@@ -1,44 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { validateToolArguments } from "@earendil-works/pi-ai";
-import registerSubagent from "./index";
-import { subagentSchema } from "./schema";
-
-function validate(args: unknown): void {
-  validateToolArguments(
-    { name: "subagent", parameters: subagentSchema } as never,
-    {
-      type: "toolCall",
-      id: "1",
-      name: "subagent",
-      arguments: args as Record<string, unknown>,
-    }
-  );
-}
-
-describe("subagent extension registration", () => {
-  test("schema rejects an empty prompt", () => {
-    expect(() => validate({ prompt: "" })).toThrow();
-  });
-
-  test("registers one parallel tool without a prompt snippet", () => {
-    let tool:
-      | {
-          readonly name: string;
-          readonly executionMode?: string;
-          readonly promptSnippet?: string;
-          readonly parameters: unknown;
-        }
-      | undefined;
-    registerSubagent({
-      registerTool(def) {
-        tool = def;
-      },
-    } as ExtensionAPI);
-
-    expect(tool?.name).toBe("subagent");
-    expect(tool?.executionMode).toBe("parallel");
-    expect(tool?.promptSnippet).toBeUndefined();
-    expect(tool?.parameters).toBe(subagentSchema);
-  });
-});