pim-agent 0.0.1 → 0.10.0

package/packages/telegram/src/UpdateConfirm.ts

@@ -0,0 +1,61 @@
+import { unlink } from "node:fs/promises";
+import { join } from "node:path";
+
+import { Fs } from "#core/shared/Fs";
+
+const CONFIRM_FILE = "update-confirm.json";
+
+/** The "🔄 Updating..." message to edit once the restarted daemon is back. */
+export type UpdateConfirmEntry = {
+  readonly chatId: number;
+  readonly threadId: number | undefined;
+  readonly messageId: number;
+};
+
+async function append(
+  configDir: string,
+  entry: UpdateConfirmEntry
+): Promise<void> {
+  const merged = [...(await read(configDir)), entry];
+  await Fs.writeAtomic(
+    updateConfirmPath(configDir),
+    JSON.stringify(merged, null, 2)
+  );
+}
+
+async function read(
+  configDir: string
+): Promise<ReadonlyArray<UpdateConfirmEntry>> {
+  const data = await Fs.readJsonOrEmpty<unknown[]>(
+    updateConfirmPath(configDir),
+    []
+  );
+  if (!Array.isArray(data)) {
+    return [];
+  }
+  return data.filter(
+    (e): e is UpdateConfirmEntry =>
+      !!e &&
+      typeof e === "object" &&
+      typeof (e as UpdateConfirmEntry).chatId === "number" &&
+      ((e as UpdateConfirmEntry).threadId === undefined ||
+        typeof (e as UpdateConfirmEntry).threadId === "number") &&
+      typeof (e as UpdateConfirmEntry).messageId === "number"
+  );
+}
+
+async function clear(configDir: string): Promise<void> {
+  try {
+    await unlink(updateConfirmPath(configDir));
+  } catch (err) {
+    if ((err as NodeJS.ErrnoException).code !== "ENOENT") {
+      console.warn(`[update-confirm] unlink failed:`, err);
+    }
+  }
+}
+
+function updateConfirmPath(configDir: string): string {
+  return join(configDir, CONFIRM_FILE);
+}
+
+export const UpdateConfirm = { append, read, clear };

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

