pi-model-control 0.1.0

package/README.md

@@ -0,0 +1,22 @@
+# pi-model-control
+
+Model and thinking level controls for pi.
+
+## Commands
+
+- **`/variants`** — Searchable model + thinking level selector. Shows only enabled models from your API. Type to fuzzy-filter, ↑↓ navigate, Enter to confirm.
+- **`/thinking`** — Select thinking level for the current model.
+
+## Install
+
+```json
+// settings.json
+{
+  "packages": ["npm:pi-model-control"]
+}
+```
+
+Or via pi CLI:
+```
+pi package install pi-model-control
+```

package/extensions/thinking.ts

@@ -0,0 +1,48 @@
+import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+
+const DISPLAY_LEVELS = ["default", "minimal", "low", "medium", "high", "max"];
+
+function getSupportedLevels(m: any): string[] {
+  if (!m.reasoning) return ["default"];
+  return DISPLAY_LEVELS.filter((level) => {
+    const piLevel = level === "default" ? "off" : level;
+    const mapped = m.thinkingLevelMap?.[piLevel];
+    if (mapped === null) return false;
+    if (level === "max") return mapped !== undefined;
+    return true;
+  });
+}
+
+function displayToPi(display: string): string {
+  return display === "default" ? "off" : display;
+}
+
+function piToDisplay(pi: string): string {
+  return pi === "off" ? "default" : pi;
+}
+
+export default function (pi: ExtensionAPI) {
+  pi.registerCommand("thinking", {
+    description: "Select thinking level for current model",
+    async handler(_args: string, ctx: ExtensionCommandContext) {
+      const model = ctx.model;
+      if (!model) {
+        ctx.ui.notify("No active model", "error");
+        return;
+      }
+
+      const levels = getSupportedLevels(model);
+      const currentDisplay = piToDisplay(pi.getThinkingLevel());
+      const labels = levels.map((l) => l === currentDisplay ? `${l} ✓` : l);
+
+      const chosen = await ctx.ui.select(`Thinking level — ${model.id}`, labels);
+      if (!chosen) return;
+
+      const displayLevel = chosen.replace(" ✓", "");
+      if (!levels.includes(displayLevel)) return;
+
+      pi.setThinkingLevel(displayToPi(displayLevel) as any);
+      ctx.ui.notify(`✓ Thinking: ${displayLevel}`, "info");
+    },
+  });
+}

package/extensions/variants.ts

