pim-agent 0.0.1 → 0.9.0

package/packages/tui/src/extensions/footer/segments.ts

@@ -0,0 +1,202 @@
+import type {
+  ExtensionContext,
+  ThinkingLevelChangeEntry,
+} from "@earendil-works/pi-coding-agent";
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { Format } from "#core/shared/Format";
+import { Paths } from "#core/shared/Paths";
+import type { GitState } from "#core/shared/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 gitSegment(state: GitState): Segment | null {
+  const { branch, dirtyCount, ahead, behind } = state;
+  if (!branch) {
+    return null;
+  }
+  let text = `${GIT_ICON} ${branch}`;
+  if (dirtyCount > 0) {
+    text += ` ${GIT_DIRTY_ICON}${dirtyCount}`;
+  }
+  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
+      : dirtyCount > 0
+        ? 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 = Format.formatTokens(usage.contextWindow);
+  const text =
+    usage.percent === null
+      ? `?/${window}`
+      : `${usage.percent.toFixed(1)}%/${window}`;
+  const bg = {
+    full: BG_BRIGHT_RED,
+    warn: BG_BRIGHT_YELLOW,
+    ok: BG_BRIGHT_GREEN,
+  }[Format.contextFill(usage.percent ?? 0)];
+  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 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 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: [] },
+  ];
+
+  const gapOf = (c: { left: Segment[]; right: Segment[] }): number =>
+    c.left.length > 0 && c.right.length > 0 ? 1 : 0;
+  const fits = (c: { left: Segment[]; right: Segment[] }): boolean =>
+    groupWidth(c.left) + groupWidth(c.right) + gapOf(c) <= width;
+
+  const chosen = candidates.find(fits) ?? candidates.at(-1)!;
+  const rightWidth = groupWidth(chosen.right);
+
+  let left = chosen.left;
+  let leftWidth = groupWidth(left);
+  const requiredWidth = leftWidth + rightWidth + gapOf(chosen);
+  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 = groupWidth(left);
+  }
+
+  const gap =
+    left.length > 0 && chosen.right.length > 0
+      ? Math.max(1, width - leftWidth - rightWidth)
+      : 0;
+  return fitLine(
+    renderLeftGroup(left) + " ".repeat(gap) + renderRightGroup(chosen.right),
+    width
+  );
+}

package/packages/tui/src/extensions/pim/index.ts

@@ -0,0 +1,89 @@
+import {
+  DynamicBorder,
+  type ExtensionAPI,
+  getSettingsListTheme,
+} from "@earendil-works/pi-coding-agent";
+import {
+  type Component,
+  Container,
+  type SettingItem,
+  SettingsList,
+} from "@earendil-works/pi-tui";
+import {
+  ExtensionToggles,
+  type PimExtensionName,
+} from "#core/shared/ExtensionToggles";
+
+const ENABLED = "enabled";
+const DISABLED = "disabled";
+
+const MAX_VISIBLE = 12;
+
+export async function menuItems(): Promise<SettingItem[]> {
+  const disabled = new Set(await ExtensionToggles.disabled());
+  return ExtensionToggles.NAMES.filter(
+    (name) => !ExtensionToggles.isRequired(name)
+  ).map((name) => ({
+    id: name,
+    label: name,
+    description: ExtensionToggles.describe(name),
+    currentValue: disabled.has(name) ? DISABLED : ENABLED,
+    values: [ENABLED, DISABLED],
+  }));
+}
+
+export function createToggleMenu(
+  items: SettingItem[],
+  onToggle: (name: PimExtensionName, disabled: boolean) => void,
+  done: () => void
+): Component {
+  const container = new Container();
+  container.addChild(new DynamicBorder());
+  const list = new SettingsList(
+    items,
+    Math.min(items.length, MAX_VISIBLE),
+    getSettingsListTheme(),
+    (id, value) => {
+      onToggle(id as PimExtensionName, value === DISABLED);
+    },
+    done
+  );
+  container.addChild(list);
+  container.addChild(new DynamicBorder());
+  return {
+    invalidate: () => container.invalidate(),
+    render: (width) => container.render(width),
+    handleInput: (data) => list.handleInput(data),
+  };
+}
+
+export default function (pi: ExtensionAPI): void {
+  pi.registerCommand("pim", {
+    description: "Enable or disable pim extensions",
+    handler: async (_args, ctx) => {
+      if (ctx.mode !== "tui") {
+        ctx.ui.notify("/pim needs the interactive TUI", "warning");
+        return;
+      }
+
+      const writes: Promise<void>[] = [];
+      const items = await menuItems();
+      await ctx.ui.custom<void>((_tui, _theme, _keybindings, done) =>
+        createToggleMenu(
+          items,
+          (name, disabled) => {
+            writes.push(ExtensionToggles.setDisabled(name, disabled));
+          },
+          () => done()
+        )
+      );
+      if (writes.length === 0) {
+        return;
+      }
+      await Promise.all(writes);
+
+      // `ctx` is stale after this: `reload()` re-invokes every inline factory.
+      await ctx.reload();
+    },
+  });
+}