@@ -0,0 +1,144 @@
+import type {
+  ExtensionAPI,
+  ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+
+import { PimVersion } from "#core/shared/PimVersion";
+
+const SPLASH_ID = "pim-splash";
+const UPDATE_CHECK_TIMEOUT_MS = 3_000;
+
+const shortcuts = [
+  ["Ctrl+C", "Clear editor (first) / exit (second)"],
+  ["Escape", "Cancel autocomplete / abort streaming"],
+  ["/<command>", "Slash commands", "<command>"],
+  ["/hotkeys", "Show all keyboard shortcuts"],
+  ["/settings", "Open settings menu"],
+  ["/pim", "Enable or disable pim extensions"],
+  ["@<path>", "Attach files", "<path>"],
+  ["!<command>", "Run bash command", "<command>"],
+  ["!!<command>", "Run bash command (excluded from context)", "<command>"],
+] as const;
+
+export default async function (pi: ExtensionAPI): Promise<void> {
+  if (typeof Bun === "undefined") {
+    throw new Error(
+      "Pim requires the Bun runtime.\n" +
+        "To run Pim: bun install -g pim-agent, then run `pim`.\n" +
+        "To run vanilla Pi without Pim: `pi -ne`."
+    );
+  }
+
+  const version = await PimVersion.current();
+
+  const keyCol = Math.max(...shortcuts.map(([k]) => k.length)) + 2;
+
+  let splashShown = false;
+  let update: string | undefined;
+  let updateCheck: Promise<string | undefined> | undefined;
+
+  const checkForUpdate = (): Promise<string | undefined> => {
+    updateCheck ??= process.env["PI_OFFLINE"]
+      ? Promise.resolve(undefined)
+      : PimVersion.latest({ timeoutMs: UPDATE_CHECK_TIMEOUT_MS }).then(
+          (available) =>
+            available !== undefined && PimVersion.isNewer(available, version)
+              ? available
+              : undefined
+        );
+    return updateCheck;
+  };
+
+  const showSplash = (ctx: ExtensionContext): void => {
+    const theme = ctx.ui.theme;
+    const renderKey = (key: string, muted: string | undefined): string => {
+      const padding = " ".repeat(Math.max(0, keyCol - key.length));
+      if (!muted) {
+        return theme.fg("mdCode", key + padding);
+      }
+      const idx = key.indexOf(muted);
+      if (idx === -1) {
+        return theme.fg("mdCode", key + padding);
+      }
+      return (
+        theme.fg("mdCode", key.slice(0, idx)) +
+        theme.fg("muted", muted) +
+        key.slice(idx + muted.length) +
+        padding
+      );
+    };
+
+    const title =
+      theme.bold(theme.fg("accent", "PIM - Pi IMproved")) +
+      " " +
+      theme.italic(theme.fg("muted", `v${version}`));
+    ctx.ui.setWidget(SPLASH_ID, [
+      title,
+      ...shortcuts.map(
+        ([k, d, muted]) => renderKey(k, muted) + theme.fg("dim", d)
+      ),
+      ...(update === undefined
+        ? []
+        : [
+            "",
+            theme.fg("warning", `Update available: v${update}`) +
+              theme.fg("dim", " - run ") +
+              theme.fg("mdCode", "pim update"),
+          ]),
+    ]);
+    splashShown = true;
+  };
+
+  pi.on("session_start", (event, ctx) => {
+    if (event.reason !== "startup" && event.reason !== "new") {
+      return;
+    }
+
+    showSplash(ctx);
+    void checkForUpdate().then((available) => {
+      if (available === undefined || !splashShown) {
+        return;
+      }
+      update = available;
+      showSplash(ctx);
+    });
+  });
+
+  const clearSplash = (ctx: ExtensionContext) => {
+    if (splashShown) {
+      ctx.ui.setWidget(SPLASH_ID, undefined);
+      splashShown = false;
+    }
+  };
+
+  pi.on("input", (_event, ctx) => {
+    clearSplash(ctx);
+    return { action: "continue" };
+  });
+  pi.on("user_bash", (_event, ctx) => {
+    clearSplash(ctx);
+  });
+  pi.on("model_select", (_event, ctx) => {
+    clearSplash(ctx);
+  });
+  pi.on("thinking_level_select", (_event, ctx) => {
+    clearSplash(ctx);
+  });
+  pi.on("session_before_fork", (_event, ctx) => {
+    clearSplash(ctx);
+  });
+  pi.on("session_before_tree", (_event, ctx) => {
+    clearSplash(ctx);
+  });
+  pi.on("session_before_compact", (_event, ctx) => {
+    clearSplash(ctx);
+  });
+
+  pi.registerCommand("clear", {
+    description: "Start a new session (alias: /new)",
+    handler: async (_args, ctx) => {
+      await ctx.waitForIdle();
+      await ctx.newSession();
+    },
+  });
+}

package/packages/tui/src/extensions/command-picker/index.ts

@@ -0,0 +1,75 @@
+import type {
+  AutocompleteProviderFactory,
+  ExtensionAPI,
+} from "@earendil-works/pi-coding-agent";
+import type { AutocompleteProvider } from "@earendil-works/pi-tui";
+import { rankCommands } from "#core/picker/commandRanker";
+import { SLASH_PREFIX } from "#core/picker/token";
+import { wrapProvider } from "../wrapProvider";
+
+const MAX_VISIBLE_ROWS = 10;
+const SLASH_LINES = ["/"];
+
+export function createCommandPickerProviderFactory(): AutocompleteProviderFactory {
+  return (current: AutocompleteProvider): AutocompleteProvider => {
+    let answered: string | undefined;
+
+    return wrapProvider(current, {
+      async getSuggestions(lines, cursorLine, cursorCol, options) {
+        answered = undefined;
+        const line = lines[cursorLine] ?? "";
+        const beforeCursor = line.slice(0, cursorCol);
+
+        const slashMatch = beforeCursor.match(SLASH_PREFIX);
+        if (!slashMatch) {
+          return current.getSuggestions(lines, cursorLine, cursorCol, options);
+        }
+
+        const all = await current.getSuggestions(SLASH_LINES, 0, 1, options);
+        if (all === null) {
+          return null;
+        }
+
+        const query = slashMatch[1] ?? "";
+        const items = rankCommands(query, all.items, {
+          limit: MAX_VISIBLE_ROWS,
+        });
+        if (items.length === 0) {
+          return null;
+        }
+        answered = `/${query}`;
+        return { items, prefix: answered };
+      },
+
+      // Pi completes a slash command only where it opens the line; ours sits anywhere in it.
+      applyCompletion(lines, cursorLine, cursorCol, item, prefix) {
+        if (prefix !== answered) {
+          return current.applyCompletion(
+            lines,
+            cursorLine,
+            cursorCol,
+            item,
+            prefix
+          );
+        }
+        const line = lines[cursorLine] ?? "";
+        const head = line.slice(0, cursorCol - prefix.length);
+        const tail = line.slice(cursorCol);
+        const inserted = `/${item.value}${/^\s/.test(tail) ? "" : " "}`;
+        const next = [...lines];
+        next[cursorLine] = `${head}${inserted}${tail}`;
+        return {
+          lines: next,
+          cursorLine,
+          cursorCol: head.length + inserted.length,
+        };
+      },
+    });
+  };
+}
+
+export default function (pi: ExtensionAPI): void {
+  pi.on("session_start", (_event, ctx) => {
+    ctx.ui.addAutocompleteProvider(createCommandPickerProviderFactory());
+  });
+}

package/packages/tui/src/extensions/file-picker/index.ts

@@ -0,0 +1,156 @@
+import type {
+  AutocompleteProviderFactory,
+  ExtensionAPI,
+} from "@earendil-works/pi-coding-agent";
+import type { AutocompleteProvider } from "@earendil-works/pi-tui";
+import type { FilePickerSuggestionEngine } from "#core/picker/FilePickerSuggestionEngine";
+import { AT_PREFIX, isDirectoryItem, sigilOffset } from "#core/picker/token";
+import { WorkerFilePickerSuggestionEngine } from "#core/picker/WorkerFilePickerSuggestionEngine";
+import { wrapProvider } from "../wrapProvider";
+
+const MAX_VISIBLE_ROWS = 50;
+
+// Pi cancels autocomplete after Tab; re-enter Tab next tick to keep drilling.
+function keepDrilling(): void {
+  setTimeout(() => {
+    try {
+      process.stdin.emit("data", "\t");
+    } catch {}
+  }, 0);
+}
+
+function sameActiveAtToken(
+  a: ActiveAtToken | undefined,
+  b: ActiveAtToken
+): boolean {
+  return a?.cursorLine === b.cursorLine && a.atCol === b.atCol;
+}
+
+export type FilePickerProviderFactoryOptions = {
+  readonly engine: FilePickerSuggestionEngine;
+};
+
+type ActiveAtToken = {
+  readonly cursorLine: number;
+  readonly atCol: number;
+};
+
+export function createFilePickerProviderFactory(
+  options: FilePickerProviderFactoryOptions
+): AutocompleteProviderFactory {
+  const refreshRelative = (): void => {
+    void options.engine.refreshRelative();
+  };
+
+  return (current: AutocompleteProvider): AutocompleteProvider => {
+    let activeAtToken: ActiveAtToken | undefined;
+
+    return wrapProvider(current, {
+      async getSuggestions(lines, cursorLine, cursorCol, autocompleteOptions) {
+        const line = lines[cursorLine] ?? "";
+        const beforeCursor = line.slice(0, cursorCol);
+
+        const atMatch = beforeCursor.match(AT_PREFIX);
+        if (!atMatch) {
+          activeAtToken = undefined;
+          return current.getSuggestions(
+            lines,
+            cursorLine,
+            cursorCol,
+            autocompleteOptions
+          );
+        }
+
+        const query = atMatch[1] ?? "";
+        const atToken = { cursorLine, atCol: sigilOffset(atMatch) };
+        if (!sameActiveAtToken(activeAtToken, atToken)) {
+          activeAtToken = atToken;
+          refreshRelative();
+        }
+
+        const items = await options.engine
+          .rank(query, {
+            limit: MAX_VISIBLE_ROWS,
+            signal: autocompleteOptions.signal,
+          })
+          .catch(() => undefined);
+        if (items === undefined) {
+          return current.getSuggestions(
+            lines,
+            cursorLine,
+            cursorCol,
+            autocompleteOptions
+          );
+        }
+        if (items.length === 0) {
+          return null;
+        }
+        return {
+          items: items.map((item) => ({
+            ...item,
+            value: `@${item.value}`,
+          })),
+          prefix: `@${query}`,
+        };
+      },
+
+      applyCompletion(lines, cursorLine, cursorCol, item, prefix) {
+        // Pi appends a trailing space after file completions; apply @ items here instead.
+        if (prefix.startsWith("@")) {
+          const line = lines[cursorLine] ?? "";
+          const beforePrefix = line.slice(0, cursorCol - prefix.length);
+          const afterCursor = line.slice(cursorCol);
+          const hasTrailingQuote = item.value.endsWith('"');
+          const adjustedAfterCursor =
+            prefix.startsWith('@"') &&
+            hasTrailingQuote &&
+            afterCursor.startsWith('"')
+              ? afterCursor.slice(1)
+              : afterCursor;
+
+          const newLines = [...lines];
+          newLines[cursorLine] =
+            `${beforePrefix}${item.value}${adjustedAfterCursor}`;
+
+          const isDirectory = isDirectoryItem(item);
+          const cursorOffset =
+            isDirectory && hasTrailingQuote
+              ? item.value.length - 1
+              : item.value.length;
+
+          if (isDirectory) {
+            keepDrilling();
+          }
+
+          return {
+            lines: newLines,
+            cursorLine,
+            cursorCol: beforePrefix.length + cursorOffset,
+          };
+        }
+
+        const result = current.applyCompletion(
+          lines,
+          cursorLine,
+          cursorCol,
+          item,
+          prefix
+        );
+        if (item.value.endsWith("/")) {
+          keepDrilling();
+        }
+        return result;
+      },
+    });
+  };
+}
+
+export default function (pi: ExtensionAPI): void {
+  pi.on("session_start", (_event, ctx) => {
+    ctx.ui.addAutocompleteProvider(
+      createFilePickerProviderFactory({
+        engine: new WorkerFilePickerSuggestionEngine(ctx.cwd),
+      })
+    );
+  });
+}

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

@@ -0,0 +1,93 @@
+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 type { GitState } from "#core/shared/Git";
+import { GitMonitor } from "#core/shared/GitMonitor";
+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 renderFooterLine: (
+    width: number,
+    ctx: ExtensionContext,
+    gitState: GitState,
+    cost: number
+  ) => string;
+  readonly getTotalCost: (ctx: ExtensionContext) => number;
+};
+
+const DEFAULT_FOOTER_WIDGET_DEPS: FooterWidgetDeps = {
+  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,
+  monitor: GitMonitor,
+  deps: FooterWidgetDeps = DEFAULT_FOOTER_WIDGET_DEPS
+): FooterWidget {
+  const refresh = (): void => {
+    void monitor.refresh(ctx.cwd);
+  };
+  // The monitor holds the state; a copy here would be a second one to keep.
+  const unwatch = monitor.watch(ctx.cwd, () => {
+    tui.requestRender();
+  });
+  const unsubBranch = footerData.onBranchChange(refresh);
+  activeGitRefresh = refresh;
+  return {
+    invalidate(): void {},
+    render(width: number): string[] {
+      return [
+        deps.renderFooterLine(
+          width,
+          ctx,
+          monitor.stateOf(ctx.cwd),
+          deps.getTotalCost(ctx)
+        ),
+      ];
+    },
+    dispose(): void {
+      unsubBranch();
+      unwatch();
+      activeGitRefresh = null;
+    },
+  };
+}
+
+export default function (pi: ExtensionAPI): void {
+  const monitor = new GitMonitor();
+  pi.on("session_start", (_event, ctx) => {
+    if (!ctx.hasUI) {
+      return;
+    }
+    ctx.ui.setFooter((tui, _theme, footerData) =>
+      createFooterWidget(ctx, tui, footerData, monitor)
+    );
+  });
+
+  pi.on("tool_execution_end", () => {
+    activeGitRefresh?.();
+  });
+}

package/packages/tui/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;
+}