@aaroncql/pim-agent 0.0.1 → 0.1.0

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

@@ -1,161 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { createFooterWidget, getTotalCost } from "./index";
-import type { GitState } from "./git";
-
-function deferred<T>(): {
-  readonly promise: Promise<T>;
-  readonly resolve: (value: T) => void;
-} {
-  let resolve!: (value: T) => void;
-  const promise = new Promise<T>((r) => {
-    resolve = r;
-  });
-  return { promise, resolve };
-}
-
-async function flushPromises(): Promise<void> {
-  await Promise.resolve();
-  await Promise.resolve();
-}
-
-function assistant(cost: number): unknown {
-  return {
-    type: "message",
-    message: {
-      role: "assistant",
-      usage: {
-        cost: {
-          total: cost,
-        },
-      },
-    },
-  };
-}
-
-describe("getTotalCost", () => {
-  test("sums assistant costs across all session entries", () => {
-    const ctx = {
-      sessionManager: {
-        getEntries: () => [
-          assistant(1.25),
-          {
-            type: "message",
-            message: {
-              role: "user",
-            },
-          },
-          assistant(2.5),
-        ],
-      },
-    } as unknown as ExtensionContext;
-
-    expect(getTotalCost(ctx)).toBe(3.75);
-  });
-});
-
-describe("createFooterWidget", () => {
-  test("coalesces git refreshes while one is in flight", async () => {
-    const first = deferred<GitState>();
-    const second = deferred<GitState>();
-    const fetches: Promise<GitState>[] = [];
-    let branchHandler: () => void = () => {};
-    let gitWatchHandler: () => void = () => {};
-    let branchUnsubscribed = false;
-    let gitWatchDisposed = false;
-    let renderRequests = 0;
-
-    const ctx = {
-      cwd: "/repo",
-      sessionManager: {
-        getEntries: () => [],
-      },
-    } as unknown as ExtensionContext;
-
-    const widget = createFooterWidget(
-      ctx,
-      {
-        requestRender: () => {
-          renderRequests++;
-        },
-      },
-      {
-        onBranchChange: (handler) => {
-          branchHandler = handler;
-          return () => {
-            branchUnsubscribed = true;
-          };
-        },
-      },
-      {
-        fetchGitStatus: () => {
-          const promise = fetches.length === 0 ? first.promise : second.promise;
-          fetches.push(promise);
-          return promise;
-        },
-        watchGitDir: (_cwd, handler) => {
-          gitWatchHandler = handler;
-          return () => {
-            gitWatchDisposed = true;
-          };
-        },
-        renderFooterLine: (_width, _ctx, gitState) => gitState.branch ?? "none",
-        getTotalCost: () => 0,
-      }
-    );
-
-    expect(fetches).toHaveLength(1);
-
-    branchHandler();
-    gitWatchHandler();
-    expect(fetches).toHaveLength(1);
-
-    first.resolve({ branch: "main", dirty: false, ahead: 0, behind: 0 });
-    await flushPromises();
-    expect(fetches).toHaveLength(2);
-
-    second.resolve({ branch: "next", dirty: true, ahead: 1, behind: 0 });
-    await flushPromises();
-    expect(fetches).toHaveLength(2);
-    expect(renderRequests).toBe(2);
-    expect(widget.render(80)).toEqual(["next"]);
-
-    widget.dispose();
-    expect(branchUnsubscribed).toBe(true);
-    expect(gitWatchDisposed).toBe(true);
-  });
-
-  test("requests render only when git state changes", async () => {
-    const refresh = deferred<GitState>();
-    let renderRequests = 0;
-
-    const widget = createFooterWidget(
-      {
-        cwd: "/repo",
-        sessionManager: {
-          getEntries: () => [],
-        },
-      } as unknown as ExtensionContext,
-      {
-        requestRender: () => {
-          renderRequests++;
-        },
-      },
-      {
-        onBranchChange: () => () => {},
-      },
-      {
-        fetchGitStatus: () => refresh.promise,
-        watchGitDir: () => () => {},
-        renderFooterLine: () => "",
-        getTotalCost: () => 0,
-      }
-    );
-
-    refresh.resolve({ branch: null, dirty: false, ahead: 0, behind: 0 });
-    await flushPromises();
-
-    expect(renderRequests).toBe(0);
-    widget.dispose();
-  });
-});

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

