@aaroncql/pim-agent 0.0.1

package/src/extensions/footer/segments.ts

@@ -0,0 +1,234 @@
+import type {
+  ExtensionContext,
+  ThinkingLevelChangeEntry,
+} from "@earendil-works/pi-coding-agent";
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { Paths } from "../../shared/Paths";
+import type { GitState } from "./git";
+import {
+  BG_BRIGHT_GREEN,
+  BG_BRIGHT_MAGENTA,
+  BG_BRIGHT_RED,
+  BG_BRIGHT_YELLOW,
+  BG_GRAY,
+  FG_BLACK,
+  FG_WHITE,
+  GIT_AHEAD_ICON,
+  GIT_BEHIND_ICON,
+  GIT_DIRTY_ICON,
+  GIT_ICON,
+  groupWidth,
+  renderLeftGroup,
+  renderRightGroup,
+  type Segment,
+  thinChevronLeft,
+} from "./powerline";
+
+function formatTokens(n: number): string {
+  if (n < 1000) {
+    return `${n}`;
+  }
+  if (n < 10_000) {
+    return `${(n / 1000).toFixed(1)}K`;
+  }
+  if (n < 1_000_000) {
+    return `${Math.round(n / 1000)}K`;
+  }
+  if (n < 10_000_000) {
+    return `${(n / 1_000_000).toFixed(1)}M`;
+  }
+  return `${Math.round(n / 1_000_000)}M`;
+}
+
+function gitSegment(state: GitState): Segment | null {
+  const { branch, dirty, ahead, behind } = state;
+  if (!branch) {
+    return null;
+  }
+  let text = `${GIT_ICON} ${branch}`;
+  if (dirty) {
+    text += ` ${GIT_DIRTY_ICON}`;
+  }
+  if (ahead > 0 || behind > 0) {
+    let arrows = " ";
+    if (ahead > 0) {
+      arrows += `${GIT_AHEAD_ICON}${ahead}`;
+    }
+    if (behind > 0) {
+      arrows += `${GIT_BEHIND_ICON}${behind}`;
+    }
+    text += arrows;
+  }
+  const bg =
+    behind > 0 ? BG_BRIGHT_RED : dirty ? BG_BRIGHT_YELLOW : BG_BRIGHT_GREEN;
+  return { text, fg: FG_BLACK, bg };
+}
+
+function ctxSegment(ctx: ExtensionContext): Segment | null {
+  const usage = ctx.getContextUsage();
+  if (!usage || usage.contextWindow === 0) {
+    return null;
+  }
+  const window = formatTokens(usage.contextWindow);
+  const text =
+    usage.percent === null
+      ? `?/${window}`
+      : `${usage.percent.toFixed(1)}%/${window}`;
+  const percent = usage.percent ?? 0;
+  const bg =
+    percent >= 70
+      ? BG_BRIGHT_RED
+      : percent > 40
+        ? BG_BRIGHT_YELLOW
+        : BG_BRIGHT_GREEN;
+  return { text, fg: FG_BLACK, bg };
+}
+
+function costSegment(cost: number): Segment | null {
+  if (cost <= 0) {
+    return null;
+  }
+  return {
+    text: `$${cost.toFixed(2)}`,
+    fg: FG_BLACK,
+    bg: BG_BRIGHT_MAGENTA,
+  };
+}
+
+const LEVEL_LABEL: Record<string, string> = { minimal: "min", medium: "med" };
+
+function findLatestThinkingLevel(ctx: ExtensionContext): string {
+  const branch = ctx.sessionManager.getBranch();
+  for (let i = branch.length - 1; i >= 0; i--) {
+    const entry = branch[i]!;
+    if (entry.type === "thinking_level_change") {
+      return (entry as ThinkingLevelChangeEntry).thinkingLevel;
+    }
+  }
+  return "off";
+}
+
+function modelSegment(ctx: ExtensionContext): Segment | null {
+  const id = ctx.model?.id;
+  if (!id) {
+    return null;
+  }
+
+  if (ctx.model?.reasoning) {
+    const level = findLatestThinkingLevel(ctx);
+    const label = LEVEL_LABEL[level] ?? level;
+    return {
+      text: `${id} ${thinChevronLeft(BG_GRAY, FG_WHITE)} ${label}`,
+      fg: FG_WHITE,
+      bg: BG_GRAY,
+    };
+  }
+
+  return { text: id, fg: FG_WHITE, bg: BG_GRAY };
+}
+
+function compact<T>(items: readonly (T | null)[]): T[] {
+  return items.filter((x): x is T => x !== null);
+}
+
+function totalWidth(
+  left: readonly Segment[],
+  right: readonly Segment[]
+): number {
+  const gap = left.length > 0 && right.length > 0 ? 1 : 0;
+  return groupWidth(left) + groupWidth(right) + gap;
+}
+
+function fitLine(line: string, width: number): string {
+  if (width <= 0) {
+    return "";
+  }
+  return visibleWidth(line) <= width ? line : truncateToWidth(line, width, "");
+}
+
+const bold = (s: string): string => `\x1b[1m${s}\x1b[22m`;
+
+function formatCwd(path: string): string {
+  if (path === "/" || path === "~") {
+    return bold(path);
+  }
+  const parts = path.split("/");
+  const last = parts.pop()!;
+  const abbrParent = parts
+    .map((p) => {
+      if (p === "" || p === "~") {
+        return p;
+      }
+      return p.startsWith(".") && p.length > 1 ? p.slice(0, 2) : p[0]!;
+    })
+    .join("/");
+  return `${abbrParent}/${bold(last)}`;
+}
+
+export function renderFooterLine(
+  width: number,
+  ctx: ExtensionContext,
+  gitState: GitState,
+  cost: number
+): string {
+  const cwd: Segment = {
+    text: formatCwd(Paths.abbreviateHome(ctx.sessionManager.getCwd())),
+    fg: FG_WHITE,
+    bg: BG_GRAY,
+  };
+  const branch = gitSegment(gitState);
+  const costSeg = costSegment(cost);
+  const ctxSeg = ctxSegment(ctx);
+  const model = modelSegment(ctx);
+
+  const fullLeft = compact([cwd, branch]);
+  const fullLeftWidth = groupWidth(fullLeft);
+  const candidates: readonly { left: Segment[]; right: Segment[] }[] = [
+    { left: fullLeft, right: compact([costSeg, ctxSeg, model]) },
+    { left: fullLeft, right: compact([costSeg, ctxSeg]) },
+    { left: fullLeft, right: compact([ctxSeg]) },
+    { left: [cwd], right: compact([ctxSeg]) },
+    { left: [cwd], right: [] },
+  ];
+
+  let chosen = candidates[candidates.length - 1]!;
+  let chosenLeftWidth = groupWidth(chosen.left);
+  let chosenRightWidth = groupWidth(chosen.right);
+  for (const c of candidates) {
+    const lw = c.left === fullLeft ? fullLeftWidth : groupWidth(c.left);
+    const rw = groupWidth(c.right);
+    const gapWidth = c.left.length > 0 && c.right.length > 0 ? 1 : 0;
+    if (lw + rw + gapWidth <= width) {
+      chosen = c;
+      chosenLeftWidth = lw;
+      chosenRightWidth = rw;
+      break;
+    }
+  }
+
+  let left = chosen.left;
+  let leftWidth = chosenLeftWidth;
+  const requiredWidth = totalWidth(left, chosen.right);
+  if (requiredWidth > width && left.length > 0) {
+    const overflow = requiredWidth - width;
+    const newCwdWidth = Math.max(0, visibleWidth(left[0]!.text) - overflow);
+    const truncated: Segment = {
+      ...left[0]!,
+      text: truncateToWidth(left[0]!.text, newCwdWidth, "…"),
+    };
+    left = [truncated, ...left.slice(1)];
+    leftWidth =
+      leftWidth -
+      visibleWidth(chosen.left[0]!.text) +
+      visibleWidth(truncated.text);
+  }
+
+  const gap =
+    left.length > 0 && chosen.right.length > 0
+      ? Math.max(1, width - leftWidth - chosenRightWidth)
+      : 0;
+  return fitLine(
+    renderLeftGroup(left) + " ".repeat(gap) + renderRightGroup(chosen.right),
+    width
+  );
+}

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

