@aaroncql/pim-agent 0.0.1

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

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

@@ -0,0 +1,148 @@
+import type { AssistantMessage } from "@earendil-works/pi-ai";
+import type {
+  ExtensionAPI,
+  ExtensionContext,
+  ReadonlyFooterDataProvider,
+} from "@earendil-works/pi-coding-agent";
+import type { Component, TUI } from "@earendil-works/pi-tui";
+import { PimSettings } from "../../shared/PimSettings";
+import { EMPTY_GIT, fetchGitStatus, type GitState, watchGitDir } from "./git";
+import { renderFooterLine } from "./segments";
+
+let activeGitRefresh: (() => void) | null = null;
+
+type FooterTui = Pick<TUI, "requestRender">;
+type FooterData = Pick<ReadonlyFooterDataProvider, "onBranchChange">;
+type FooterWidget = Component & { readonly dispose: () => void };
+
+type FooterWidgetDeps = {
+  readonly fetchGitStatus: (cwd: string) => Promise<GitState>;
+  readonly watchGitDir: (cwd: string, onChange: () => void) => () => void;
+  readonly renderFooterLine: (
+    width: number,
+    ctx: ExtensionContext,
+    gitState: GitState,
+    cost: number
+  ) => string;
+  readonly getTotalCost: (ctx: ExtensionContext) => number;
+};
+
+const DEFAULT_FOOTER_WIDGET_DEPS: FooterWidgetDeps = {
+  fetchGitStatus,
+  watchGitDir,
+  renderFooterLine,
+  getTotalCost,
+};
+
+export function getTotalCost(ctx: ExtensionContext): number {
+  let cost = 0;
+  for (const e of ctx.sessionManager.getEntries()) {
+    if (e.type === "message" && e.message.role === "assistant") {
+      cost += (e.message as AssistantMessage).usage.cost.total;
+    }
+  }
+  return cost;
+}
+
+export function createFooterWidget(
+  ctx: ExtensionContext,
+  tui: FooterTui,
+  footerData: FooterData,
+  deps: FooterWidgetDeps = DEFAULT_FOOTER_WIDGET_DEPS
+): FooterWidget {
+  let gitState: GitState = EMPTY_GIT;
+  let inFlight = false;
+  let pending = false;
+  const refresh = async (): Promise<void> => {
+    if (inFlight) {
+      pending = true;
+      return;
+    }
+    inFlight = true;
+    try {
+      do {
+        pending = false;
+        const next = await deps.fetchGitStatus(ctx.cwd);
+        if (
+          next.branch !== gitState.branch ||
+          next.dirty !== gitState.dirty ||
+          next.ahead !== gitState.ahead ||
+          next.behind !== gitState.behind
+        ) {
+          gitState = next;
+          tui.requestRender();
+        }
+      } while (pending);
+    } finally {
+      inFlight = false;
+    }
+  };
+  void refresh();
+  const unsubBranch = footerData.onBranchChange(() => {
+    void refresh();
+  });
+  const disposeGitWatch = deps.watchGitDir(ctx.cwd, () => {
+    void refresh();
+  });
+  activeGitRefresh = () => {
+    void refresh();
+  };
+  return {
+    invalidate(): void {},
+    render(width: number): string[] {
+      return [
+        deps.renderFooterLine(width, ctx, gitState, deps.getTotalCost(ctx)),
+      ];
+    },
+    dispose(): void {
+      unsubBranch();
+      disposeGitWatch();
+      activeGitRefresh = null;
+    },
+  };
+}
+
+function installFooter(ctx: ExtensionContext): void {
+  if (!ctx.hasUI) {
+    return;
+  }
+  ctx.ui.setFooter((tui, _theme, footerData) => {
+    return createFooterWidget(ctx, tui, footerData);
+  });
+}
+
+export default function (pi: ExtensionAPI): void {
+  const apply = async (ctx: ExtensionContext): Promise<void> => {
+    if (!ctx.hasUI) {
+      return;
+    }
+    const { enabled } = await PimSettings.get("powerline");
+    if (enabled) {
+      installFooter(ctx);
+    } else {
+      ctx.ui.setFooter(undefined);
+    }
+  };
+
+  pi.registerCommand("powerline", {
+    description: "Toggle Pim powerline footer",
+    handler: async (_args, ctx) => {
+      const current = await PimSettings.get("powerline");
+      const next = { ...current, enabled: !current.enabled };
+      await PimSettings.set("powerline", next);
+      await apply(ctx);
+      ctx.ui.notify(
+        `Pim powerline footer ${next.enabled ? "enabled" : "disabled"}`,
+        "info"
+      );
+    },
+  });
+
+  pi.on("session_start", async (_event, ctx) => {
+    await apply(ctx);
+  });
+
+  pi.on("tool_execution_end", () => {
+    activeGitRefresh?.();
+  });
+}