@@ -1,164 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { visibleWidth } from "@earendil-works/pi-tui";
-import { renderFooterLine } from "./segments";
-
-function stripAnsi(s: string): string {
-  let out = "";
-  for (let i = 0; i < s.length; i++) {
-    if (s.charCodeAt(i) === 27 && s[i + 1] === "[") {
-      i += 2;
-      while (i < s.length && s[i] !== "m") {
-        i++;
-      }
-    } else {
-      out += s[i]!;
-    }
-  }
-  return out;
-}
-
-function createCtx(
-  branch: readonly unknown[] = [],
-  options: {
-    readonly cwd?: string;
-    readonly model?: { readonly id: string; readonly reasoning?: boolean };
-  } = {}
-): ExtensionContext {
-  return {
-    sessionManager: {
-      getCwd: () => options.cwd ?? "/home/aaroncql/dev/pim-agent",
-      getBranch: () => branch,
-    },
-    getContextUsage: () => ({
-      tokens: 200_000,
-      contextWindow: 200_000,
-      percent: 50,
-    }),
-    model: options.model ?? {
-      id: "gpt-5.5",
-      reasoning: true,
-    },
-  } as unknown as ExtensionContext;
-}
-
-describe("renderFooterLine", () => {
-  test("does not exceed narrow terminal widths", () => {
-    const ctx = createCtx();
-    const widths = [0, 1, 2, 3, 4, 8, 10, 12, 16, 20, 40];
-
-    for (const width of widths) {
-      const line = renderFooterLine(
-        width,
-        ctx,
-        {
-          branch: "feat/some-very-long-branch",
-          dirty: true,
-          ahead: 12,
-          behind: 3,
-        },
-        12.34
-      );
-
-      expect(visibleWidth(line)).toBeLessThanOrEqual(width);
-    }
-  });
-
-  test("drops lower-priority segments as width tightens", () => {
-    const ctx = createCtx(
-      [{ type: "thinking_level_change", thinkingLevel: "medium" }],
-      { cwd: "/x/proj" }
-    );
-    const git = {
-      branch: "main",
-      dirty: true,
-      ahead: 2,
-      behind: 0,
-    };
-
-    expect(stripAnsi(renderFooterLine(200, ctx, git, 1.23))).toContain(
-      "gpt-5.5"
-    );
-    expect(stripAnsi(renderFooterLine(200, ctx, git, 1.23))).toContain("$1.23");
-    expect(stripAnsi(renderFooterLine(200, ctx, git, 1.23))).toContain("main");
-    expect(stripAnsi(renderFooterLine(200, ctx, git, 1.23))).toContain(
-      "50.0%/200K"
-    );
-
-    const withoutModel = stripAnsi(renderFooterLine(50, ctx, git, 1.23));
-    expect(withoutModel).not.toContain("gpt-5.5");
-    expect(withoutModel).toContain("$1.23");
-    expect(withoutModel).toContain("main");
-    expect(withoutModel).toContain("50.0%/200K");
-
-    const withoutCost = stripAnsi(renderFooterLine(40, ctx, git, 1.23));
-    expect(withoutCost).not.toContain("$1.23");
-    expect(withoutCost).toContain("main");
-    expect(withoutCost).toContain("50.0%/200K");
-
-    const withoutGit = stripAnsi(renderFooterLine(35, ctx, git, 1.23));
-    expect(withoutGit).not.toContain("main");
-    expect(withoutGit).toContain("/x/proj");
-    expect(withoutGit).toContain("50.0%/200K");
-
-    const cwdOnly = stripAnsi(renderFooterLine(20, ctx, git, 1.23));
-    expect(cwdOnly).toContain("/x/proj");
-    expect(cwdOnly).not.toContain("50.0%/200K");
-  });
-
-  test("renders latest reasoning level for reasoning models", () => {
-    const medium = stripAnsi(
-      renderFooterLine(
-        120,
-        createCtx([{ type: "thinking_level_change", thinkingLevel: "medium" }]),
-        { branch: null, dirty: false, ahead: 0, behind: 0 },
-        0
-      )
-    );
-    expect(medium).toContain("gpt-5.5");
-    expect(medium).toContain("med");
-
-    const latestWins = stripAnsi(
-      renderFooterLine(
-        120,
-        createCtx([
-          { type: "thinking_level_change", thinkingLevel: "minimal" },
-          { type: "thinking_level_change", thinkingLevel: "xhigh" },
-        ]),
-        { branch: null, dirty: false, ahead: 0, behind: 0 },
-        0
-      )
-    );
-    expect(latestWins).toContain("xhigh");
-    expect(latestWins).not.toContain("min");
-
-    const noLevel = stripAnsi(
-      renderFooterLine(
-        120,
-        createCtx(),
-        { branch: null, dirty: false, ahead: 0, behind: 0 },
-        0
-      )
-    );
-    expect(noLevel).toContain("off");
-  });
-
-  test("omits reasoning level for non-reasoning models", () => {
-    const line = stripAnsi(
-      renderFooterLine(
-        120,
-        createCtx(
-          [{ type: "thinking_level_change", thinkingLevel: "medium" }],
-          {
-            model: { id: "gpt-5.5" },
-          }
-        ),
-        { branch: null, dirty: false, ahead: 0, behind: 0 },
-        0
-      )
-    );
-
-    expect(line).toContain("gpt-5.5");
-    expect(line).not.toContain("med");
-  });
-});