@@ -0,0 +1,278 @@
+import type { ExtensionAPI, ExtensionCommandContext, Theme } from "@earendil-works/pi-coding-agent";
+import { DynamicBorder } from "@earendil-works/pi-coding-agent";
+import { Input, Container, TUI, Text, Spacer, fuzzyFilter, getKeybindings } from "@earendil-works/pi-tui";
+import type { Focusable } from "@earendil-works/pi-tui";
+import { readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+interface VariantEntry {
+  provider: string;
+  model: string;
+  thinking: string;
+}
+
+const DISPLAY_LEVELS = ["default", "minimal", "low", "medium", "high", "max"];
+
+function getSupportedLevels(m: any): string[] {
+  if (!m.reasoning) return ["default"];
+  return DISPLAY_LEVELS.filter((level) => {
+    const piLevel = level === "default" ? "off" : level;
+    const mapped = m.thinkingLevelMap?.[piLevel];
+    if (mapped === null) return false;
+    if (level === "max") return mapped !== undefined;
+    return true;
+  });
+}
+
+function displayToPi(display: string): string {
+  return display === "default" ? "off" : display;
+}
+
+function loadEnabledModels(): Set<string> | null {
+  const dir = process.env.PI_CODING_AGENT_DIR || join(homedir(), ".pi", "agent");
+  const path = join(dir, "settings.json");
+  if (existsSync(path)) {
+    try {
+      const raw = readFileSync(path, "utf-8");
+      const data = JSON.parse(raw);
+      if (Array.isArray(data.enabledModels)) return new Set(data.enabledModels);
+    } catch { /* fall through */ }
+  }
+  return null;
+}
+
+function generateVariants(ctx: ExtensionCommandContext): VariantEntry[] {
+  const allModels = ctx.modelRegistry.getAll();
+  const enabledSet = loadEnabledModels();
+  const seen = new Set<string>();
+  const variants: VariantEntry[] = [];
+
+  for (const m of allModels) {
+    const key = `${m.provider}/${m.id}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+
+    if (enabledSet && !enabledSet.has(key)) continue;
+
+    const levels = getSupportedLevels(m);
+    for (const t of levels) {
+      variants.push({
+        provider: m.provider,
+        model: m.id,
+        thinking: t,
+      });
+    }
+  }
+
+  return variants;
+}
+
+class ModelSelectorComponent extends Container implements Focusable {
+  private searchInput: Input;
+  private listContainer: Container;
+  private allVariants: VariantEntry[];
+  private filteredVariants: VariantEntry[];
+  private selectedIndex = 0;
+  private onSelectCallback: (variant: VariantEntry) => void;
+  private onCancelCallback: () => void;
+  private tui: TUI;
+  private theme: Theme;
+  private headerText: Text;
+  private hintText: Text;
+
+  private _focused = false;
+  get focused(): boolean {
+    return this._focused;
+  }
+  set focused(value: boolean) {
+    this._focused = value;
+    this.searchInput.focused = value;
+  }
+
+  constructor(
+    tui: TUI,
+    theme: Theme,
+    variants: VariantEntry[],
+    onSelect: (variant: VariantEntry) => void,
+    onCancel: () => void,
+  ) {
+    super();
+    this.tui = tui;
+    this.theme = theme;
+    this.allVariants = variants;
+    this.filteredVariants = variants;
+    this.onSelectCallback = onSelect;
+    this.onCancelCallback = onCancel;
+
+    this.addChild(new DynamicBorder((s: string) => theme.fg("accent", s)));
+    this.addChild(new Spacer(1));
+
+    this.headerText = new Text("", 1, 0);
+    this.addChild(this.headerText);
+    this.addChild(new Spacer(1));
+
+    this.searchInput = new Input();
+    this.searchInput.onSubmit = () => {
+      const selected = this.filteredVariants[this.selectedIndex];
+      if (selected) this.onSelectCallback(selected);
+    };
+    this.addChild(this.searchInput);
+
+    this.addChild(new Spacer(1));
+    this.listContainer = new Container();
+    this.addChild(this.listContainer);
+
+    this.addChild(new Spacer(1));
+    this.hintText = new Text("", 1, 0);
+    this.addChild(this.hintText);
+    this.addChild(new Spacer(1));
+    this.addChild(new DynamicBorder((s: string) => theme.fg("accent", s)));
+
+    this.updateHeader();
+    this.updateHints();
+    this.applyFilter("");
+  }
+
+  private updateHeader(): void {
+    this.headerText.setText(
+      this.theme.fg("accent", this.theme.bold(`Models (${this.allVariants.length} variants)`)),
+    );
+  }
+
+  private updateHints(): void {
+    this.hintText.setText(
+      this.theme.fg("dim", "Type to search · ↑↓ select · Enter confirm · Esc cancel"),
+    );
+  }
+
+  private applyFilter(query: string): void {
+    if (!query.trim()) {
+      this.filteredVariants = this.allVariants;
+    } else {
+      this.filteredVariants = fuzzyFilter(this.allVariants, query, (v) => `${v.model} ${v.thinking}`);
+    }
+    this.selectedIndex = Math.min(this.selectedIndex, Math.max(0, this.filteredVariants.length - 1));
+    this.updateList();
+  }
+
+  private updateList(): void {
+    this.listContainer.clear();
+
+    if (this.filteredVariants.length === 0) {
+      this.listContainer.addChild(new Text(this.theme.fg("muted", "  No matching models"), 0, 0));
+      return;
+    }
+
+    const maxVisible = 12;
+    const startIndex = Math.max(
+      0,
+      Math.min(this.selectedIndex - Math.floor(maxVisible / 2), this.filteredVariants.length - maxVisible),
+    );
+    const endIndex = Math.min(startIndex + maxVisible, this.filteredVariants.length);
+
+    for (let i = startIndex; i < endIndex; i++) {
+      const v = this.filteredVariants[i];
+      if (!v) continue;
+      const isSelected = i === this.selectedIndex;
+      const prefix = isSelected ? this.theme.fg("accent", "→ ") : "  ";
+      const modelColor = isSelected ? "accent" : "text";
+      const thinkingColor = isSelected ? "accent" : "muted";
+      const line = `${prefix}${this.theme.fg(modelColor, v.model)} ${this.theme.fg(thinkingColor, `(${v.thinking})`)}`;
+      this.listContainer.addChild(new Text(line, 0, 0));
+    }
+
+    if (startIndex > 0 || endIndex < this.filteredVariants.length) {
+      const scrollInfo = this.theme.fg(
+        "dim",
+        `  (${this.selectedIndex + 1}/${this.filteredVariants.length})`,
+      );
+      this.listContainer.addChild(new Text(scrollInfo, 0, 0));
+    }
+  }
+
+  handleInput(keyData: string): void {
+    const kb = getKeybindings();
+    if (kb.matches(keyData, "tui.select.up")) {
+      if (this.filteredVariants.length === 0) return;
+      this.selectedIndex = this.selectedIndex === 0 ? this.filteredVariants.length - 1 : this.selectedIndex - 1;
+      this.updateList();
+      return;
+    }
+    if (kb.matches(keyData, "tui.select.down")) {
+      if (this.filteredVariants.length === 0) return;
+      this.selectedIndex = this.selectedIndex === this.filteredVariants.length - 1 ? 0 : this.selectedIndex + 1;
+      this.updateList();
+      return;
+    }
+    if (kb.matches(keyData, "tui.select.confirm")) {
+      const selected = this.filteredVariants[this.selectedIndex];
+      if (selected) this.onSelectCallback(selected);
+      return;
+    }
+    if (kb.matches(keyData, "tui.select.cancel")) {
+      this.onCancelCallback();
+      return;
+    }
+    this.searchInput.handleInput(keyData);
+    this.applyFilter(this.searchInput.getValue());
+  }
+
+  override invalidate(): void {
+    super.invalidate();
+    this.updateHeader();
+    this.updateHints();
+    this.updateList();
+  }
+}
+
+export default function (pi: ExtensionAPI) {
+  pi.registerCommand("variants", {
+    description: "Switch model + thinking level (searchable)",
+    async handler(_args: string, ctx: ExtensionCommandContext) {
+      const variants = generateVariants(ctx);
+
+      if (variants.length === 0) {
+        ctx.ui.notify("No enabled models found", "error");
+        return;
+      }
+
+      const result = await ctx.ui.custom<VariantEntry | null>((tui, theme, _kb, done) => {
+        let selected: VariantEntry | null = null;
+
+        const selector = new ModelSelectorComponent(
+          tui,
+          theme,
+          variants,
+          (v) => {
+            selected = v;
+            done();
+          },
+          () => done(),
+        );
+
+        return {
+          get focused() { return true; },
+          set focused(value: boolean) {
+            selector.focused = value;
+          },
+          render(width: number) { return selector.render(width); },
+          invalidate() { selector.invalidate(); },
+          handleInput(data: string) { selector.handleInput(data); },
+        };
+      });
+
+      if (!result) return;
+
+      const model = ctx.modelRegistry.find(result.provider, result.model);
+      if (!model) {
+        ctx.ui.notify(`Model ${result.provider}/${result.model} not found`, "error");
+        return;
+      }
+
+      await pi.setModel(model);
+      pi.setThinkingLevel(displayToPi(result.thinking) as any);
+      ctx.ui.notify(`✓ ${result.model} → ${result.thinking}`, "info");
+    },
+  });
+}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "pi-model-control",
+  "version": "0.1.0",
+  "description": "Model and thinking level controls for pi — /variants and /thinking commands",
+  "type": "module",
+  "files": [
+    "extensions"
+  ],
+  "keywords": [
+    "pi-package",
+    "pi",
+    "coding-agent",
+    "extensions",
+    "model",
+    "thinking"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "pi": {
+    "extensions": [
+      "./extensions/variants.ts",
+      "./extensions/thinking.ts"
+    ]
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*"
+  },
+  "devDependencies": {
+    "sigstore": "^5.0.0"
+  },
+  "dependencies": {
+    "libnpmpublish": "^12.0.0",
+    "node-fetch": "^3.3.2"
+  }
+}