package/src/extensions/footer/powerline.ts

@@ -0,0 +1,87 @@
+import { visibleWidth } from "@earendil-works/pi-tui";
+
+export const SEP_RIGHT = "";
+export const SEP_LEFT = "";
+export const SEP_THIN_LEFT = "";
+
+export const GIT_ICON = "";
+export const GIT_DIRTY_ICON = "";
+export const GIT_AHEAD_ICON = "";
+export const GIT_BEHIND_ICON = "";
+
+export const RESET = "\x1b[0m";
+export const BG_DEFAULT = "\x1b[49m";
+export const REVERSE = "\x1b[7m";
+export const RESET_REVERSE = "\x1b[27m";
+
+export const FG_BLACK = "\x1b[30m";
+export const FG_WHITE = "\x1b[97m";
+export const BG_GRAY = "\x1b[100m";
+export const BG_BRIGHT_RED = "\x1b[101m";
+export const BG_BRIGHT_GREEN = "\x1b[102m";
+export const BG_BRIGHT_YELLOW = "\x1b[103m";
+export const BG_BRIGHT_MAGENTA = "\x1b[105m";
+
+export const BG_TO_FG: Record<string, string> = {
+  [BG_GRAY]: "\x1b[90m",
+  [BG_BRIGHT_RED]: "\x1b[91m",
+  [BG_BRIGHT_GREEN]: "\x1b[92m",
+  [BG_BRIGHT_YELLOW]: "\x1b[93m",
+  [BG_BRIGHT_MAGENTA]: "\x1b[95m",
+};
+
+export type Segment = {
+  readonly text: string;
+  readonly fg: string;
+  readonly bg: string;
+};
+
+export function paint(seg: Segment): string {
+  return `${seg.bg}${seg.fg} ${seg.text} ${RESET}`;
+}
+
+export function chevronRight(prev: Segment, next: Segment | null): string {
+  const fg = BG_TO_FG[prev.bg]!;
+  if (next === null) {
+    return `${fg}${SEP_RIGHT}${RESET}`;
+  }
+  return `${fg}${next.bg}${SEP_RIGHT}${RESET}`;
+}
+
+export function chevronLeft(prev: Segment | null, next: Segment): string {
+  const fg = BG_TO_FG[next.bg]!;
+  if (prev === null) {
+    return `${fg}${SEP_LEFT}${RESET}`;
+  }
+  return `${fg}${prev.bg}${SEP_LEFT}${RESET}`;
+}
+
+export function thinChevronLeft(bg: string, fg: string): string {
+  return `${BG_DEFAULT}${BG_TO_FG[bg]}${REVERSE}${SEP_THIN_LEFT}${RESET_REVERSE}${bg}${fg}`;
+}
+
+export function renderLeftGroup(segs: readonly Segment[]): string {
+  let out = "";
+  for (let i = 0; i < segs.length; i++) {
+    out += paint(segs[i]!);
+    out += chevronRight(segs[i]!, segs[i + 1] ?? null);
+  }
+  return out;
+}
+
+export function renderRightGroup(segs: readonly Segment[]): string {
+  let out = "";
+  for (let i = 0; i < segs.length; i++) {
+    out += chevronLeft(segs[i - 1] ?? null, segs[i]!);
+    out += paint(segs[i]!);
+  }
+  return out;
+}
+
+export function groupWidth(segs: readonly Segment[]): number {
+  let w = 0;
+  for (const s of segs) {
+    w += visibleWidth(s.text) + 3;
+  }
+  return w;
+}

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

@@ -0,0 +1,164 @@
+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");
+  });
+});