@@ -0,0 +1,171 @@
+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/glob.ts

@@ -0,0 +1,34 @@
+import { FileScanner, type FileScanOptions } from "../../shared/FileScanner";
+import { FsErrors } from "../../shared/FsErrors";
+
+export type GlobMatch = {
+  readonly path: string;
+  readonly mtime: number;
+};
+
+export type GlobScanOptions = FileScanOptions;
+
+export async function findFiles(
+  root: string,
+  pattern: string,
+  options: GlobScanOptions
+): Promise<readonly GlobMatch[]> {
+  const metadata = await FsErrors.statOrThrow(root);
+
+  if (!metadata.isDirectory()) {
+    throw new Error(
+      `Glob path must be a directory: ${root}. Drop "path" and put the filename in "pattern", or use the read tool to inspect a single file.`
+    );
+  }
+
+  const paths = await FileScanner.scan(root, pattern, options);
+  const matches: GlobMatch[] = paths.map((path) => ({
+    path,
+    mtime: Bun.file(path).lastModified,
+  }));
+
+  return matches.sort(
+    (left, right) =>
+      right.mtime - left.mtime || left.path.localeCompare(right.path)
+  );
+}

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

@@ -0,0 +1,68 @@
+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/index.ts

@@ -0,0 +1,136 @@
+import type { ExtensionAPI, Theme } from "@earendil-works/pi-coding-agent";
+import { Paths } from "../../shared/Paths";
+import {
+  Renderer,
+  type StatefulToolCallTitleContext,
+  type StatefulToolCallTitleState,
+} from "../../shared/Renderer";
+import { Tools } from "../../shared/Tools";
+import { findFiles } from "./glob";
+import { formatTitle, renderFiles } from "./render";
+import {
+  GLOB_HEAD_LIMIT_MAX,
+  type GlobInput,
+  type GlobPathFormat,
+  globSchema,
+} from "./schema";
+
+const PREVIEW_LINES = 10;
+const DEFAULT_PATH_FORMAT: GlobPathFormat = "relative";
+
+type GlobCallState = StatefulToolCallTitleState & {
+  fileCount?: number;
+};
+
+type GlobRenderContext = StatefulToolCallTitleContext & {
+  readonly args?: GlobInput;
+  readonly cwd: string;
+};
+
+function renderTitle(
+  input: Partial<GlobInput>,
+  theme: Theme,
+  context: GlobRenderContext
+) {
+  const state = context.state as GlobCallState;
+  const title = formatTitle({
+    pattern: input.pattern,
+    path: input.path,
+    cwd: context.cwd,
+    fileCount: state.fileCount,
+  });
+  return Renderer.renderStatefulToolCallTitle({
+    label: "Glob",
+    title,
+    theme,
+    context,
+  });
+}
+
+export default function (pi: ExtensionAPI): void {
+  Tools.register(pi, {
+    name: "glob",
+    label: "glob",
+    description:
+      "Find files by glob pattern under a directory, sorted newest first. Skips gitignored paths and dotfiles unless requested. Use glob to enumerate files instead of bash with find, fd, ls -R, or similar.",
+    parameters: globSchema,
+    renderShell: "self",
+    executionMode: "parallel",
+    async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+      const {
+        pattern,
+        path,
+        exclude,
+        includeDotfiles,
+        includeIgnored,
+        pathFormat,
+        headLimit,
+      } = params as GlobInput;
+
+      if (signal?.aborted) {
+        throw new Error("Glob aborted before execution.");
+      }
+
+      const limit = headLimit ?? GLOB_HEAD_LIMIT_MAX;
+      const resolvedPathFormat = pathFormat ?? DEFAULT_PATH_FORMAT;
+      const absolutePath = Paths.resolve(path ?? ".", ctx.cwd);
+      const matches = await findFiles(absolutePath, pattern, {
+        exclude,
+        includeDotfiles: includeDotfiles ?? false,
+        includeIgnored: includeIgnored ?? false,
+      });
+      const outcome = renderFiles(matches, limit, {
+        cwd: ctx.cwd,
+        pathFormat: resolvedPathFormat,
+      });
+      const content: Array<{ type: "text"; text: string }> = [
+        { type: "text", text: outcome.body },
+      ];
+
+      if (outcome.truncated) {
+        content.push({
+          type: "text",
+          text: `[glob tool: showing ${outcome.visibleItems} of ${outcome.totalItems} entries; narrow the pattern or scope to a specific path to reduce results.]`,
+        });
+      }
+
+      return {
+        content,
+        details: {
+          absolutePath,
+          pattern,
+          exclude,
+          includeDotfiles: includeDotfiles ?? false,
+          includeIgnored: includeIgnored ?? false,
+          pathFormat: resolvedPathFormat,
+          fileCount: matches.length,
+          totalItems: outcome.totalItems,
+          visibleItems: outcome.visibleItems,
+          truncated: outcome.truncated,
+        },
+      };
+    },
+    renderCall(args, theme, context) {
+      return renderTitle((args ?? {}) as Partial<GlobInput>, theme, context);
+    },
+    renderResult(result, options, theme, context) {
+      const state = context.state as GlobCallState;
+      const details = result.details as
+        | { readonly fileCount?: number }
+        | undefined;
+
+      if (details?.fileCount !== undefined) {
+        state.fileCount = details.fileCount;
+        renderTitle(context.args ?? {}, theme, context);
+      }
+
+      return Renderer.renderBorderedResult({
+        result,
+        options,
+        theme,
+        context,
+        previewLines: PREVIEW_LINES,
+      });
+    },
+  });
+}