pi-hide-providers 0.1.0

package/README.md

@@ -0,0 +1,165 @@
+<div align="center">
+
+# 🔇 pi-hide-providers
+
+**Hide providers and models from the selector in [pi](https://github.com/earendil-works/pi-coding-agent)**
+
+_Filter the model picker so you only see the models you care about._
+
+[![pi extension](https://img.shields.io/badge/pi-extension-blueviolet)](https://github.com/earendil-works/pi-coding-agent)
+[![license](https://img.shields.io/badge/license-MIT-blue)](./LICENSE)
+
+<img src="assets/demo.jpg" alt="pi-hide-providers interactive model selector" width="800">
+
+</div>
+
+---
+
+## The Problem
+
+Pi's model selector shows **every** available model from every configured provider. If you have Ollama running with 20 local models, or an OpenRouter account with hundreds of options, the model list becomes noisy and slow to navigate. There's no built-in way to say *"I never want to see these providers/models in the selector."*
+
+Pi has `enabledModels` in `settings.json` as an allowlist, but maintaining it manually is tedious — you have to list every model you *do* want, and clobber `settings.json` with hundreds of entries. What you really want is a **blocklist**: *"hide everything from these providers, except the ones I explicitly use."*
+
+## The Solution
+
+`pi-hide-providers` gives you a blocklist that **completely removes** models from all lists — not an allowlist, not a scoped subset:
+
+- Define hide rules in a config file (`~/.pi/agent/hide-providers.json` or `.pi/hide-providers.json`)
+- On session start, the extension monkey-patches `modelRegistry.getAvailable()`, `getAll()`, and `find()` to filter out hidden models
+- The `/model` selector, `Ctrl+P` cycling, `--list-models`, and session restoration all see only visible models
+- `/hide-models reset` unpatches the registry — all models return immediately
+- Changes via `/hide-models add` and `/hide-models remove` take effect immediately (no reload needed)
+- Interactive `/hide-models` command — no-args opens the TUI selector; subcommands for adding, removing, and inspecting rules
+
+No `settings.json` is modified. No 250+ entry explosion. No allowlist semantics.
+
+## Usage
+
+### Interactive Commands
+
+| Command | What it does |
+|---------|-------------|
+| `/hide-models` | Open interactive TUI to select providers/models to hide |
+| `/hide-models add ollama` | Hide the entire `ollama` provider |
+| `/hide-models add openrouter/cheap-model` | Hide a specific model from `openrouter` |
+| `/hide-models add openrouter/*` | Hide the entire `openrouter` provider (explicit) |
+| `/hide-models remove ollama` | Remove the hide rule for `ollama` |
+| `/hide-models status` | Show current rules, patch status, and hidden model count |
+| `/hide-models apply` | Show current hide state (changes are already active) |
+| `/hide-models reset` | Unpatch registry — all models return immediately |
+| `/hide-models help` | Show usage reference |
+
+### Config File
+
+Create `~/.pi/agent/hide-providers.json` (global) or `.pi/hide-providers.json` (project-local):
+
+```json
+{
+  "hide": [
+    { "provider": "ollama" },
+    { "provider": "openrouter", "model": "cheap-model" },
+    { "provider": "github-copilot", "model": "gpt-3.5-turbo" }
+  ]
+}
+```
+
+**Rule formats:**
+
+| Rule | Effect |
+|------|--------|
+| `{ "provider": "ollama" }` | Hide all models from the `ollama` provider |
+| `{ "provider": "ollama", "model": "*" }` | Same — explicit wildcard |
+| `{ "provider": "openrouter", "model": "cheap-model" }` | Hide only `openrouter/cheap-model` |
+
+Project config (`.pi/hide-providers.json`) takes priority over global config (`~/.pi/agent/hide-providers.json`).
+
+## Installation
+
+```bash
+pi install https://github.com/monotykamary/pi-hide-providers
+```
+
+Or in `~/.pi/agent/settings.json`:
+
+```json
+{
+  "packages": [
+    "https://github.com/monotykamary/pi-hide-providers"
+  ]
+}
+```
+
+Then `/reload` or restart pi.
+
+For quick one-off tests:
+
+```bash
+pi -e ./hide-providers.ts
+```
+
+## How It Works
+
+```
+Session starts
+  → Extension reads hide-providers.json
+  → Monkey-patches modelRegistry:
+      getAvailable() → original result filtered by isHidden()
+      getAll()       → original result filtered by isHidden()
+      find(p, m)    → returns undefined if isHidden(p, m)
+  → All downstream consumers see only visible models:
+      /model selector, Ctrl+P, --list-models, session restoration
+
+/hide-models add or /hide-models remove:
+  → Config updated on disk
+  → currentRules updated in memory
+  → Patched methods read latest rules via closure
+  → Changes take effect immediately (no reload)
+
+/hide-models reset:
+  → Unpatches registry (restores original methods)
+  → All models return immediately
+```
+
+The SDK doesn't provide a mechanism to remove models from the registry — `registerProvider({ models: [] })` is treated as "no models to register" (override-only), not "remove all models." Monkey-patching the accessor methods is the only way to completely remove models from all lists without touching `settings.json`.
+
+The patches survive `modelRegistry.refresh()` because they wrap the original methods. On reload, the extension detects the registry is already patched and just updates the rules source.
+
+## Comparison with Alternatives
+
+| Approach | Pros | Cons |
+|----------|------|------|
+| **pi-hide-providers** (this) | Blocklist — completely removes models from all lists; no `settings.json` writes; changes take effect immediately; survives `refresh()` | Monkey-patches `modelRegistry` methods (not an official SDK mechanism) |
+| `enabledModels` in `settings.json` (manual) | Built-in, no extension needed | Allowlist — must list every model you want individually; no blocklist support; clobbers settings with hundreds of entries |
+| `--models` CLI flag | Per-session scoping | Must pass every time; no persistence |
+| `pi.unregisterProvider()` | Restores built-in models after override | Only works for providers registered via `pi.registerProvider()`; can't hide entire providers (empty models array is a no-op) |
+| `pi-model-router` scope shim | Dynamic scoping with routing | Heavyweight — full routing system just to filter the model list |
+
+## Development
+
+```bash
+npm install
+npm test          # Vitest unit tests
+npm run typecheck # TypeScript validation
+npm run lint:dead # Dead code detection (knip)
+```
+
+### Structure
+
+```
+.
+├── hide-providers.ts   # Main extension
+├── src/
+│   └── index.ts        # Constants, types, and utilities
+├── __tests__/
+│   └── unit/
+│       └── hide-providers.test.ts
+├── package.json
+├── tsconfig.json
+├── vitest.config.ts
+└── knip.json
+```
+
+## License
+
+MIT

package/hide-providers.ts

@@ -0,0 +1,497 @@
+import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+import {
+  HIDE_COMMAND_DESCRIPTION,
+  CONFIG_FILENAME,
+  type HideRule,
+  type HideProvidersConfig,
+  isHidden,
+  parseRule,
+  formatRule,
+  deduplicateRules,
+} from "./src/index.js";
+import { HideProviderSelectorComponent, type HideProviderSelectorResult } from "./src/provider-selector.js";
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+/**
+ * pi-hide-providers — hide providers and models from pi's model selector.
+ *
+ * Strategy: monkey-patches modelRegistry accessor methods (getAvailable, getAll, find)
+ * to filter out models matched by hide rules.
+ *
+ * This is the only mechanism that completely removes models from ALL lists:
+ * the /model selector, Ctrl+P cycling, --list-models CLI, and session restoration.
+ * It survives modelRegistry.refresh() because our patches wrap the originals.
+ * No settings.json is touched — no 250+ entry explosion, no allowlist semantics.
+ */
+
+// Config paths
+const globalConfigDir = join(homedir(), ".pi", "agent");
+const globalConfigPath = join(globalConfigDir, CONFIG_FILENAME);
+
+function getProjectConfigPath(cwd: string): string {
+  return join(cwd, ".pi", CONFIG_FILENAME);
+}
+
+// Read config from disk (project overrides global)
+function readConfig(cwd: string): HideProvidersConfig {
+  const projectPath = getProjectConfigPath(cwd);
+  const path = existsSync(projectPath) ? projectPath : globalConfigPath;
+
+  if (!existsSync(path)) {
+    return { hide: [] };
+  }
+
+  try {
+    const raw = readFileSync(path, "utf8");
+    const parsed = JSON.parse(raw) as HideProvidersConfig;
+    if (!Array.isArray(parsed.hide)) {
+      return { hide: [] };
+    }
+    return { hide: deduplicateRules(parsed.hide) };
+  } catch {
+    return { hide: [] };
+  }
+}
+
+// Write config to disk
+function writeConfig(cwd: string, config: HideProvidersConfig): string {
+  const projectPath = getProjectConfigPath(cwd);
+  const path = existsSync(getProjectConfigPath(cwd)) ? projectPath : globalConfigPath;
+  const dir = path === projectPath ? join(cwd, ".pi") : globalConfigDir;
+
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+
+  writeFileSync(path, JSON.stringify(config, null, 2) + "\n", "utf8");
+  return path;
+}
+
+// Monkey-patching helpers
+
+const PATCH_KEY = "__hide_providers_patched";
+
+interface PatchedRegistry {
+  [PATCH_KEY]: boolean;
+  getAvailable(): unknown[];
+  getAll(): unknown[];
+  find(provider: string, modelId: string): unknown | undefined;
+  __hide_providers_get_rules: () => HideRule[];
+  __hide_providers_orig_getAvailable: () => unknown[];
+  __hide_providers_orig_getAll: () => unknown[];
+  __hide_providers_orig_find: (provider: string, modelId: string) => unknown | undefined;
+}
+
+// Patch a model registry to filter out hidden models.
+// If already patched (e.g. after reload), just updates the rules source.
+function patchRegistry(
+  registry: PatchedRegistry,
+  getRules: () => HideRule[],
+): void {
+  if (registry[PATCH_KEY]) {
+    registry.__hide_providers_get_rules = getRules;
+    return;
+  }
+
+  registry[PATCH_KEY] = true;
+  registry.__hide_providers_get_rules = getRules;
+
+  // Save originals
+  registry.__hide_providers_orig_getAvailable = registry.getAvailable.bind(registry);
+  registry.__hide_providers_orig_getAll = registry.getAll.bind(registry);
+  registry.__hide_providers_orig_find = registry.find.bind(registry);
+
+  // Patch getAvailable — used by model selector, Ctrl+P cycle, resolveModelScope
+  registry.getAvailable = function (this: PatchedRegistry) {
+    const rules = this.__hide_providers_get_rules();
+    const all = this.__hide_providers_orig_getAvailable();
+    return all.filter(
+      (m: any) => !isHidden(rules, m.provider, m.id),
+    );
+  };
+
+  // Patch getAll — used by --list-models and CLI model resolution
+  registry.getAll = function (this: PatchedRegistry) {
+    const rules = this.__hide_providers_get_rules();
+    const all = this.__hide_providers_orig_getAll();
+    return all.filter(
+      (m: any) => !isHidden(rules, m.provider, m.id),
+    );
+  };
+
+  // Patch find — used by session restoration. Hides hidden models from being restored.
+  registry.find = function (
+    this: PatchedRegistry,
+    provider: string,
+    modelId: string,
+  ) {
+    const rules = this.__hide_providers_get_rules();
+    if (isHidden(rules, provider, modelId)) return undefined;
+    return this.__hide_providers_orig_find(provider, modelId);
+  };
+}
+
+// Restore original methods on a patched registry.
+function unpatchRegistry(registry: PatchedRegistry): void {
+  if (!registry[PATCH_KEY]) return;
+
+  registry.getAvailable = registry.__hide_providers_orig_getAvailable;
+  registry.getAll = registry.__hide_providers_orig_getAll;
+  registry.find = registry.__hide_providers_orig_find;
+
+  delete (registry as any)[PATCH_KEY];
+  delete (registry as any).__hide_providers_get_rules;
+  delete (registry as any).__hide_providers_orig_getAvailable;
+  delete (registry as any).__hide_providers_orig_getAll;
+  delete (registry as any).__hide_providers_orig_find;
+}
+
+// Extension
+
+export default function (pi: ExtensionAPI) {
+  let currentRules: HideRule[] = [];
+
+  pi.on("session_start", async (_event, ctx) => {
+    const config = readConfig(ctx.cwd);
+    currentRules = config.hide;
+
+    if (currentRules.length > 0) {
+      patchRegistry(ctx.modelRegistry as unknown as PatchedRegistry, () => currentRules);
+
+      if (ctx.hasUI) {
+        ctx.ui.notify(
+          `pi-hide-providers: ${currentRules.length} rule(s) active — getAvailable/getAll/find patched to filter hidden models`,
+          "info",
+        );
+      }
+    }
+  });
+
+  // Safety net: block selection of hidden models if they somehow show up
+  pi.on("model_select", async (event, ctx) => {
+    if (isHidden(currentRules, event.model.provider, event.model.id)) {
+      ctx.ui.notify(
+        `Blocked: ${event.model.provider}/${event.model.id} is hidden by pi-hide-providers`,
+        "warning",
+      );
+    }
+  });
+
+  // /hide-models command — interactive management
+  pi.registerCommand("hide-models", {
+    description: HIDE_COMMAND_DESCRIPTION,
+    getArgumentCompletions(prefix: string) {
+      const subcommands = ["add", "remove", "status", "list", "apply", "reset"];
+      const matches = subcommands.filter((s) => s.startsWith(prefix));
+      return matches.length > 0 ? matches.map((s) => ({ value: s, label: s })) : null;
+    },
+    handler: async (args, ctx) => {
+      await handleHideCommand(ctx, args.trim(), currentRules, (rules) => {
+        currentRules = rules;
+      });
+    },
+  });
+}
+
+async function handleHideCommand(
+  ctx: ExtensionCommandContext,
+  args: string,
+  currentRules: HideRule[],
+  setRules: (rules: HideRule[]) => void,
+): Promise<void> {
+  const parts = args.split(/\s+/);
+  const subcommand = parts[0]?.toLowerCase() ?? "";
+  const rest = parts.slice(1).join(" ");
+
+  // /hide-models — open interactive TUI selector (default action)
+  if (!subcommand) {
+    await showHideSelector(ctx, currentRules, setRules);
+    return;
+  }
+
+  // /hide-models list — show rules
+  if (subcommand === "list") {
+    showStatus(ctx, currentRules);
+    return;
+  }
+
+  // /hide-models add <rule> — add a hide rule
+  if (subcommand === "add") {
+    if (!rest) {
+      ctx.ui.notify(
+        "Usage: /hide-models add <provider> | <provider/model-id> | <provider/*>",
+        "warning",
+      );
+      return;
+    }
+
+    const rule = parseRule(rest);
+    if (!rule) {
+      ctx.ui.notify(
+        `Invalid rule: "${rest}". Use "provider" or "provider/model-id".`,
+        "error",
+      );
+      return;
+    }
+
+    const updated = deduplicateRules([...currentRules, rule]);
+    const configPath = writeConfig(ctx.cwd, { hide: updated });
+    setRules(updated);
+    ctx.ui.notify(
+      `Added: ${formatRule(rule)} (config: ${configPath}). Changes take effect immediately.`,
+      "info",
+    );
+    return;
+  }
+
+  // /hide-models remove <rule> — remove a hide rule
+  if (subcommand === "remove") {
+    if (!rest) {
+      ctx.ui.notify(
+        "Usage: /hide-models remove <provider> | <provider/model-id> | <provider/*>",
+        "warning",
+      );
+      return;
+    }
+
+    const rule = parseRule(rest);
+    if (!rule) {
+      ctx.ui.notify(
+        `Invalid rule: "${rest}". Use "provider" or "provider/model-id".`,
+        "error",
+      );
+      return;
+    }
+
+    const key = formatRule(rule);
+    const before = currentRules.length;
+    const updated = currentRules.filter((r) => formatRule(r) !== key);
+
+    if (updated.length === before) {
+      ctx.ui.notify(`Rule not found: ${key}`, "warning");
+      return;
+    }
+
+    writeConfig(ctx.cwd, { hide: updated });
+    setRules(updated);
+    ctx.ui.notify(
+      `Removed: ${key}. Changes take effect immediately.`,
+      "info",
+    );
+    return;
+  }
+
+  // /hide-models status — show current status
+  if (subcommand === "status") {
+    showStatus(ctx, currentRules);
+    return;
+  }
+
+  // /hide-models apply — notification (changes already active via patched methods)
+  if (subcommand === "apply") {
+    if (currentRules.length === 0) {
+      ctx.ui.notify("No hide rules configured. Use /hide-models add to create rules.", "warning");
+      return;
+    }
+
+    const total = countTotalFromUnpatched(ctx);
+    const hidden = hiddenFromUnpatched(ctx, currentRules);
+
+    ctx.ui.notify(
+      `Applied: ${currentRules.length} rule(s) active — ${total - hidden} visible, ${hidden} hidden (registry methods are patched)`,
+      "info",
+    );
+    return;
+  }
+
+  // /hide-models reset — unpatch registry (takes effect immediately)
+  if (subcommand === "reset") {
+    const registry = ctx.modelRegistry as unknown as PatchedRegistry;
+    if (!registry[PATCH_KEY]) {
+      ctx.ui.notify("Registry is not patched. Nothing to reset.", "info");
+      return;
+    }
+
+    unpatchRegistry(registry);
+    ctx.ui.notify(
+      "Reset: registry unpatched — all models restored immediately.",
+      "info",
+    );
+    return;
+  }
+
+  // /hide-models help
+  if (subcommand === "help") {
+    ctx.ui.notify(
+      [
+        "pi-hide-providers commands:",
+        "  /hide-models              Open interactive TUI to select providers/models to hide",
+        "  /hide-models status      Show current rules and status",
+        "  /hide-models list         Same as /hide-models status",
+        "  /hide-models add <rule>   Add a hide rule (e.g. ollama, openrouter/cheap-model)",
+        "  /hide-models remove <rule> Remove a hide rule",
+        "  /hide-models apply        Show current hide state",
+        "  /hide-models reset        Unpatch registry — restore all models",
+        "  /hide-models help         This message",
+        "",
+        "Rule formats:",
+        '  "provider"           Hide entire provider',
+        '  "provider/*"         Hide entire provider (explicit)',
+        '  "provider/model-id"  Hide specific model',
+        "",
+        "Mechanism: monkey-patches modelRegistry.getAvailable(),",
+        "  getAll(), and find() to filter out hidden models.",
+        "  Takes effect immediately. No settings.json modifications.",
+        "  Survives refresh().",
+      ].join("\n"),
+      "info",
+    );
+    return;
+  }
+
+  ctx.ui.notify(
+    `Unknown subcommand: "${subcommand}". Use /hide-models help for usage.`,
+    "warning",
+  );
+}
+
+// Open the interactive TUI selector for hiding providers/models.
+async function showHideSelector(
+  ctx: ExtensionCommandContext,
+  currentRules: HideRule[],
+  setRules: (rules: HideRule[]) => void,
+): Promise<void> {
+  // Get all models from the unpatched registry (so we see everything)
+  const registry = ctx.modelRegistry as unknown as PatchedRegistry;
+  const allModels = registry.__hide_providers_orig_getAll?.() ?? ctx.modelRegistry.getAll();
+
+  const models = (allModels as any[]).map((m: any) => ({
+    provider: m.provider as string,
+    id: m.id as string,
+    name: (m.name ?? m.id) as string,
+  }));
+
+  const result = await ctx.ui.custom<HideProviderSelectorResult>(
+    (tui, theme, _kb, done) => {
+      const selector = new HideProviderSelectorComponent(
+        theme,
+        models,
+        currentRules,
+        (result) => done(result),
+      );
+
+      return {
+        render(width: number) {
+          return selector.render(width);
+        },
+        invalidate() {
+          selector.invalidate();
+        },
+        handleInput(data: string) {
+          selector.handleInput(data);
+          tui.requestRender();
+        },
+      };
+    },
+  );
+
+  if (!result || result.cancelled) {
+    ctx.ui.notify("Hide selector cancelled.", "info");
+    return;
+  }
+
+  // Apply the new rules
+  const newRules = result.rules;
+  const configPath = writeConfig(ctx.cwd, { hide: newRules });
+  setRules(newRules);
+
+  if (newRules.length === 0) {
+    // No rules left — unpatch the registry
+    unpatchRegistry(registry);
+    ctx.ui.notify("All models visible. Registry unpatched.", "info");
+  } else {
+    // Ensure the registry is patched
+    patchRegistry(registry, () => newRules);
+    ctx.ui.notify(
+      `Hide rules updated: ${newRules.length} rule(s) active (config: ${configPath})`,
+      "info",
+    );
+  }
+}
+
+// Count total models using the original (unpatched) getAll.
+function countTotalFromUnpatched(ctx: ExtensionCommandContext): number {
+  const registry = ctx.modelRegistry as unknown as PatchedRegistry;
+  const all = registry.__hide_providers_orig_getAll?.();
+  if (all) return all.length;
+  try {
+    return (ctx.modelRegistry.getAll() as any[]).length;
+  } catch {
+    return 0;
+  }
+}
+
+// Count hidden models using the original (unpatched) getAll.
+function hiddenFromUnpatched(
+  ctx: ExtensionCommandContext,
+  rules: ReadonlyArray<HideRule>,
+): number {
+  const registry = ctx.modelRegistry as unknown as PatchedRegistry;
+  const all = registry.__hide_providers_orig_getAll?.();
+  if (all) {
+    return (all as any[]).filter((m: any) => isHidden(rules, m.provider, m.id)).length;
+  }
+  try {
+    return (ctx.modelRegistry.getAll() as any[]).filter(
+      (m: any) => isHidden(rules, m.provider, m.id),
+    ).length;
+  } catch {
+    return 0;
+  }
+}
+
+function showStatus(
+  ctx: ExtensionCommandContext,
+  rules: ReadonlyArray<HideRule>,
+): void {
+  const lines: string[] = [];
+
+  if (rules.length === 0) {
+    lines.push("No hide rules configured. Use /hide-models add to create rules.");
+  } else {
+    lines.push(`Hide rules (${rules.length}):`);
+    for (let i = 0; i < rules.length; i++) {
+      lines.push(`  ${i + 1}. ${formatRule(rules[i])}`);
+    }
+  }
+
+  const registry = ctx.modelRegistry as unknown as PatchedRegistry;
+  if (registry[PATCH_KEY]) {
+    lines.push("");
+    lines.push("Status: PATCHED — getAvailable/getAll/find filter hidden models");
+  }
+
+  try {
+    const all = registry.__hide_providers_orig_getAll?.() ?? [];
+    if (all.length > 0) {
+      const hidden = (all as any[]).filter((m: any) => isHidden(rules, m.provider, m.id));
+      lines.push("");
+      lines.push(`Models: ${all.length - hidden.length} visible, ${hidden.length} hidden`);
+      if (hidden.length > 0) {
+        const preview = hidden.slice(0, 10);
+        for (const m of preview) {
+          lines.push(`  ${m.provider}/${m.id}`);
+        }
+        if (hidden.length > 10) {
+          lines.push(`  ... and ${hidden.length - 10} more`);
+        }
+      }
+    }
+  } catch {
+    // ignore
+  }
+
+  ctx.ui.notify(lines.join("\n"), "info");
+}

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "pi-hide-providers",
+  "version": "0.1.0",
+  "description": "Hide providers and models from pi's model selector — filter the /model list and Ctrl+P cycling via a configurable blocklist",
+  "type": "module",
+  "author": "Tom X Nguyen",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/monotykamary/pi-hide-providers.git"
+  },
+  "homepage": "https://github.com/monotykamary/pi-hide-providers#readme",
+  "bugs": {
+    "url": "https://github.com/monotykamary/pi-hide-providers/issues"
+  },
+  "keywords": [
+    "pi-package",
+    "pi",
+    "pi-coding-agent",
+    "extension",
+    "hide",
+    "provider",
+    "model",
+    "filter",
+    "blocklist",
+    "model-selector"
+  ],
+  "files": [
+    "*.ts",
+    "src/",
+    "README.md"
+  ],
+  "scripts": {
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "typecheck": "tsc --noEmit",
+    "lint:dead": "knip --no-gitignore"
+  },
+  "devDependencies": {
+    "@earendil-works/pi-coding-agent": "0.75.4",
+    "@types/node": "25.9.1",
+    "@vitest/coverage-v8": "4.1.7",
+    "knip": "6.14.1",
+    "typescript": "6.0.3",
+    "vitest": "4.1.7"
+  },
+  "pi": {
+    "extensions": [
+      "./hide-providers.ts"
+    ]
+  }
+}

package/src/index.ts

@@ -0,0 +1,97 @@
+/**
+ * Shared constants, types, and utilities for pi-hide-providers.
+ */
+
+/** Description shown in the / commands list. */
+export const HIDE_COMMAND_DESCRIPTION = "Manage which models are hidden from the model selector";
+
+/** Default config file name. */
+export const CONFIG_FILENAME = "hide-providers.json";
+
+/** Glob wildcard — matches any model id within a provider. */
+export const PROVIDER_WILDCARD = "*";
+
+export interface HideRule {
+  /** Provider name to hide (e.g. "ollama", "openrouter"). Required. */
+  provider: string;
+  /**
+   * Model id pattern to hide within the provider.
+   * Use "*" to hide all models from the provider.
+   * Omit or leave undefined to hide the entire provider.
+   */
+  model?: string;
+}
+
+export interface HideProvidersConfig {
+  /** List of hide rules. A model is hidden if it matches ANY rule. */
+  hide: HideRule[];
+}
+
+/**
+ * Check whether a model is matched by any hide rule.
+ *
+ * A rule matches when:
+ * - rule.provider === model.provider (exact, case-sensitive)
+ * - AND (rule.model is undefined OR rule.model === "*" OR rule.model === model.id)
+ */
+export function isHidden(
+  rules: ReadonlyArray<HideRule>,
+  provider: string,
+  modelId: string,
+): boolean {
+  return rules.some(
+    (rule) =>
+      rule.provider === provider &&
+      (rule.model === undefined || rule.model === PROVIDER_WILDCARD || rule.model === modelId),
+  );
+}
+
+/**
+ * Parse a provider/model reference string into a HideRule.
+ *
+ * Formats:
+ *   "provider"           → { provider }            (hide entire provider)
+ *   "provider/*"         → { provider, model: "*" } (hide entire provider, explicit)
+ *   "provider/model-id"  → { provider, model: "model-id" } (hide specific model)
+ */
+export function parseRule(input: string): HideRule | null {
+  const trimmed = input.trim();
+  if (trimmed.length === 0) return null;
+
+  const slashIndex = trimmed.indexOf("/");
+  if (slashIndex === -1) {
+    return { provider: trimmed };
+  }
+
+  const provider = trimmed.slice(0, slashIndex);
+  const model = trimmed.slice(slashIndex + 1);
+
+  if (provider.length === 0) return null;
+
+  return model === PROVIDER_WILDCARD
+    ? { provider }
+    : { provider, model };
+}
+
+/**
+ * Format a HideRule as a human-readable string.
+ */
+export function formatRule(rule: HideRule): string {
+  if (rule.model === undefined || rule.model === PROVIDER_WILDCARD) {
+    return `${rule.provider}/*`;
+  }
+  return `${rule.provider}/${rule.model}`;
+}
+
+/**
+ * Deduplicate hide rules — same provider+model pair only kept once.
+ */
+export function deduplicateRules(rules: ReadonlyArray<HideRule>): HideRule[] {
+  const seen = new Set<string>();
+  return rules.filter((rule) => {
+    const key = formatRule(rule);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}

package/src/provider-selector.ts

@@ -0,0 +1,461 @@
+/**
+ * HideProviderSelectorComponent — an interactive TUI for selecting which
+ * providers/models to hide from pi's model selector.
+ *
+ * Uses the same patterns as pi's built-in ScopedModelsSelectorComponent:
+ * - Lists all available models grouped by provider
+ * - Search/filter via Input component
+ * - Enter toggles hide/show for selected item
+ * - Tab toggles provider-level hide/show
+ * - Ctrl+A / Ctrl+D bulk hide/show (respects search filter)
+ * - Ctrl+S to save and close
+ * - Changes take effect immediately through the patched registry
+ * - Results are returned as HideRule[] array
+ */
+
+import {
+  Container,
+  type Component,
+  fuzzyFilter,
+  getKeybindings,
+  Input,
+  Key,
+  matchesKey,
+  Spacer,
+  Text,
+} from "@earendil-works/pi-tui";
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { DynamicBorder, keyText } from "@earendil-works/pi-coding-agent";
+import {
+  type HideRule,
+  isHidden,
+  deduplicateRules,
+} from "./index.js";
+
+// Internal state for one display row
+
+interface DisplayItem {
+  /** fullId = provider/id */
+  fullId: string;
+  provider: string;
+  modelId: string;
+  modelName: string;
+  hidden: boolean;
+}
+
+// Component
+
+export interface HideProviderSelectorResult {
+  /** The final set of hide rules after the user closes the selector. */
+  rules: HideRule[];
+  /** If true, the user cancelled (esc) and rules should not be applied. */
+  cancelled: boolean;
+}
+
+export class HideProviderSelectorComponent implements Component {
+  // injected dependencies
+  private theme: Theme;
+  private done: (result: HideProviderSelectorResult) => void;
+
+  // model data
+  private allItems: DisplayItem[] = [];
+
+  // current hide rules
+  private hiddenRules: HideRule[] = [];
+
+  // UI state
+  private filteredItems: DisplayItem[] = [];
+  private selectedIndex = 0;
+  private maxVisible = 10;
+  private searchInput: Input;
+  private listContainer: Container;
+  private footerText: Text;
+  private hasChanges = false;
+
+  // Focusable — propagate to search input for IME cursor positioning
+  private _focused = false;
+  get focused(): boolean {
+    return this._focused;
+  }
+  set focused(value: boolean) {
+    this._focused = value;
+    this.searchInput.focused = value;
+  }
+
+  constructor(
+    theme: Theme,
+    allModels: Array<{ provider: string; id: string; name: string }>,
+    currentRules: HideRule[],
+    done: (result: HideProviderSelectorResult) => void,
+  ) {
+    this.theme = theme;
+    this.done = done;
+    this.hiddenRules = deduplicateRules(currentRules);
+
+    // Build display items
+    for (const m of allModels) {
+      this.allItems.push({
+        fullId: `${m.provider}/${m.id}`,
+        provider: m.provider,
+        modelId: m.id,
+        modelName: m.name,
+        hidden: isHidden(currentRules, m.provider, m.id),
+      });
+    }
+    this.filteredItems = [...this.allItems];
+
+    this.searchInput = new Input();
+    this.listContainer = new Container();
+    this.footerText = new Text(this.getFooterText(), 0, 0);
+
+    // Wire search input enter to toggle first visible item
+    this.searchInput.onSubmit = () => {
+      if (this.filteredItems[this.selectedIndex]) {
+        this.toggleItem(this.filteredItems[this.selectedIndex]);
+      }
+    };
+
+    this.updateList();
+  }
+
+  // Component interface
+
+  render(width: number): string[] {
+    const lines: string[] = [];
+
+    lines.push(...new DynamicBorder((s) => this.theme.fg("accent", s)).render(width));
+    lines.push("");
+    lines.push(this.theme.fg("accent", this.theme.bold("Hide Provider Configuration")));
+    lines.push(
+      this.theme.fg(
+        "muted",
+        `Select providers or models to hide from the model selector.`,
+      ),
+    );
+    lines.push("");
+    lines.push(...this.searchInput.render(width));
+    lines.push("");
+    lines.push(...this.listContainer.render(width));
+    lines.push("");
+    lines.push(...this.footerText.render(width));
+    lines.push(...new DynamicBorder((s) => this.theme.fg("accent", s)).render(width));
+
+    return lines;
+  }
+
+  handleInput(data: string): void {
+    const kb = getKeybindings();
+
+    if (kb.matches(data, "tui.select.up")) {
+      if (this.filteredItems.length === 0) return;
+      this.selectedIndex =
+        this.selectedIndex === 0
+          ? this.filteredItems.length - 1
+          : this.selectedIndex - 1;
+      this.updateList();
+      return;
+    }
+
+    if (kb.matches(data, "tui.select.down")) {
+      if (this.filteredItems.length === 0) return;
+      this.selectedIndex =
+        this.selectedIndex === this.filteredItems.length - 1
+          ? 0
+          : this.selectedIndex + 1;
+      this.updateList();
+      return;
+    }
+
+    // Tab — toggle the provider of the selected item
+    if (kb.matches(data, "tui.input.tab")) {
+      const item = this.filteredItems[this.selectedIndex];
+      if (item) {
+        this.toggleProvider(item.provider);
+      }
+      return;
+    }
+
+    // Enter — toggle selected item
+    if (kb.matches(data, "tui.select.confirm")) {
+      const item = this.filteredItems[this.selectedIndex];
+      if (item) {
+        this.toggleItem(item);
+      }
+      return;
+    }
+
+    // Ctrl+A — hide all (filtered if search active)
+    if (matchesKey(data, Key.ctrl("a"))) {
+      const targets = this.getFilterTargets();
+      this.hideModels(targets);
+      this.hasChanges = true;
+      this.refresh();
+      return;
+    }
+
+    // Ctrl+D — show all (filtered if search active)
+    if (matchesKey(data, Key.ctrl("d"))) {
+      const targets = this.getFilterTargets();
+      this.showModels(targets);
+      this.hasChanges = true;
+      this.refresh();
+      return;
+    }
+
+    // Ctrl+S — save and close
+    if (matchesKey(data, Key.ctrl("s"))) {
+      this.finish(false);
+      return;
+    }
+
+    // Escape — cancel
+    if (matchesKey(data, Key.escape)) {
+      this.finish(true);
+      return;
+    }
+
+    // Ctrl+C — clear search or cancel if empty
+    if (matchesKey(data, Key.ctrl("c"))) {
+      if (this.searchInput.getValue()) {
+        this.searchInput.setValue("");
+        this.refresh();
+      } else {
+        this.finish(true);
+      }
+      return;
+    }
+
+    // Pass everything else to search input
+    this.searchInput.handleInput(data);
+    this.refresh();
+  }
+
+  invalidate(): void {
+    this.searchInput.invalidate();
+    this.listContainer.invalidate();
+    this.footerText.invalidate();
+  }
+
+  // Internal helpers
+
+  private getFilterTargets(): DisplayItem[] {
+    const query = this.searchInput.getValue();
+    return query ? this.filteredItems : this.allItems;
+  }
+
+  private getFooterText(): string {
+    const allCount = this.allItems.length;
+    const hiddenCount = this.allItems.filter(
+      (i) => isHidden(this.hiddenRules, i.provider, i.modelId),
+    ).length;
+    const visibleCount = allCount - hiddenCount;
+
+    const parts: string[] = [
+      `${keyText("tui.select.confirm")} toggle`,
+      `tab provider`,
+      `ctrl+a hide all`,
+      `ctrl+d show all`,
+      `ctrl+s done`,
+      `${visibleCount} visible · ${hiddenCount} hidden`,
+    ];
+
+    const text = parts.join(" · ");
+    return this.hasChanges
+      ? this.theme.fg("dim", `  ${text} `) + this.theme.fg("warning", "(unsaved)")
+      : this.theme.fg("dim", `  ${text}`);
+  }
+
+  private refresh(): void {
+    const query = this.searchInput.getValue();
+    this.filteredItems = query
+      ? fuzzyFilter(
+          this.allItems,
+          query,
+          (i) => `${i.provider} ${i.modelId} ${i.provider}/${i.modelId} ${i.modelName}`,
+        )
+      : [...this.allItems];
+
+    // Update hidden status on all items (rules may have changed)
+    for (const item of this.filteredItems) {
+      item.hidden = isHidden(this.hiddenRules, item.provider, item.modelId);
+    }
+
+    this.selectedIndex = Math.min(
+      this.selectedIndex,
+      Math.max(0, this.filteredItems.length - 1),
+    );
+    this.updateList();
+  }
+
+  private updateList(): void {
+    this.listContainer.clear();
+
+    if (this.filteredItems.length === 0) {
+      this.listContainer.addChild(
+        new Text(this.theme.fg("muted", "  No matching models"), 0, 0),
+      );
+      this.footerText.setText(this.getFooterText());
+      return;
+    }
+
+    const startIndex = Math.max(
+      0,
+      Math.min(
+        this.selectedIndex - Math.floor(this.maxVisible / 2),
+        this.filteredItems.length - this.maxVisible,
+      ),
+    );
+    const endIndex = Math.min(startIndex + this.maxVisible, this.filteredItems.length);
+
+    for (let i = startIndex; i < endIndex; i++) {
+      const item = this.filteredItems[i];
+      if (!item) continue;
+
+      const isSelected = i === this.selectedIndex;
+      const prefix = isSelected ? this.theme.fg("accent", "→ ") : "  ";
+      const modelText = isSelected
+        ? this.theme.fg("accent", item.modelId)
+        : item.modelId;
+      const providerBadge = this.theme.fg("muted", ` [${item.provider}]`);
+      const status = item.hidden
+        ? this.theme.fg("warning", " ✗")
+        : this.theme.fg("success", " ✓");
+
+      this.listContainer.addChild(
+        new Text(`${prefix}${modelText}${providerBadge}${status}`, 0, 0),
+      );
+    }
+
+    // Scroll indicator
+    if (startIndex > 0 || endIndex < this.filteredItems.length) {
+      this.listContainer.addChild(
+        new Text(
+          this.theme.fg("muted", `  (${this.selectedIndex + 1}/${this.filteredItems.length})`),
+          0,
+          0,
+        ),
+      );
+    }
+
+    // Model name + provider status for the selected item
+    if (this.filteredItems.length > 0) {
+      const selected = this.filteredItems[this.selectedIndex];
+      this.listContainer.addChild(new Spacer(1));
+      this.listContainer.addChild(
+        new Text(this.theme.fg("muted", `  Model Name: ${selected.modelName}`), 0, 0),
+      );
+
+      const providerItems = this.allItems.filter(
+        (i) => i.provider === selected.provider,
+      );
+      const hiddenInProvider = providerItems.filter(
+        (i) => isHidden(this.hiddenRules, i.provider, i.modelId),
+      ).length;
+      this.listContainer.addChild(
+        new Text(
+          this.theme.fg(
+            "dim",
+            `  Provider: ${selected.provider} — ${providerItems.length - hiddenInProvider} visible, ${hiddenInProvider} hidden`,
+          ),
+          0,
+          0,
+        ),
+      );
+    }
+
+    this.footerText.setText(this.getFooterText());
+  }
+
+  /** Toggle a single item between hidden and visible. */
+  private toggleItem(item: DisplayItem): void {
+    if (item.hidden) {
+      // Remove the matching rule
+      this.hiddenRules = this.hiddenRules.filter(
+        (r) =>
+          !(r.provider === item.provider &&
+            (r.model === item.modelId || r.model === undefined)),
+      );
+    } else {
+      // Add a rule for this specific model
+      this.hiddenRules = deduplicateRules([
+        ...this.hiddenRules,
+        { provider: item.provider, model: item.modelId },
+      ]);
+    }
+    this.hasChanges = true;
+    this.refresh();
+  }
+
+  /** Toggle all models for a provider between hidden and visible. */
+  private toggleProvider(provider: string): void {
+    const providerItems = this.allItems.filter((i) => i.provider === provider);
+    const hiddenCount = providerItems.filter(
+      (i) => isHidden(this.hiddenRules, i.provider, i.modelId),
+    ).length;
+
+    if (hiddenCount > 0) {
+      // Show all — remove all rules for this provider
+      this.hiddenRules = this.hiddenRules.filter(
+        (r) => r.provider !== provider,
+      );
+    } else {
+      // Hide all — add a single provider-level rule
+      this.hiddenRules = deduplicateRules([
+        ...this.hiddenRules,
+        { provider },
+      ]);
+    }
+    this.hasChanges = true;
+    this.refresh();
+  }
+
+  /** Add hide rules for the given items. */
+  private hideModels(items: DisplayItem[]): void {
+    const byProvider = new Map<string, string[]>();
+    for (const item of items) {
+      const list = byProvider.get(item.provider) ?? [];
+      list.push(item.modelId);
+      byProvider.set(item.provider, list);
+    }
+
+    for (const [provider, modelIds] of byProvider) {
+      const totalForProvider = this.allItems.filter(
+        (i) => i.provider === provider,
+      ).length;
+      if (modelIds.length === totalForProvider) {
+        // All models for this provider — use a provider-level rule
+        this.hiddenRules = deduplicateRules([
+          ...this.hiddenRules.filter((r) => r.provider !== provider),
+          { provider },
+        ]);
+      } else {
+        // Partial — add individual model rules
+        for (const modelId of modelIds) {
+          this.hiddenRules = deduplicateRules([
+            ...this.hiddenRules,
+            { provider, model: modelId },
+          ]);
+        }
+      }
+    }
+  }
+
+  /** Remove hide rules for the given items. */
+  private showModels(items: DisplayItem[]): void {
+    for (const item of items) {
+      this.hiddenRules = this.hiddenRules.filter(
+        (r) =>
+          !(r.provider === item.provider &&
+            (r.model === item.modelId || r.model === undefined)),
+      );
+    }
+  }
+
+  /** Close and pass results to `done`. */
+  private finish(cancelled: boolean): void {
+    this.done({
+      rules: cancelled ? [] : this.hiddenRules,
+      cancelled,
+    });
+  }
+}

package/vitest.config.ts

@@ -0,0 +1,15 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: "node",
+    include: ["__tests__/**/*.test.ts"],
+    exclude: ["node_modules", "dist", ".idea", ".git", ".cache"],
+    coverage: {
+      provider: "v8",
+      reporter: ["text", "json", "html"],
+      exclude: ["node_modules/", "**/*.d.ts", "**/*.test.ts"],
+    },
+  },
+});