package/packages/tui/src/extensions/session-lease/index.ts

@@ -0,0 +1,248 @@
+import type {
+  ExtensionAPI,
+  ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+
+import { EventLog } from "#core/session/EventLog";
+import {
+  type LeaseHandle,
+  type LeaseRecord,
+  SessionLease,
+} from "#core/session/SessionLease";
+import { WriteMark } from "#core/session/WriteMark";
+
+const POLL_MS = 2_000;
+
+/** Survives the extension instance: `switchSession` re-runs every factory. */
+let carried: { readonly path: string; readonly text: string } | undefined;
+
+function isForeign(record: LeaseRecord | undefined): record is LeaseRecord {
+  return record !== undefined && !SessionLease.isOurs(record);
+}
+
+function describe(record: LeaseRecord): string {
+  return record.frontend === "daemon" ? "The browser" : "Another terminal";
+}
+
+function notify(
+  ctx: ExtensionContext,
+  message: string,
+  level: "info" | "warning" | "error" = "warning"
+): void {
+  if (ctx.hasUI) {
+    ctx.ui.notify(message, level);
+  }
+}
+
+export default function (pi: ExtensionAPI): void {
+  let manager: ExtensionContext["sessionManager"] | undefined;
+  let path: string | undefined;
+  let log: EventLog | undefined;
+  let mark: WriteMark = WriteMark.UNREAD;
+  let stale = false;
+  let holder: LeaseRecord | undefined;
+  let handle: LeaseHandle | undefined;
+  let syncing = false;
+  let stopWatch: (() => void) | undefined;
+  let poll: ReturnType<typeof setInterval> | undefined;
+
+  const measure = async (): Promise<WriteMark | undefined> => {
+    if (log === undefined || manager === undefined) {
+      return undefined;
+    }
+    return await WriteMark.of(log, manager);
+  };
+
+  /** Absorb our own appends; anything else is another surface writing this session. */
+  const reconcile = async (): Promise<void> => {
+    const next = await measure();
+    if (next === undefined) {
+      return;
+    }
+    if (WriteMark.foreignSince(mark, next)) {
+      stale = true;
+      return;
+    }
+    mark = next;
+  };
+
+  /** Whatever the file says right now is the truth pi was opened on. */
+  const anchor = async (): Promise<void> => {
+    mark = (await measure()) ?? WriteMark.UNREAD;
+    stale = false;
+  };
+
+  const refresh = async (): Promise<void> => {
+    const current = path;
+    if (current === undefined) {
+      return;
+    }
+    holder = await SessionLease.read(current);
+    await reconcile();
+  };
+
+  const stopIdleWatch = (): void => {
+    stopWatch?.();
+    stopWatch = undefined;
+    if (poll !== undefined) {
+      clearInterval(poll);
+      poll = undefined;
+    }
+  };
+
+  // Idle only: during our own turn every append is ours and the lease is held.
+  const startIdleWatch = (): void => {
+    stopIdleWatch();
+    const current = path;
+    if (current === undefined) {
+      return;
+    }
+    const tick = (): void => {
+      void refresh().catch(() => undefined);
+    };
+    stopWatch = SessionLease.watch(current, tick);
+    poll = setInterval(tick, POLL_MS);
+    poll.unref?.();
+  };
+
+  const pointAt = (next: string | undefined): void => {
+    path = next;
+    log = next === undefined ? undefined : new EventLog(next);
+    mark = WriteMark.UNREAD;
+    stale = false;
+    holder = undefined;
+  };
+
+  const release = async (): Promise<void> => {
+    const held = handle;
+    handle = undefined;
+    await held?.release();
+  };
+
+  pi.on("session_start", async (_event, ctx) => {
+    manager = ctx.sessionManager;
+    handle = undefined;
+    syncing = false;
+    pointAt(ctx.sessionManager.getSessionFile());
+    await anchor();
+    startIdleWatch();
+
+    const stash = carried;
+    carried = undefined;
+    if (stash !== undefined && stash.path === path) {
+      notify(ctx, `Caught up — your message was not sent: ${stash.text}`);
+    }
+  });
+
+  pi.on("input", async (event, ctx) => {
+    if (event.streamingBehavior !== undefined || path === undefined) {
+      return { action: "continue" };
+    }
+    await refresh();
+
+    if (isForeign(holder)) {
+      notify(
+        ctx,
+        `${describe(holder)} is running a turn. Try again when it finishes.`
+      );
+      return { action: "handled" };
+    }
+    if (!stale) {
+      return { action: "continue" };
+    }
+
+    if (event.text.trim() !== "") {
+      carried = { path, text: event.text };
+    }
+    notify(ctx, "This session was continued elsewhere — catching up.");
+    if (!syncing) {
+      syncing = true;
+      // Deferred: dispatching inside `emitInput` tears the session down under its own stack.
+      setTimeout(() => {
+        pi.sendUserMessage("/sync", { expandPromptTemplates: true });
+      }, 0);
+    }
+    return { action: "handled" };
+  });
+
+  pi.on("before_agent_start", async (_event, ctx) => {
+    stopIdleWatch();
+    const current = path;
+    if (current === undefined || handle !== undefined) {
+      return;
+    }
+    const result = await SessionLease.acquire(current, "tui");
+    if (result.ok) {
+      handle = result.handle;
+      return;
+    }
+    notify(
+      ctx,
+      isForeign(result.holder)
+        ? `${describe(result.holder)} just started a turn. Try again when it finishes.`
+        : "This session's turn lease is held elsewhere. Try again in a moment."
+    );
+    ctx.abort();
+  });
+
+  pi.on("agent_settled", async (_event, ctx) => {
+    await release();
+    manager = ctx.sessionManager;
+    const file = ctx.sessionManager.getSessionFile();
+    if (file !== path) {
+      pointAt(file);
+    }
+    await reconcile();
+    startIdleWatch();
+  });
+
+  pi.on("session_shutdown", async () => {
+    stopIdleWatch();
+    await release();
+  });
+
+  pi.registerCommand("sync", {
+    description: "Reload this session from disk after another surface wrote it",
+    handler: async (_args, ctx) => {
+      syncing = false;
+      const current = path;
+      if (current === undefined) {
+        notify(ctx, "This session is not on disk yet — nothing to sync.");
+        return;
+      }
+      if (!ctx.isIdle()) {
+        notify(ctx, "Wait for the current turn to finish, then run /sync.");
+        return;
+      }
+      // A missing or unreadable file makes pi's session replacement exit the process.
+      if (!(await Bun.file(current).exists())) {
+        notify(ctx, `Session file is gone: ${current}`, "error");
+        return;
+      }
+      const held = await SessionLease.read(current);
+      if (isForeign(held)) {
+        notify(
+          ctx,
+          `${describe(held)} is running a turn. Try /sync when it finishes.`
+        );
+        return;
+      }
+      try {
+        // Reopening repairs a torn tail and rewrites on migration, so hold the lease over it.
+        await SessionLease.hold(
+          current,
+          "tui",
+          async () => {
+            const result = await ctx.switchSession(current);
+            if (result.cancelled) {
+              notify(ctx, "Sync cancelled.");
+            }
+          },
+          { timeoutMs: 0 }
+        );
+      } catch (err) {
+        notify(ctx, err instanceof Error ? err.message : String(err), "error");
+      }
+    },
+  });
+}

package/packages/tui/src/extensions/tps/index.ts

@@ -0,0 +1,118 @@
+import type { AssistantMessageEvent } from "@earendil-works/pi-ai";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+type RequestTiming = {
+  readonly sentMs: number;
+  firstOutputMs: number | null;
+};
+
+function isOutputEvent(event: AssistantMessageEvent): boolean {
+  switch (event.type) {
+    case "text_delta":
+    case "thinking_delta":
+    case "toolcall_delta":
+      return event.delta.length > 0;
+    case "text_end":
+    case "thinking_end":
+      return event.content.length > 0;
+    case "toolcall_end":
+      return true;
+    default:
+      return false;
+  }
+}
+
+export default function (pi: ExtensionAPI): void {
+  let requestTiming: RequestTiming | null = null;
+
+  let promptTokens = 0;
+  let prefillMs = 0;
+  let outputTokens = 0;
+  let decodeMs = 0;
+  let cacheReadTokens = 0;
+  let firstTtftMs: number | null = null;
+
+  pi.on("agent_start", () => {
+    promptTokens = 0;
+    prefillMs = 0;
+    outputTokens = 0;
+    decodeMs = 0;
+    cacheReadTokens = 0;
+    firstTtftMs = null;
+  });
+
+  pi.on("before_provider_request", () => {
+    requestTiming = {
+      sentMs: Date.now(),
+      firstOutputMs: null,
+    };
+  });
+
+  pi.on("message_update", (event) => {
+    if (
+      event.message.role === "assistant" &&
+      requestTiming !== null &&
+      requestTiming.firstOutputMs === null &&
+      isOutputEvent(event.assistantMessageEvent)
+    ) {
+      requestTiming.firstOutputMs = Date.now();
+    }
+  });
+
+  pi.on("message_end", (event) => {
+    if (event.message.role !== "assistant") {
+      return;
+    }
+
+    const timing = requestTiming;
+    const endedMs = Date.now();
+    requestTiming = null;
+    if (timing === null) {
+      return;
+    }
+
+    const usage = event.message.usage;
+    const responseMs = timing.firstOutputMs ?? endedMs;
+    const ttft = responseMs - timing.sentMs;
+    const decode = endedMs - responseMs;
+
+    if (firstTtftMs === null && ttft > 0) {
+      firstTtftMs = ttft;
+    }
+
+    const prefillCounted = (usage.input ?? 0) + (usage.cacheWrite ?? 0);
+    if (prefillCounted > 0 && ttft > 0) {
+      promptTokens += prefillCounted;
+      prefillMs += ttft;
+    }
+    if ((usage.output ?? 0) > 0 && decode > 0) {
+      outputTokens += usage.output;
+      decodeMs += decode;
+    }
+    cacheReadTokens += usage.cacheRead ?? 0;
+  });
+
+  pi.on("agent_end", (_event, ctx) => {
+    if (!ctx.hasUI) {
+      return;
+    }
+    if (decodeMs <= 0 && prefillMs <= 0) {
+      return;
+    }
+
+    const decodeTps = decodeMs > 0 ? outputTokens / (decodeMs / 1000) : 0;
+    const prefillTps = prefillMs > 0 ? promptTokens / (prefillMs / 1000) : 0;
+    const ttftSec = firstTtftMs !== null ? firstTtftMs / 1000 : 0;
+
+    const parts = [
+      `Decode: ${decodeTps.toFixed(1)} tps`,
+      `Prefill: ${prefillTps.toFixed(1)} tps`,
+    ];
+    if (cacheReadTokens > 0) {
+      parts.push(`Cache read: ${cacheReadTokens.toLocaleString()}`);
+    }
+    parts.push(`TTFT: ${ttftSec.toFixed(2)}s`);
+
+    ctx.ui.notify(parts.join(" | "), "info");
+  });
+}