bermudis-pi-goodies 0.2.0 → 0.3.0

package/README.md

@@ -1,11 +1,12 @@
 # bermudis-pi-goodies
 
 A bundle of small, frequently-used [Pi](https://github.com/earendil-works/pi)
-extensions. One entry point, nine independent features.
+extensions. One entry point, ten independent features.
 
 | Feature | Command / hook | What it does |
 |---------|----------------|--------------|
 | `copy-with-model` | `/copy-with-model` | Copy last assistant message to the clipboard in a code fence tagged with the model name. |
+| `copy-trajectory` | `/copy-trajectory [thinking]` | Copy the whole conversation (user + assistant text, tool calls stripped) to the clipboard; `thinking` also includes assistant thinking blocks. |
 | `name-with-ai` | `/name-with-ai [name]` | Generate a short session name from the first user message (or set one manually). |
 | `zed` | `/z` | Open Zed editor on the current working directory. |
 | `prefer-tools` | hook (no command) | Nudge toward modern CLIs: `rg` over `grep`, `fd` over `find`, `uv` over bare `python`/`pip`/`pytest`/`mypy`. |
@@ -20,7 +21,7 @@ extensions. One entry point, nine independent features.
 After publishing the package to npm:
 
 ```bash
-pi install npm:bermudis-pi-goodies@0.2.0
+pi install npm:bermudis-pi-goodies@0.3.0
 ```
 
 Remove any old `bermudis-pi-goodies.ts` symlink before reloading Pi. Each

package/copy-trajectory.ts

@@ -0,0 +1,166 @@
+/**
+ * copy-trajectory — /copy-trajectory
+ *
+ * Copies the current session's trajectory to the system clipboard as plain
+ * text, keeping only the human-readable conversation: user messages and
+ * assistant text. Tool calls, tool results, and session metadata are stripped.
+ *
+ *   /copy-trajectory            copy user + assistant text
+ *   /copy-trajectory thinking   also include assistant thinking blocks
+ *
+ * Uses ctx.sessionManager.getBranch() for the active (compaction-aware) branch
+ * and @earendil-works/pi-coding-agent's copyToClipboard for the clipboard write.
+ */
+
+import {
+  copyToClipboard,
+  type ExtensionAPI,
+  type SessionEntry,
+} from "@earendil-works/pi-coding-agent";
+
+const isRecord = (v: unknown): v is Record<string, unknown> =>
+  typeof v === "object" && v !== null;
+
+/** Extract `text` content blocks from a message body (string or block array). */
+const extractTextParts = (content: unknown): string[] => {
+  if (typeof content === "string") return [content];
+  if (!Array.isArray(content)) return [];
+  const parts: string[] = [];
+  for (const block of content) {
+    if (!isRecord(block)) continue;
+    if (block.type === "text" && typeof block.text === "string") {
+      parts.push(block.text);
+    }
+  }
+  return parts;
+};
+
+/** Extract `thinking` content blocks from an assistant message body. */
+const extractThinkingParts = (content: unknown): string[] => {
+  if (!Array.isArray(content)) return [];
+  const parts: string[] = [];
+  for (const block of content) {
+    if (!isRecord(block)) continue;
+    if (block.type === "thinking" && typeof block.thinking === "string") {
+      parts.push(block.thinking);
+    }
+  }
+  return parts;
+};
+
+type Turn = {
+  role: "User" | "Assistant";
+  /** For assistant turns: the model that actually served the reply (or the
+   *  requested model when the provider doesn't report the resolved one). */
+  model?: string;
+  body: string;
+};
+
+/** Build the readable turns from a branch of session entries. */
+function buildTrajectory(
+  entries: readonly SessionEntry[],
+  includeThinking: boolean,
+): Turn[] {
+  const turns: Turn[] = [];
+
+  for (const entry of entries) {
+    // getBranch() returns the full SessionEntry union; the `message` member
+    // is discriminated by `type: "message"`.
+    if (entry.type !== "message") continue;
+    const message = entry.message;
+    if (message.role !== "user" && message.role !== "assistant") continue;
+
+    const chunks: string[] = [...extractTextParts(message.content)];
+
+    let model: string | undefined;
+    if (message.role === "assistant") {
+      // AssistantMessage carries both the requested `model` and, when the
+      // provider echoes it back, `responseModel` (the model that actually ran).
+      model = message.responseModel ?? message.model;
+      if (includeThinking) {
+        for (const t of extractThinkingParts(message.content)) {
+          chunks.push(
+            t
+              .split("\n")
+              .map((line) => `> ${line}`)
+              .join("\n"),
+          );
+        }
+      }
+    }
+
+    const body = chunks.join("\n").trim();
+    if (!body) continue; // skip empty / tool-only turns
+
+    turns.push({
+      role: message.role === "user" ? "User" : "Assistant",
+      model,
+      body,
+    });
+  }
+
+  return turns;
+}
+
+const renderTrajectory = (turns: readonly Turn[]): string =>
+  turns
+    .map((t) => {
+      const header =
+        t.role === "Assistant" && t.model
+          ? `## Assistant (${t.model})`
+          : `## ${t.role}`;
+      return `${header}\n\n${t.body}`;
+    })
+    .join("\n\n");
+
+export default function (pi: ExtensionAPI) {
+  pi.registerCommand("copy-trajectory", {
+    description:
+      "Copy the conversation (user + assistant text, no tool calls) to the clipboard",
+    getArgumentCompletions: (prefix) => {
+      const opts = ["thinking"].filter((o) => o.startsWith(prefix));
+      return opts.length > 0 ? opts.map((o) => ({ value: o, label: o })) : null;
+    },
+    handler: async (args, ctx) => {
+      // Don't snapshot a half-streamed message.
+      await ctx.waitForIdle();
+
+      const arg = args.trim();
+      if (arg !== "" && arg !== "thinking") {
+        ctx.ui.notify(
+          `Unknown argument ${JSON.stringify(arg)}. Usage: /copy-trajectory [thinking]`,
+          "warning",
+        );
+        return;
+      }
+      const includeThinking = arg === "thinking";
+
+      const turns = buildTrajectory(
+        ctx.sessionManager.getBranch(),
+        includeThinking,
+      );
+
+      if (turns.length === 0) {
+        ctx.ui.notify("No messages to copy yet", "warning");
+        return;
+      }
+
+      const text = renderTrajectory(turns);
+
+      try {
+        await copyToClipboard(text);
+      } catch (err) {
+        ctx.ui.notify(
+          `Failed to copy: ${err instanceof Error ? err.message : String(err)}`,
+          "error",
+        );
+        return;
+      }
+
+      ctx.ui.notify(
+        `Copied ${turns.length} message${turns.length === 1 ? "" : "s"} (${text.length.toLocaleString()} chars) to clipboard`,
+        "info",
+      );
+    },
+  });
+}

package/index.ts

@@ -4,6 +4,7 @@
  * Composes independent modules, each registering its own commands/hooks
  * against the shared ExtensionAPI:
  *   - copy-with-model  /copy-with-model  copy last reply tagged with the model
+ *   - copy-trajectory  /copy-trajectory  copy the whole conversation (text only) to the clipboard
  *   - name-with-ai     /name-with-ai     generate a session name via the model
  *   - zed              /z                open Zed on cwd
  *   - prefer-tools     hook              block legacy tools (use trash/rg/fd/uv)
@@ -14,6 +15,7 @@
  *   - tps              hook              notify tokens/sec and usage at each agent turn end
  */
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import copyTrajectory from "./copy-trajectory.ts";
 import copyWithModel from "./copy-with-model.ts";
 import fixedDefaults from "./fixed-defaults.ts";
 import kilo from "./kilo.ts";
@@ -26,6 +28,7 @@ import preferTools from "./prefer-tools.ts";
 
 export default function bermudisPiGoodies(pi: ExtensionAPI): void {
   copyWithModel(pi);
+  copyTrajectory(pi);
   nameWithAi(pi);
   zed(pi);
   preferTools(pi);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bermudis-pi-goodies",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "private": false,
   "description": "A bundle of small, frequently-used Pi extensions.",
   "keywords": ["pi-package"],

package/provider-balance.ts

@@ -5,6 +5,8 @@ import type {
   ExtensionContext,
 } from "@earendil-works/pi-coding-agent";
 import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { readFileSync, renameSync, mkdirSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
 
 const KILO_API_BASE = process.env.KILO_API_URL || "https://api.kilo.ai";
 const KILO_BALANCE_ENDPOINT = `${KILO_API_BASE}/api/profile/balance`;
@@ -23,6 +25,23 @@ const BALANCE_FETCH_TIMEOUT_MS = 5_000;
 /** Refresh the footer balance every Nth turn end during a run. See turn_end handler. */
 const REFRESH_EVERY_N_TURNS = 5;
 
+/**
+ * Balance cache shared across every pi process on the machine, keyed by
+ * provider. Two motivations:
+ *
+ * 1. The user runs several pi instances against the same metered account
+ *    (quota/credits are per-account, not per-session), so every session may
+ *    show the freshest reading any instance fetched.
+ * 2. On session switch pi tears this runtime down and reloads the extension
+ *    for the new session (session_shutdown reason "resume" -> session_start
+ *    reason "resume"), wiping in-memory state. Without a shared cache the new
+ *    session's footer is blank/stale until its own first fetch lands, which
+ *    can be agent_settled or the 5th turn_end.
+ */
+const BALANCE_CACHE_FILE = `${process.env.HOME ?? ""}/.pi/agent/cache/provider-balance.json`;
+/** Ignore cache entries older than this; stale balances mislead. */
+const BALANCE_CACHE_TTL_MS = 30 * 60 * 1000;
+
 interface BalanceAdapter {
   fetch(token: string, signal: AbortSignal): Promise<Balance>;
   requiresOAuth?: boolean;
@@ -538,6 +557,100 @@ const BALANCE_ADAPTERS: Readonly<Record<string, BalanceAdapter>> = {
   "openai-codex": { fetch: fetchCodexQuota, requiresOAuth: true },
 };
 
+// --- Shared balance cache ---------------------------------------------------
+
+interface BalanceCacheEntry {
+  fetchedAt: number;
+  balance: Balance;
+}
+
+type BalanceCache = Record<string, BalanceCacheEntry>;
+
+function parseCachedBalance(value: unknown): Balance | null {
+  if (!Array.isArray(value)) return null;
+  const segments: BalanceSegment[] = [];
+  for (const candidate of value) {
+    const segment = asRecord(candidate);
+    if (!segment) return null;
+    const credits = numericProperty(segment, "credits");
+    const quotaRecord = asRecord(segment.quota);
+    const remainingPercent = numericProperty(quotaRecord, "remainingPercent");
+    if (
+      credits === null &&
+      (quotaRecord === null || remainingPercent === null)
+    ) {
+      return null;
+    }
+    const label = stringProperty(segment, "label") ?? undefined;
+    const windowSeconds = numericProperty(quotaRecord, "windowSeconds");
+    const resetAt = numericProperty(quotaRecord, "resetAt");
+    segments.push({
+      ...(label !== undefined ? { label } : {}),
+      ...(credits !== null ? { credits } : {}),
+      ...(quotaRecord !== null && remainingPercent !== null
+        ? {
+            quota: {
+              remainingPercent,
+              ...(windowSeconds !== null ? { windowSeconds } : {}),
+              ...(resetAt !== null ? { resetAt } : {}),
+            },
+          }
+        : {}),
+    });
+  }
+  return segments;
+}
+
+/** Read the freshest non-expired cached balance for a provider. */
+export function readCachedBalance(
+  provider: string,
+  nowMs = Date.now(),
+): Balance | null {
+  let raw: string;
+  try {
+    raw = readFileSync(BALANCE_CACHE_FILE, "utf8");
+  } catch {
+    return null; // Missing/unreadable cache is a normal cold start.
+  }
+
+  try {
+    const entry = asRecord(asRecord(JSON.parse(raw))?.[provider]);
+    const fetchedAt = numericProperty(entry, "fetchedAt");
+    if (entry === null || fetchedAt === null) return null;
+    if (nowMs - fetchedAt >= BALANCE_CACHE_TTL_MS) return null;
+    return parseCachedBalance(entry.balance);
+  } catch {
+    return null; // Corrupt cache must never break the footer.
+  }
+}
+
+/**
+ * Persist a fresh reading so other live sessions and future freshly-loaded
+ * sessions render it instantly. Write is atomic (tmp + rename) because
+ * several pi processes can fetch concurrently.
+ */
+function writeCachedBalance(provider: string, balance: Balance): void {
+  let cache: BalanceCache = {};
+  try {
+    const existing = asRecord(
+      JSON.parse(readFileSync(BALANCE_CACHE_FILE, "utf8")),
+    );
+    if (existing) cache = existing as BalanceCache;
+  } catch {
+    // Missing or corrupt cache: start fresh rather than failing the write.
+  }
+  cache[provider] = { fetchedAt: Date.now(), balance };
+
+  try {
+    mkdirSync(dirname(BALANCE_CACHE_FILE), { recursive: true });
+    const tempFile = `${BALANCE_CACHE_FILE}.${process.pid}.tmp`;
+    writeFileSync(tempFile, JSON.stringify(cache));
+    renameSync(tempFile, BALANCE_CACHE_FILE);
+  } catch {
+    // The cache is an accelerator only; the footer works without it.
+  }
+}
+
 type FooterSession = ConstructorParameters<typeof FooterComponent>[0];
 type FooterFactory = NonNullable<
   Parameters<ExtensionContext["ui"]["setFooter"]>[0]
@@ -726,6 +839,16 @@ export default function providerBalance(pi: ExtensionAPI): void {
     const providerId = provider;
     const adapter = providerId ? BALANCE_ADAPTERS[providerId] : undefined;
     if (!adapter || !providerId) return;
+
+    // Paint the freshest known value for this account immediately: another
+    // live pi instance may have fetched seconds ago, and on session switch
+    // this is what keeps the new session's footer warm instead of blank until
+    // its own first fetch lands.
+    const cached = readCachedBalance(providerId);
+    if (cached) {
+      balance = cached;
+      requestRender?.();
+    }
     if (
       adapter.requiresOAuth &&
       (!model ||
@@ -739,7 +862,10 @@ export default function providerBalance(pi: ExtensionAPI): void {
       const token = await ctx.modelRegistry.getApiKeyForProvider(providerId);
       if (!token || generation !== refreshGeneration) return;
       balance = await adapter.fetch(token, controller.signal);
-      if (generation === refreshGeneration) requestRender?.();
+      if (generation === refreshGeneration) {
+        writeCachedBalance(providerId, balance);
+        requestRender?.();
+      }
     } catch (error) {
       if (generation !== refreshGeneration || controller.signal.aborted) return;
       // This is a best-effort background refresh. Writing to stdout/stderr while
@@ -793,6 +919,12 @@ export default function providerBalance(pi: ExtensionAPI): void {
     });
   }
 
+  // Fires for startup, reload, and every session switch/new/fork: pi tears
+  // the old runtime down (session_shutdown) and starts a fresh one, so this
+  // is both our initializer and our "user switched sessions" signal.
+  // refreshBalance seeds from the shared cache first, so a session resumed
+  // mid-run elsewhere shows the other instance's last reading immediately
+  // instead of going stale until agent_settled or the 5th turn_end.
   pi.on("session_start", (_event, ctx) => {
     activeContext = ctx;
     activeThinkingLevel = restoredThinkingLevel(ctx);