package/src/extensions/glob/glob.test.ts

@@ -1,171 +0,0 @@
-import { mkdir, mkdtemp, rm, utimes, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterAll, describe, expect, test } from "bun:test";
-import { findFiles } from "./glob";
-
-const tempRoots: string[] = [];
-
-const tempRoot = async (): Promise<string> => {
-  const root = await mkdtemp(join(tmpdir(), "pim-glob-tool-"));
-  tempRoots.push(root);
-  return root;
-};
-
-afterAll(async () => {
-  await Promise.all(
-    tempRoots.map((root) => rm(root, { force: true, recursive: true }))
-  );
-});
-
-const defaultScanOptions = {
-  includeDotfiles: false,
-  includeIgnored: false,
-} as const;
-
-describe("findFiles", () => {
-  test("sorts by recency desc with path-asc tiebreak when mtimes are equal", async () => {
-    const root = await tempRoot();
-    const older = join(root, "older.ts");
-    const tieB = join(root, "b.ts");
-    const tieA = join(root, "a.ts");
-
-    await writeFile(older, "", "utf8");
-    await writeFile(tieA, "", "utf8");
-    await writeFile(tieB, "", "utf8");
-
-    await utimes(
-      older,
-      new Date("2024-01-01T00:00:00Z"),
-      new Date("2024-01-01T00:00:00Z")
-    );
-    await utimes(
-      tieA,
-      new Date("2024-01-02T00:00:00Z"),
-      new Date("2024-01-02T00:00:00Z")
-    );
-    await utimes(
-      tieB,
-      new Date("2024-01-02T00:00:00Z"),
-      new Date("2024-01-02T00:00:00Z")
-    );
-
-    const matches = await findFiles(root, "**/*.ts", defaultScanOptions);
-
-    expect(matches.map((match) => match.path)).toEqual([tieA, tieB, older]);
-  });
-
-  test("respects gitignore, dotfiles, and the always-ignored defaults", async () => {
-    const root = await tempRoot();
-    const src = join(root, "src");
-    const ignored = join(src, "ignored.ts");
-    const kept = join(src, "kept.ts");
-    const nodeModules = join(root, "node_modules", "pkg", "x.ts");
-    const dot = join(root, ".secret", "x.ts");
-
-    await mkdir(src, { recursive: true });
-    await mkdir(join(root, "node_modules", "pkg"), { recursive: true });
-    await mkdir(join(root, ".secret"), { recursive: true });
-    await writeFile(join(root, ".gitignore"), "ignored.ts\n", "utf8");
-    await writeFile(ignored, "", "utf8");
-    await writeFile(kept, "", "utf8");
-    await writeFile(nodeModules, "", "utf8");
-    await writeFile(dot, "", "utf8");
-
-    const matches = await findFiles(root, "**/*.ts", defaultScanOptions);
-
-    expect(matches.map((match) => match.path)).toEqual([kept]);
-  });
-
-  test("can include dotfiles and ignored paths", async () => {
-    const root = await tempRoot();
-    const kept = join(root, "kept.ts");
-    const ignored = join(root, "ignored.ts");
-    const dot = join(root, ".secret", "x.ts");
-
-    await mkdir(join(root, ".secret"), { recursive: true });
-    await writeFile(join(root, ".gitignore"), "ignored.ts\n", "utf8");
-    await writeFile(kept, "", "utf8");
-    await writeFile(ignored, "", "utf8");
-    await writeFile(dot, "", "utf8");
-
-    const matches = await findFiles(root, "**/*.ts", {
-      includeDotfiles: true,
-      includeIgnored: true,
-    });
-
-    expect(matches.map((match) => match.path).sort()).toEqual(
-      [dot, ignored, kept].sort()
-    );
-  });
-
-  test("filters by glob pattern extension", async () => {
-    const root = await tempRoot();
-    const ts = join(root, "a.ts");
-    const md = join(root, "a.md");
-
-    await writeFile(ts, "", "utf8");
-    await writeFile(md, "", "utf8");
-
-    const matches = await findFiles(root, "**/*.ts", defaultScanOptions);
-
-    expect(matches.map((match) => match.path)).toEqual([ts]);
-  });
-
-  test("excludes a single glob pattern", async () => {
-    const root = await tempRoot();
-    const source = join(root, "src", "app.ts");
-    const test = join(root, "src", "app.test.ts");
-
-    await mkdir(join(root, "src"), { recursive: true });
-    await writeFile(source, "", "utf8");
-    await writeFile(test, "", "utf8");
-
-    const matches = await findFiles(root, "**/*.ts", {
-      ...defaultScanOptions,
-      exclude: ["**/*.test.ts"],
-    });
-
-    expect(matches.map((match) => match.path)).toEqual([source]);
-  });
-
-  test("excludes multiple glob patterns", async () => {
-    const root = await tempRoot();
-    const source = join(root, "src", "app.ts");
-    const test = join(root, "src", "app.test.ts");
-    const generated = join(root, "src", "generated", "types.ts");
-
-    await mkdir(join(root, "src", "generated"), { recursive: true });
-    await writeFile(source, "", "utf8");
-    await writeFile(test, "", "utf8");
-    await writeFile(generated, "", "utf8");
-
-    const matches = await findFiles(root, "**/*.ts", {
-      ...defaultScanOptions,
-      exclude: ["**/*.test.ts", "src/generated/**"],
-    });
-
-    expect(matches.map((match) => match.path)).toEqual([source]);
-  });
-
-  test("throws an actionable error when the path does not exist", async () => {
-    const root = await tempRoot();
-    const missing = join(root, "nope");
-
-    await expect(
-      findFiles(missing, "**/*", defaultScanOptions)
-    ).rejects.toThrow(
-      `Path not found: ${missing}. Use glob to locate the file or directory, or verify the path.`
-    );
-  });
-
-  test("throws an actionable error when path is a file, not a directory", async () => {
-    const root = await tempRoot();
-    const file = join(root, "notes.txt");
-    await writeFile(file, "hello", "utf8");
-
-    await expect(findFiles(file, "**/*", defaultScanOptions)).rejects.toThrow(
-      `Glob path must be a directory: ${file}. Drop "path" and put the filename in "pattern", or use the read tool to inspect a single file.`
-    );
-  });
-});

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

