bermudis-pi-goodies 0.1.0

package/README.md

@@ -0,0 +1,112 @@
+# bermudis-pi-goodies
+
+A bundle of small, frequently-used [Pi](https://github.com/earendil-works/pi)
+extensions. One entry point, eight 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. |
+| `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`. |
+| `model-thinking` | hook + `/model-thinking` | Apply provider/model thinking defaults and explicitly save per-model defaults. |
+| `fixed-defaults` | hook + `/fixed-defaults` | Keep the global startup provider, model, and thinking defaults fixed while allowing in-session model changes; `/fixed-defaults set` pins the current model and thinking level. |
+| `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. |
+
+## Install
+
+After publishing the package to npm:
+
+```bash
+pi install npm:bermudis-pi-goodies@0.1.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-specific thinking
+
+This feature is deliberately opt-in: models not covered by the config retain
+Pi's native thinking-level behavior. Create `~/.pi/agent/model-thinking.json`
+with provider defaults, exact model defaults, or both:
+
+```json
+{
+  "providers": {
+    "anthropic": "high",
+    "openai-codex": "xhigh"
+  },
+  "models": {
+    "anthropic/claude-haiku-4-5": "low"
+  }
+}
+```
+
+Exact `provider/model-id` entries take precedence over provider defaults. Use
+`/model-thinking set` to explicitly save the current model's current thinking
+level as an exact-model entry; it also bootstraps models not yet covered by the
+config and overwrites an existing entry. Manual thinking-level changes in Pi do
+not modify this file. All current Pi levels are accepted:
+`off`, `minimal`, `low`, `medium`, `high`, `xhigh`, and `max`.
+`/model-thinking` shows the active resolution and config path;
+`/model-thinking reset` deletes the whole config.
+
+## Fixed startup defaults
+
+Pi normally saves the last model and thinking level selected in the global
+settings file. The bundle pins those cross-session defaults to:
+
+```json
+{
+  "defaultProvider": "openai-codex",
+  "defaultModel": "gpt-5.6-luna",
+  "defaultThinkingLevel": "max"
+}
+```
+
+Selecting a different model still changes the active session and its transcript;
+`fixed-defaults` only restores the startup values after Pi persists a selection.
+
+The pinned values are the built-ins above, optionally overridden per field by
+`~/.pi/agent/fixed-defaults.json` — omit a field to keep the built-in value for
+it, and hand edits are picked up without a reload. Manage it from Pi:
+
+- `/fixed-defaults set` — pin the currently active model and thinking level as
+  the new startup defaults (written to the override file and applied to
+  `settings.json` immediately).
+- `/fixed-defaults` — show the effective pin, the active model, and the
+  override file path.
+- `/fixed-defaults reset` — delete the override file and fall back to the
+  built-in values.
+
+## Provider and balance details
+
+Kilo registration is network-free: it starts with `kilo-auto/free`, restores
+an authenticated catalog from Pi's model store, and normally revalidates that
+catalog no more than every four hours. Balance and quota requests run in the background so they
+never delay session startup, model selection, or post-run input readiness.
+The footer also reads OpenRouter remaining credits for `openrouter`, z.ai GLM
+Coding Plan token quota for `zai` (Global) and `zai-coding-cn` (BigModel China),
+and OpenAI Codex's ChatGPT subscription quota when using `openai-codex` OAuth;
+it skips platform API-key auth because that has no ChatGPT subscription quota.
+OpenRouter uses `GET /api/v1/credits`; z.ai uses
+`GET /api/monitor/usage/quota/limit`; Codex uses `GET /wham/usage`. z.ai and
+Codex show both each quota's window length and its `nextResetTime`/`reset_at`
+countdown (when supplied), and `CODEX_API_URL` or `CHATGPT_BASE_URL` can
+override the Codex base URL.
+
+All providers share one renderer: every balance is projected to a list of
+segments and formatted the same way. Credits render as `$1.5k`; each usage
+window renders as `[label ]<window> <remaining>%[ ↻<countdown>]`, e.g.
+`7d 72% ↻4d4h` (`↻` = resets in). Multiple windows are joined with `·`, and
+named extra limits like Codex Spark get a label: `7d 72% ↻4d4h · Spark 7d 74% ↻5d4h`.
+The footer refreshes on session start, model
+switch, and after each completed run (`agent_settled`), so it tracks both
+consumption and external tier changes for whatever provider is active —
+providers without a balance adapter are skipped, so this costs nothing for
+unrelated sessions. Do not also load the standalone `kilo.ts` or
+`provider-balance.ts` entries once this bundle is installed. If you previously
+symlinked the standalone `provider-balance.ts`, remove that link — the feature
+now ships in this bundle.

package/copy-with-model.ts

@@ -0,0 +1,157 @@
+/**
+ * /copy-with-model — Copy last assistant message wrapped in a code block
+ * tagged with the model name. Escapes backticks if needed.
+ *
+ * Example output for claude-sonnet-4:
+ * ```claude-sonnet-4
+ * Ok
+ * ```
+ */
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { execSync, spawn } from "node:child_process";
+import { platform } from "node:os";
+
+// ── Clipboard ─────────────────────────────────────────────────────────
+
+function copyToClipboard(text: string): void {
+  const p = platform();
+  try {
+    if (p === "darwin") {
+      execSync("pbcopy", { input: text, timeout: 5000 });
+      return;
+    }
+    if (p === "win32") {
+      execSync("clip", { input: text, timeout: 5000 });
+      return;
+    }
+    // Linux — Wayland
+    if (process.env.WAYLAND_DISPLAY) {
+      const proc = spawn("wl-copy", [], {
+        stdio: ["pipe", "ignore", "ignore"],
+      });
+      proc.stdin.on("error", () => {});
+      proc.stdin.write(text);
+      proc.stdin.end();
+      proc.unref();
+      return;
+    }
+    // Linux — X11
+    if (process.env.DISPLAY) {
+      try {
+        execSync("xclip -selection clipboard", { input: text, timeout: 5000 });
+      } catch {
+        execSync("xsel --clipboard --input", { input: text, timeout: 5000 });
+      }
+      return;
+    }
+  } catch {
+    // OSC 52 fallback
+    const encoded = Buffer.from(text).toString("base64");
+    if (encoded.length <= 100_000) {
+      process.stdout.write(`\x1b]52;c;${encoded}\x07`);
+      return;
+    }
+  }
+  throw new Error("No clipboard available");
+}
+
+// ── Helpers ───────────────────────────────────────────────────────────
+
+/** Get text content of the last assistant entry from session entries. */
+function getLastAssistantText(entries: any[]): string | undefined {
+  for (let i = entries.length - 1; i >= 0; i--) {
+    const entry = entries[i];
+    if (entry.type !== "message") continue;
+    const msg = entry.message;
+    if (!msg || msg.role !== "assistant") continue;
+    // Skip aborted messages with no content
+    if (
+      msg.stopReason === "aborted" &&
+      (!msg.content || msg.content.length === 0)
+    )
+      continue;
+    let text = "";
+    for (const block of msg.content ?? []) {
+      if (block.type === "text") text += block.text;
+    }
+    return text.trim() || undefined;
+  }
+  return undefined;
+}
+
+/** Derive a short model tag from the full model id. */
+function modelTag(model: { provider: string; id: string }): string {
+  // e.g. "anthropic/claude-sonnet-4" → "claude-sonnet-4"
+  //      "openai/gpt-4o" → "gpt-4o"
+  return model.id;
+}
+
+/**
+ * Wrap text in a code fence, escalating fence level if the content
+ * already contains backtick sequences.
+ *
+ * ```       → ````
+ * ````      → `````
+ * etc.
+ */
+function wrapInCodeBlock(tag: string, text: string): string {
+  // Find the longest run of consecutive backticks in the content
+  let maxRun = 0;
+  for (const line of text.split("\n")) {
+    let run = 0;
+    for (const ch of line) {
+      if (ch === "`") {
+        run++;
+        maxRun = Math.max(maxRun, run);
+      } else {
+        run = 0;
+      }
+    }
+  }
+
+  // Fence needs at least 3 backticks and one more than the longest run
+  const fenceLen = Math.max(3, maxRun + 1);
+  const fence = "`".repeat(fenceLen);
+
+  return `${fence}${tag}\n${text}\n${fence}`;
+}
+
+// ── Extension ─────────────────────────────────────────────────────────
+
+export default function (pi: ExtensionAPI) {
+  pi.registerCommand("copy-with-model", {
+    description:
+      "Copy last assistant message to clipboard in a code block tagged with the model name",
+    handler: async (_args, ctx) => {
+      await ctx.waitForIdle();
+
+      const entries = ctx.sessionManager.getEntries();
+      const text = getLastAssistantText(entries);
+
+      if (!text) {
+        ctx.ui.notify("No assistant messages to copy", "error");
+        return;
+      }
+
+      const model = ctx.model;
+      if (!model) {
+        ctx.ui.notify("No model selected", "error");
+        return;
+      }
+
+      const tag = modelTag(model);
+      const wrapped = wrapInCodeBlock(tag, text);
+
+      try {
+        copyToClipboard(wrapped);
+        ctx.ui.notify(`Copied with model \`${tag}\``, "info");
+      } catch (err) {
+        ctx.ui.notify(
+          `Failed to copy: ${err instanceof Error ? err.message : err}`,
+          "error",
+        );
+      }
+    },
+  });
+}

package/fixed-defaults.ts

@@ -0,0 +1,362 @@
+import {
+  getAgentDir,
+  SettingsManager,
+  type ExtensionAPI,
+  type ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import {
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { dirname, join } from "node:path";
+
+const CONFIG_FILENAME = "fixed-defaults.json";
+const ALL_LEVELS = [
+  "off",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max",
+] as const;
+
+type ThinkingLevel = ReturnType<ExtensionAPI["getThinkingLevel"]>;
+
+/**
+ * Values read from the override file. `thinkingLevel` may layer independently;
+ * `provider` and `model` are a coupled pair — a model id is meaningless without
+ * its provider, so both must be present if either is. Missing fields fall back
+ * to the built-in defaults.
+ */
+interface FixedDefaultsOverride {
+  provider?: string;
+  model?: string;
+  thinkingLevel?: ThinkingLevel;
+}
+
+interface FixedDefaultsOptions {
+  /** Internal seam used by tests; normal callers use Pi's global agent dir. */
+  agentDir?: string;
+  /** Internal seam used by tests; defaults to <agentDir>/fixed-defaults.json. */
+  configPath?: string;
+}
+
+function describeError(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+function isThinkingLevel(value: unknown): value is ThinkingLevel {
+  return (
+    typeof value === "string" &&
+    (ALL_LEVELS as readonly string[]).includes(value)
+  );
+}
+
+function parseOverride(value: unknown): FixedDefaultsOverride {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("the top level must be an object");
+  }
+
+  const input = value as Record<string, unknown>;
+  const unknownKeys = Object.keys(input).filter(
+    (key) => key !== "provider" && key !== "model" && key !== "thinkingLevel",
+  );
+  if (unknownKeys.length > 0) {
+    throw new Error(`unknown field(s): ${unknownKeys.join(", ")}`);
+  }
+
+  const override: FixedDefaultsOverride = {};
+  if (input.provider !== undefined) {
+    if (typeof input.provider !== "string" || input.provider.length === 0) {
+      throw new Error("`provider` must be a non-empty string");
+    }
+    override.provider = input.provider;
+  }
+  if (input.model !== undefined) {
+    if (typeof input.model !== "string" || input.model.length === 0) {
+      throw new Error("`model` must be a non-empty string");
+    }
+    override.model = input.model;
+  }
+  if (input.thinkingLevel !== undefined) {
+    if (!isThinkingLevel(input.thinkingLevel)) {
+      throw new Error(
+        `\`thinkingLevel\` must be one of: ${ALL_LEVELS.join(", ")}`,
+      );
+    }
+    override.thinkingLevel = input.thinkingLevel;
+  }
+
+  // provider and model are a coupled pair — a model id is meaningless without
+  // its provider. Require both if either is present so a hand-edited partial
+  // file can't pin a broken default. thinkingLevel may still layer alone.
+  if (
+    (override.provider !== undefined && override.model === undefined) ||
+    (override.model !== undefined && override.provider === undefined)
+  ) {
+    throw new Error(
+      "`provider` and `model` must be specified together — a model id is meaningless without its provider",
+    );
+  }
+
+  return override;
+}
+
+/**
+ * Read/write the override file. Reads are uncached (the file is tiny and the
+ * events are rare), so hand edits are picked up without a reload. Writes are
+ * atomic via temp file + rename.
+ */
+class DefaultsStore {
+  readonly path: string;
+
+  constructor(path: string) {
+    this.path = path;
+  }
+
+  /** Load the override; returns { override: {}, error: null } when missing. */
+  load(): LoadResult {
+    let raw: string;
+    try {
+      raw = readFileSync(this.path, "utf8");
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+        return { override: {}, error: null };
+      }
+      throw error;
+    }
+
+    try {
+      return {
+        override: parseOverride(JSON.parse(raw) as unknown),
+        error: null,
+      };
+    } catch (error) {
+      const message = describeError(error);
+      console.error(
+        `[fixed-defaults] invalid config at ${this.path}:`,
+        message,
+      );
+      return { override: {}, error: message };
+    }
+  }
+
+  save(override: FixedDefaultsOverride): void {
+    mkdirSync(dirname(this.path), { recursive: true });
+    const temporaryPath = `${this.path}.${process.pid}.${Date.now()}.tmp`;
+
+    try {
+      writeFileSync(temporaryPath, `${JSON.stringify(override, null, 2)}\n`, {
+        encoding: "utf8",
+        mode: 0o600,
+      });
+      renameSync(temporaryPath, this.path);
+    } catch (error) {
+      try {
+        unlinkSync(temporaryPath);
+      } catch {
+        // The temporary file usually does not exist when the initial write failed.
+      }
+      throw error;
+    }
+  }
+
+  reset(): boolean {
+    try {
+      unlinkSync(this.path);
+      return true;
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === "ENOENT") return false;
+      throw error;
+    }
+  }
+}
+
+/** Result of reading the override file: the parsed values plus any error. */
+interface LoadResult {
+  override: FixedDefaultsOverride;
+  /** Non-null when the file existed but failed to parse or validate. */
+  error: string | null;
+}
+
+/**
+ * Keep Pi's cross-session defaults stable while still allowing model changes in
+ * the current session. Pi intentionally saves the last selected model and
+ * thinking level, so this runs after those notifications and restores the
+ * configured startup defaults in the global settings file.
+ *
+ * The pin lives in `<agentDir>/fixed-defaults.json` and is the sole source of
+ * truth — there are no built-in defaults, so with no override file the
+ * extension is dormant and Pi's native last-selection behavior is preserved.
+ * `thinkingLevel` may layer independently; `provider` and `model` are a
+ * coupled pair. `/fixed-defaults set` pins the currently active model and
+ * thinking level; `/fixed-defaults reset` stops pinning; `/fixed-defaults`
+ * shows the active pin.
+ */
+export default function fixedDefaults(
+  pi: ExtensionAPI,
+  options: FixedDefaultsOptions = {},
+): void {
+  const agentDir = options.agentDir ?? getAgentDir();
+  const store = new DefaultsStore(
+    options.configPath ?? join(agentDir, CONFIG_FILENAME),
+  );
+  let pending = Promise.resolve();
+
+  async function restore(ctx: ExtensionContext): Promise<void> {
+    const { override, error } = store.load();
+    // A broken or absent override means no pin: leave settings untouched so
+    // Pi's native last-selection behavior is preserved rather than guessed at.
+    if (error) return;
+    const hasModelPin =
+      override.provider !== undefined && override.model !== undefined;
+    const hasThinkingPin = override.thinkingLevel !== undefined;
+    if (!hasModelPin && !hasThinkingPin) return;
+
+    const settings = SettingsManager.create(ctx.cwd, agentDir, {
+      projectTrusted: ctx.isProjectTrusted(),
+    });
+    if (hasModelPin) {
+      settings.setDefaultModelAndProvider(override.provider!, override.model!);
+    }
+    if (hasThinkingPin) {
+      settings.setDefaultThinkingLevel(override.thinkingLevel!);
+    }
+    await settings.flush();
+
+    const errors = settings.drainErrors();
+    if (errors.length > 0) {
+      const details = errors
+        .map(({ scope, error }) => `${scope}: ${describeError(error)}`)
+        .join("; ");
+      throw new Error(`failed to persist fixed defaults (${details})`);
+    }
+  }
+
+  function schedule(ctx: ExtensionContext): Promise<void> {
+    const operation = pending.then(() => restore(ctx));
+    // Keep later notifications serviceable after one failed write. The
+    // original operation is still returned so Pi can report that failure.
+    pending = operation.catch((error: unknown) => {
+      console.error("[fixed-defaults] failed to restore defaults:", error);
+    });
+    return operation;
+  }
+
+  pi.on("session_start", (_event, ctx) => schedule(ctx));
+  pi.on("model_select", (_event, ctx) => schedule(ctx));
+  pi.on("thinking_level_select", (_event, ctx) => schedule(ctx));
+
+  pi.registerCommand("fixed-defaults", {
+    description:
+      "Show, set, or reset the pinned startup model/thinking defaults",
+    handler: async (args, ctx) => {
+      const command = args.trim();
+
+      if (command === "set") {
+        const model = ctx.model;
+        if (!model) {
+          ctx.ui.notify(
+            "Cannot pin defaults without an active model.",
+            "warning",
+          );
+          return;
+        }
+
+        const level = pi.getThinkingLevel();
+        const override: FixedDefaultsOverride = {
+          provider: model.provider,
+          model: model.id,
+          thinkingLevel: level,
+        };
+        try {
+          store.save(override);
+        } catch (error) {
+          console.error("[fixed-defaults] failed to save override:", error);
+          ctx.ui.notify("Failed to save the new fixed defaults.", "error");
+          return;
+        }
+
+        try {
+          // Bring settings.json in line with the new pin right away instead
+          // of waiting for the next model/thinking/session event.
+          await schedule(ctx);
+        } catch (error) {
+          console.error("[fixed-defaults] failed to apply override:", error);
+          ctx.ui.notify(
+            "Defaults saved, but applying them to settings.json failed.",
+            "warning",
+          );
+          return;
+        }
+
+        ctx.ui.notify(
+          `Pinned ${model.provider}/${model.id} · thinking ${level} as startup defaults`,
+          "info",
+        );
+        return;
+      }
+
+      if (command === "reset") {
+        let removed: boolean;
+        try {
+          removed = store.reset();
+        } catch (error) {
+          console.error("[fixed-defaults] failed to reset override:", error);
+          ctx.ui.notify("Failed to reset fixed defaults.", "error");
+          return;
+        }
+
+        // Removing the override makes future events no-ops; there is nothing
+        // to apply to settings.json now. Existing defaults are left as-is so
+        // reset means "stop pinning," not "revert to an earlier state."
+        ctx.ui.notify(
+          removed
+            ? "Fixed-defaults pin removed. Pi will use your last selection."
+            : "No fixed-defaults override file to reset.",
+          "info",
+        );
+        return;
+      }
+
+      if (command !== "") {
+        ctx.ui.notify("Usage: /fixed-defaults [set|reset]", "warning");
+        return;
+      }
+
+      const { override, error } = store.load();
+      const model = ctx.model;
+      const lines = [
+        `model: ${model ? `${model.provider}/${model.id}` : "none"}`,
+        `thinking: ${pi.getThinkingLevel()}`,
+        "",
+      ];
+      if (error) {
+        lines.push(`⚠ override file invalid — no pin active: ${error}`);
+      } else if (Object.keys(override).length === 0) {
+        lines.push("No pin active. Pi will use your last selection.");
+      } else {
+        if (override.provider !== undefined && override.model !== undefined) {
+          lines.push(`pinned provider: ${override.provider}`);
+          lines.push(`pinned model: ${override.model}`);
+        }
+        if (override.thinkingLevel !== undefined) {
+          lines.push(`pinned thinking: ${override.thinkingLevel}`);
+        }
+      }
+      lines.push("", `override file: ${store.path}`);
+      lines.push(
+        "",
+        "run `/fixed-defaults set` to pin the current model and thinking level; `/fixed-defaults reset` to stop pinning",
+      );
+      const message = lines.join("\n");
+
+      if (ctx.hasUI) ctx.ui.notify(message, "info");
+      else console.log(message);
+    },
+  });
+}

package/index.ts

@@ -0,0 +1,34 @@
+/**
+ * bermudis-pi-goodies — a bundle of small, frequently-used Pi extensions.
+ *
+ * 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
+ *   - 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)
+ *   - model-thinking   hook + command    remember thinking levels by provider/model
+ *   - fixed-defaults   hook + command    keep startup defaults stable; /fixed-defaults set pins the current model
+ *   - kilo             provider          access Kilo Gateway models
+ *   - provider-balance footer            show Kilo credits or Codex quota in the footer
+ */
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import copyWithModel from "./copy-with-model.ts";
+import fixedDefaults from "./fixed-defaults.ts";
+import kilo from "./kilo.ts";
+import modelThinking from "./model-thinking.ts";
+import providerBalance from "./provider-balance.ts";
+import nameWithAi from "./name-with-ai.ts";
+import zed from "./zed.ts";
+import preferTools from "./prefer-tools.ts";
+
+export default function bermudisPiGoodies(pi: ExtensionAPI): void {
+  copyWithModel(pi);
+  nameWithAi(pi);
+  zed(pi);
+  preferTools(pi);
+  modelThinking(pi);
+  fixedDefaults(pi);
+  providerBalance(pi);
+  kilo(pi);
+}