bermudis-pi-goodies 0.6.0 → 0.7.0

package/README.md

@@ -11,7 +11,7 @@ extensions. One entry point, ten independent features.
 | `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`.                                    |
 | `keep-model-on-new` | hook (no command)            | Keep the active model when `/new` starts a fresh session instead of reverting to pi's saved default model.                                    |
-| `model-thinking`   | hook + `/levels`              | Per-model thinking levels stored in an extension sidecar (pi's /scoped-models rewrites `enabledModels` bare, wiping `:level` suffixes); `/levels` edits them, hooks apply them whenever a model becomes active. |
+| `clean-tui`        | tool overrides (no command)   | Collapse built-in tool output for a cleaner TUI: keeps a one-line call header, hides results/diffs until you expand a row with ctrl+e or click. |
 | `kilo`             | provider                      | Access Kilo Gateway models via `/login kilo` or `KILO_API_KEY`.                                                                                 |
 | `provider-balance` | footer (no command)           | Show remaining Kilo or OpenRouter credits, z.ai token-plan quota, or OpenAI Codex quota on the right side of the working-directory footer line. |
 | `tps`              | hook (no command)             | Notify tokens/sec and in/out/cache token usage at the end of each agent turn.                                                                   |
@@ -21,50 +21,33 @@ extensions. One entry point, ten independent features.
 After publishing the package to npm:
 
 ```bash
-pi install npm:bermudis-pi-goodies@0.6.0
+pi install npm:bermudis-pi-goodies@0.7.0
 ```
 
 Remove any old `bermudis-pi-goodies.ts` symlink before reloading Pi. Each
 feature is independent — disabling one is a one-line edit in `index.ts`.
 Kilo's provider and its balance footer are bundled here.
 
-## Model selection and thinking
-
-Pi's native scoped-models config would put per-model thinking levels in
-`enabledModels` entries like `"zai/glm-5.3:high"`, but the `/scoped-models`
-screen (which maintains that list) rewrites it with bare model ids on every
-save, destroying any `:level` suffix. So this package stores levels in its
-own sidecar file:
-
-```
-~/.pi/agent/data/bermudis-pi-goodies/thinking-levels.json
-```
-
-The split of ownership is clean: `/scoped-models` owns which models are
-enabled and their Ctrl+P cycle order; `/levels` owns the per-model thinking
-level and can never be wiped by the other screen.
-
-Use `/levels` to edit: ↑↓ moves between scoped models, ←→ cycles each
-model's level through the ladder it actually supports plus `inherit`
-(which leaves pi's global default in charge), Enter saves atomically and
-applies to the active model immediately, Esc cancels.
-
-Hooks apply the stored level whenever a model becomes active: full-picker
-selection, Ctrl+P cycling, startup, and `/new` (where this package carries
-the previous session's active model forward). A native scoped level for the session — via
-`--models "x:high"` or a hand-suffixed enabledModels entry — always wins;
-the sidecar only fills in where pi itself has no level. Explicit
-`--thinking` or `--model ...:<level>` still
-wins for that launched session — a model whose registered id genuinely ends
-in `:<level>` is indistinguishable from that shorthand without the registry,
-so it opts out of its stored level for that startup; switch or cycle to
-re-apply. Resumed and forked sessions keep the level restored by pi.
-
-One gap is inherent to Pi: it emits no `model_select` when you pick the
-model that is already active, so re-selecting it in the full picker leaves
-a manual thinking level in place — switch models (or cycle) to snap back.
-Saving the `/scoped-models` screen in pi 0.84.2 writes bare model ids, which
-is now harmless: bare ids are exactly what this design expects.
+## Per-model thinking levels (retired in favor of Pi 0.84.3)
+
+This package previously shipped a `model-thinking` module with a `/levels`
+command and an extension-owned sidecar at
+`~/.pi/agent/data/bermudis-pi-goodies/thinking-levels.json`. It existed
+because Pi's `/scoped-models` screen rewrote `enabledModels` with bare model
+ids (wiping any `:level` suffix) and because every `setThinkingLevel()` call
+persisted as the global default.
+
+Pi [0.84.3](https://github.com/earendil-works/pi/releases/tag/v0.84.3) fixed
+both: in-session model and thinking changes are now ephemeral by default
+(persist only via `/settings` or Ctrl+S, [#5263](https://github.com/earendil-works/pi/issues/5263)),
+and Pi added a native per-model thinking-level override keyed by
+`provider/modelId`, stored in `settings.json` `modelThinkingLevels` and
+edited via `/settings` → "Default thinking level per model". That is exactly
+what `model-thinking` provided, so the module is retired.
+
+If you had levels in the old sidecar
+(`~/.pi/agent/data/bermudis-pi-goodies/thinking-levels.json`), re-enter them
+via `/settings` → "Default thinking level per model".
 
 ## Provider and balance details
 

package/clean-tui.ts

@@ -0,0 +1,334 @@
+/**
+ * Collapse built-in tool output for a cleaner TUI focused on agent prose.
+ *
+ * Re-registers pi's built-in tools (read, bash, edit, write, find, grep, ls)
+ * with the same names, delegating `execute()` to the original factory
+ * implementations so behavior is unchanged. The only override is rendering:
+ * each tool keeps a terse one-line call header (command, path, or pattern)
+ * but produces no visible output when collapsed. Expand a row with ctrl+e or
+ * click to see the full result/diff.
+ *
+ * This is the display target the user chose: hide output, keep the call line.
+ * No global fold toggle — folding stays per-row via pi's native expand.
+ */
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import {
+  createBashTool,
+  createEditTool,
+  createFindTool,
+  createGrepTool,
+  createLsTool,
+  createReadTool,
+  createWriteTool,
+} from "@earendil-works/pi-coding-agent";
+import { Text } from "@earendil-works/pi-tui";
+import { homedir } from "node:os";
+
+type BuiltInTools = {
+  read: ReturnType<typeof createReadTool>;
+  bash: ReturnType<typeof createBashTool>;
+  edit: ReturnType<typeof createEditTool>;
+  write: ReturnType<typeof createWriteTool>;
+  find: ReturnType<typeof createFindTool>;
+  grep: ReturnType<typeof createGrepTool>;
+  ls: ReturnType<typeof createLsTool>;
+};
+
+const toolCache = new Map<string, BuiltInTools>();
+
+function createBuiltInTools(cwd: string): BuiltInTools {
+  return {
+    read: createReadTool(cwd),
+    bash: createBashTool(cwd),
+    edit: createEditTool(cwd),
+    write: createWriteTool(cwd),
+    find: createFindTool(cwd),
+    grep: createGrepTool(cwd),
+    ls: createLsTool(cwd),
+  };
+}
+
+function getBuiltInTools(cwd: string): BuiltInTools {
+  let tools = toolCache.get(cwd);
+  if (!tools) {
+    tools = createBuiltInTools(cwd);
+    toolCache.set(cwd, tools);
+  }
+  return tools;
+}
+
+function shortenPath(path: string): string {
+  const home = homedir();
+  if (path.startsWith(home)) return `~${path.slice(home.length)}`;
+  return path;
+}
+
+/** Extract the text content from a tool result, or undefined if none. */
+function resultText(result: {
+  content: Array<{ type: string; text?: string }>;
+}): string | undefined {
+  const textContent = result.content.find((c) => c.type === "text");
+  return textContent?.type === "text" ? textContent.text : undefined;
+}
+
+export default function cleanTui(pi: ExtensionAPI): void {
+  // parameters is a static TypeBox schema; any cwd instance yields the same
+  // schema. execute() uses ctx.cwd for the real working directory.
+  const schemaTools = getBuiltInTools(process.cwd());
+
+  pi.registerTool({
+    name: "read",
+    label: "read",
+    description: schemaTools.read.description,
+    parameters: schemaTools.read.parameters,
+    async execute(toolCallId, params, signal, onUpdate, ctx) {
+      return getBuiltInTools(ctx.cwd).read.execute(
+        toolCallId,
+        params,
+        signal,
+        onUpdate,
+      );
+    },
+    renderCall(args, theme) {
+      const path = shortenPath(args.path || "");
+      let display = path
+        ? theme.fg("accent", path)
+        : theme.fg("toolOutput", "...");
+      if (args.offset !== undefined || args.limit !== undefined) {
+        const start = args.offset ?? 1;
+        const end = args.limit !== undefined ? start + args.limit - 1 : "";
+        display += theme.fg("warning", `:${start}${end ? `-${end}` : ""}`);
+      }
+      return new Text(
+        `${theme.fg("toolTitle", theme.bold("read"))} ${display}`,
+        0,
+        0,
+      );
+    },
+    renderResult(result, { expanded }, theme) {
+      if (!expanded) return new Text("", 0, 0);
+      const text = resultText(result);
+      if (!text) return new Text("", 0, 0);
+      return new Text(
+        `\n${text
+          .split("\n")
+          .map((l) => theme.fg("toolOutput", l))
+          .join("\n")}`,
+        0,
+        0,
+      );
+    },
+  });
+
+  pi.registerTool({
+    name: "bash",
+    label: "bash",
+    description: schemaTools.bash.description,
+    parameters: schemaTools.bash.parameters,
+    async execute(toolCallId, params, signal, onUpdate, ctx) {
+      return getBuiltInTools(ctx.cwd).bash.execute(
+        toolCallId,
+        params,
+        signal,
+        onUpdate,
+      );
+    },
+    renderCall(args, theme) {
+      const command = args.command || "...";
+      const timeout = args.timeout as number | undefined;
+      const suffix = timeout ? theme.fg("muted", ` (timeout ${timeout}s)`) : "";
+      return new Text(
+        theme.fg("toolTitle", theme.bold(`$ ${command}`)) + suffix,
+        0,
+        0,
+      );
+    },
+    renderResult(result, { expanded }, theme) {
+      if (!expanded) return new Text("", 0, 0);
+      const text = resultText(result)?.trim();
+      if (!text) return new Text("", 0, 0);
+      return new Text(
+        `\n${text
+          .split("\n")
+          .map((l) => theme.fg("toolOutput", l))
+          .join("\n")}`,
+        0,
+        0,
+      );
+    },
+  });
+
+  pi.registerTool({
+    name: "write",
+    label: "write",
+    description: schemaTools.write.description,
+    parameters: schemaTools.write.parameters,
+    async execute(toolCallId, params, signal, onUpdate, ctx) {
+      return getBuiltInTools(ctx.cwd).write.execute(
+        toolCallId,
+        params,
+        signal,
+        onUpdate,
+      );
+    },
+    renderCall(args, theme) {
+      const path = shortenPath(args.path || "");
+      const display = path
+        ? theme.fg("accent", path)
+        : theme.fg("toolOutput", "...");
+      const lines = args.content ? args.content.split("\n").length : 0;
+      const info = lines > 0 ? theme.fg("muted", ` (${lines} lines)`) : "";
+      return new Text(
+        `${theme.fg("toolTitle", theme.bold("write"))} ${display}${info}`,
+        0,
+        0,
+      );
+    },
+    renderResult(result, { expanded }, theme) {
+      if (!expanded) return new Text("", 0, 0);
+      const text = resultText(result);
+      if (text) return new Text(`\n${theme.fg("error", text)}`, 0, 0);
+      return new Text("", 0, 0);
+    },
+  });
+
+  pi.registerTool({
+    name: "edit",
+    label: "edit",
+    description: schemaTools.edit.description,
+    parameters: schemaTools.edit.parameters,
+    async execute(toolCallId, params, signal, onUpdate, ctx) {
+      return getBuiltInTools(ctx.cwd).edit.execute(
+        toolCallId,
+        params,
+        signal,
+        onUpdate,
+      );
+    },
+    renderCall(args, theme) {
+      const path = shortenPath(args.path || "");
+      const display = path
+        ? theme.fg("accent", path)
+        : theme.fg("toolOutput", "...");
+      return new Text(
+        `${theme.fg("toolTitle", theme.bold("edit"))} ${display}`,
+        0,
+        0,
+      );
+    },
+    renderResult(result, { expanded }, theme) {
+      if (!expanded) return new Text("", 0, 0);
+      const text = resultText(result);
+      if (!text) return new Text("", 0, 0);
+      return new Text(`\n${theme.fg("toolOutput", text)}`, 0, 0);
+    },
+  });
+
+  pi.registerTool({
+    name: "find",
+    label: "find",
+    description: schemaTools.find.description,
+    parameters: schemaTools.find.parameters,
+    async execute(toolCallId, params, signal, onUpdate, ctx) {
+      return getBuiltInTools(ctx.cwd).find.execute(
+        toolCallId,
+        params,
+        signal,
+        onUpdate,
+      );
+    },
+    renderCall(args, theme) {
+      const pattern = args.pattern || "";
+      const path = shortenPath(args.path || ".");
+      let text = `${theme.fg("toolTitle", theme.bold("find"))} ${theme.fg("accent", pattern)}`;
+      text += theme.fg("toolOutput", ` in ${path}`);
+      return new Text(text, 0, 0);
+    },
+    renderResult(result, { expanded }, theme) {
+      if (!expanded) return new Text("", 0, 0);
+      const text = resultText(result)?.trim();
+      if (!text) return new Text("", 0, 0);
+      return new Text(
+        `\n${text
+          .split("\n")
+          .map((l) => theme.fg("toolOutput", l))
+          .join("\n")}`,
+        0,
+        0,
+      );
+    },
+  });
+
+  pi.registerTool({
+    name: "grep",
+    label: "grep",
+    description: schemaTools.grep.description,
+    parameters: schemaTools.grep.parameters,
+    async execute(toolCallId, params, signal, onUpdate, ctx) {
+      return getBuiltInTools(ctx.cwd).grep.execute(
+        toolCallId,
+        params,
+        signal,
+        onUpdate,
+      );
+    },
+    renderCall(args, theme) {
+      const pattern = args.pattern || "";
+      const path = shortenPath(args.path || ".");
+      const glob = args.glob;
+      let text = `${theme.fg("toolTitle", theme.bold("grep"))} ${theme.fg("accent", `/${pattern}/`)}`;
+      text += theme.fg("toolOutput", ` in ${path}`);
+      if (glob) text += theme.fg("toolOutput", ` (${glob})`);
+      return new Text(text, 0, 0);
+    },
+    renderResult(result, { expanded }, theme) {
+      if (!expanded) return new Text("", 0, 0);
+      const text = resultText(result)?.trim();
+      if (!text) return new Text("", 0, 0);
+      return new Text(
+        `\n${text
+          .split("\n")
+          .map((l) => theme.fg("toolOutput", l))
+          .join("\n")}`,
+        0,
+        0,
+      );
+    },
+  });
+
+  pi.registerTool({
+    name: "ls",
+    label: "ls",
+    description: schemaTools.ls.description,
+    parameters: schemaTools.ls.parameters,
+    async execute(toolCallId, params, signal, onUpdate, ctx) {
+      return getBuiltInTools(ctx.cwd).ls.execute(
+        toolCallId,
+        params,
+        signal,
+        onUpdate,
+      );
+    },
+    renderCall(args, theme) {
+      const path = shortenPath(args.path || ".");
+      return new Text(
+        `${theme.fg("toolTitle", theme.bold("ls"))} ${theme.fg("accent", path)}`,
+        0,
+        0,
+      );
+    },
+    renderResult(result, { expanded }, theme) {
+      if (!expanded) return new Text("", 0, 0);
+      const text = resultText(result)?.trim();
+      if (!text) return new Text("", 0, 0);
+      return new Text(
+        `\n${text
+          .split("\n")
+          .map((l) => theme.fg("toolOutput", l))
+          .join("\n")}`,
+        0,
+        0,
+      );
+    },
+  });
+}

package/index.ts

@@ -9,17 +9,24 @@
  *   - zed              /z                open Zed on cwd
  *   - prefer-tools     hook              block legacy tools (use trash/rg/fd/uv)
  *   - keep-model       hook              preserve the active model across /new
- *   - model-thinking   hook              manage per-model thinking levels in an extension-owned sidecar
+ *   - clean-tui        tool overrides    collapse built-in tool output; keep a one-line call header, hide results/diffs until expanded
  *   - kilo             provider          access Kilo Gateway models
  *   - provider-balance footer            show Kilo credits or Codex quota in the footer
  *   - tps              hook              notify tokens/sec and usage at each agent turn end
+ *
+ * Per-model thinking levels were previously provided here by a `model-thinking`
+ * module with a `/levels` command and an extension-owned sidecar. Pi 0.84.3
+ * added native per-model thinking-level overrides (settings.json
+ * `modelThinkingLevels`, edited via `/settings` → "Default thinking level per
+ * model") and made in-session model/thinking changes ephemeral by default, so
+ * that module is retired.
  */
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import copyTrajectory from "./copy-trajectory.ts";
 import copyWithModel from "./copy-with-model.ts";
 import kilo from "./kilo.ts";
 import keepModelOnNew from "./keep-model-on-new.ts";
-import modelThinking from "./model-thinking.ts";
+import cleanTui from "./clean-tui.ts";
 import providerBalance from "./provider-balance.ts";
 import tps from "./tps.ts";
 import nameWithAi from "./name-with-ai.ts";
@@ -32,10 +39,8 @@ export default function bermudisPiGoodies(pi: ExtensionAPI): void {
   nameWithAi(pi);
   zed(pi);
   preferTools(pi);
-  // Register this before model-thinking so /new restores the model first and
-  // model-thinking then sees and configures the final active model.
   keepModelOnNew(pi);
-  modelThinking(pi);
+  cleanTui(pi);
   providerBalance(pi);
   kilo(pi);
   tps(pi);

package/keep-model-on-new.ts

@@ -9,11 +9,23 @@ interface ModelIdentity {
 }
 
 /**
- * Extension modules are cached across Pi's session-runtime replacement, while
- * their factories and handlers are recreated. This small handoff therefore
- * survives /new without writing transient state to disk.
+ * Pi normally caches extension modules across a session-runtime replacement,
+ * but that cache can be invalidated by another resource loader or /reload.
+ * Keep the handoff on globalThis so a fresh import in the same Pi process
+ * cannot lose it. The state is still transient and never written to disk.
  */
-const pendingModels = new Map<string, ModelIdentity>();
+const pendingModelsKey = Symbol.for(
+  "bermudis-pi-goodies.keep-model-on-new.pending-models",
+);
+
+type GlobalWithPendingModels = typeof globalThis & {
+  [pendingModelsKey]?: Map<string, ModelIdentity>;
+};
+
+function getPendingModels(): Map<string, ModelIdentity> {
+  const globalState = globalThis as GlobalWithPendingModels;
+  return (globalState[pendingModelsKey] ??= new Map());
+}
 
 function handoffKey(
   sessionFile: string | undefined,
@@ -31,7 +43,7 @@ export default function keepModelOnNew(
   pi: ExtensionAPI,
   options: KeepModelOnNewOptions = {},
 ): void {
-  const handoffs = options.pendingModels ?? pendingModels;
+  const handoffs = options.pendingModels ?? getPendingModels();
 
   pi.on("session_before_switch", (event, ctx) => {
     if (event.reason !== "new" || !ctx.model) return;
@@ -64,7 +76,12 @@ export default function keepModelOnNew(
     }
 
     try {
-      await pi.setModel(model);
+      const restored = await pi.setModel(model);
+      if (!restored) {
+        const message = `Could not keep model after /new: ${previous.provider}/${previous.id} is not authenticated`;
+        console.warn(`[keep-model-on-new] ${message}`);
+        ctx.ui.notify(message, "warning");
+      }
     } catch (error) {
       const detail = error instanceof Error ? error.message : String(error);
       console.warn(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bermudis-pi-goodies",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "private": false,
   "description": "A bundle of small, frequently-used Pi extensions.",
   "keywords": ["pi-package"],
@@ -21,10 +21,10 @@
     "format": "prettier --write \"*.ts\" \"!*.bundle.ts\""
   },
   "devDependencies": {
-    "@earendil-works/pi-agent-core": "^0.84.0",
-    "@earendil-works/pi-ai": "^0.84.0",
-    "@earendil-works/pi-coding-agent": "^0.84.0",
-    "@earendil-works/pi-tui": "^0.84.0",
+    "@earendil-works/pi-agent-core": "^0.84.3",
+    "@earendil-works/pi-ai": "^0.84.3",
+    "@earendil-works/pi-coding-agent": "^0.84.3",
+    "@earendil-works/pi-tui": "^0.84.3",
     "@marcfargas/pi-test-harness": "0.6.1",
     "esbuild": "^0.27.0",
     "prettier": "^3.8.4"