@@ -1,68 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type {
-  AgentToolResult,
-  ExtensionAPI,
-  Theme,
-  ToolDefinition,
-} from "@earendil-works/pi-coding-agent";
-import registerGlob from "./index";
-
-const stubTheme = {
-  bold: (text: string) => text,
-  fg: (_color: string, text: string) => text,
-} as unknown as Theme;
-
-function registeredTool(): ToolDefinition {
-  let tool: ToolDefinition | undefined;
-  registerGlob({
-    registerTool(def: ToolDefinition): void {
-      tool = def;
-    },
-  } as unknown as ExtensionAPI);
-
-  if (tool === undefined) {
-    throw new Error("glob tool was not registered");
-  }
-  return tool;
-}
-
-describe("glob tool renderer", () => {
-  test("updates the visible call title with the file count when the result renders", () => {
-    const tool = registeredTool();
-    const args = { pattern: "**/*.ts" };
-    const state = {};
-    const callContext = {
-      args,
-      toolCallId: "glob-1",
-      invalidate: () => {},
-      lastComponent: undefined,
-      state,
-      cwd: "/repo",
-      executionStarted: true,
-      argsComplete: true,
-      isPartial: false,
-      expanded: false,
-      showImages: true,
-      isError: false,
-    };
-    const callComponent = tool.renderCall!(args, stubTheme, callContext);
-
-    expect(callComponent.render(120).join("\n")).not.toContain("(2 files)");
-
-    const result: AgentToolResult<unknown> = {
-      content: [{ type: "text", text: "src/a.ts\nsrc/b.ts" }],
-      details: { fileCount: 2 },
-    };
-    tool.renderResult!(
-      result,
-      { expanded: false, isPartial: false },
-      stubTheme,
-      {
-        ...callContext,
-        lastComponent: undefined,
-      }
-    );
-
-    expect(callComponent.render(120).join("\n")).toContain("(2 files)");
-  });
-});

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

@@ -1,126 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import type { GlobMatch } from "./glob";
-import { formatTitle, renderFiles } from "./render";
-
-const fixture: readonly GlobMatch[] = [
-  { path: "/repo/newer.ts", mtime: 2_000 },
-  { path: "/repo/older.ts", mtime: 1_000 },
-];
-
-const relativeOptions = {
-  cwd: "/repo",
-  pathFormat: "relative",
-} as const;
-
-const absoluteOptions = {
-  cwd: "/repo",
-  pathFormat: "absolute",
-} as const;
-
-describe("renderFiles", () => {
-  test("joins paths with newlines, newest first, relative by default", () => {
-    const outcome = renderFiles(fixture, 1000, relativeOptions);
-    expect(outcome.body).toBe("newer.ts\nolder.ts");
-    expect(outcome.totalItems).toBe(2);
-    expect(outcome.visibleItems).toBe(2);
-    expect(outcome.truncated).toBe(false);
-  });
-
-  test("can render absolute paths", () => {
-    const outcome = renderFiles(fixture, 1000, absoluteOptions);
-    expect(outcome.body).toBe("/repo/newer.ts\n/repo/older.ts");
-  });
-
-  test("flips truncated when results exceed headLimit", () => {
-    const outcome = renderFiles(fixture, 1, relativeOptions);
-    expect(outcome.body).toBe("newer.ts");
-    expect(outcome.truncated).toBe(true);
-    expect(outcome.visibleItems).toBe(1);
-    expect(outcome.totalItems).toBe(2);
-  });
-
-  test("returns a no-match outcome when there are no results", () => {
-    const outcome = renderFiles([], 1000, relativeOptions);
-    expect(outcome.body).toBe("No matches.");
-    expect(outcome.truncated).toBe(false);
-    expect(outcome.totalItems).toBe(0);
-    expect(outcome.visibleItems).toBe(0);
-  });
-});
-
-describe("formatTitle", () => {
-  test("uses relative path under cwd", () => {
-    const title = formatTitle({
-      pattern: "**/*.ts",
-      path: "/repo/src",
-      cwd: "/repo",
-    });
-    expect(title).toBe("**/*.ts in src");
-  });
-
-  test("omits location when path is undefined", () => {
-    const title = formatTitle({
-      pattern: "**/*.ts",
-      path: undefined,
-      cwd: "/repo",
-    });
-    expect(title).toBe("**/*.ts");
-  });
-
-  test("omits location when path resolves to cwd", () => {
-    const title = formatTitle({
-      pattern: "**/*.ts",
-      path: ".",
-      cwd: "/repo",
-    });
-    expect(title).toBe("**/*.ts");
-  });
-
-  test("omits location when path is the absolute cwd", () => {
-    const title = formatTitle({
-      pattern: "**/*.ts",
-      path: "/repo",
-      cwd: "/repo",
-    });
-    expect(title).toBe("**/*.ts");
-  });
-
-  test("uses '...' placeholder when pattern is undefined", () => {
-    const title = formatTitle({
-      pattern: undefined,
-      path: undefined,
-      cwd: "/repo",
-    });
-    expect(title).toBe("...");
-  });
-
-  test("appends pluralized file count when provided", () => {
-    const title = formatTitle({
-      pattern: "**/*.ts",
-      path: "/repo/src",
-      cwd: "/repo",
-      fileCount: 3,
-    });
-    expect(title).toBe("**/*.ts in src (3 files)");
-  });
-
-  test("uses singular noun for a single file", () => {
-    const title = formatTitle({
-      pattern: "**/*.ts",
-      path: undefined,
-      cwd: "/repo",
-      fileCount: 1,
-    });
-    expect(title).toBe("**/*.ts (1 file)");
-  });
-
-  test("shows zero count without omitting the suffix", () => {
-    const title = formatTitle({
-      pattern: "**/*.ts",
-      path: undefined,
-      cwd: "/repo",
-      fileCount: 0,
-    });
-    expect(title).toBe("**/*.ts (0 files)");
-  });
-});