pi-better-model-select 0.1.4 → 0.3.0

package/extensions/bms.ts

@@ -4,10 +4,13 @@
 // with add / update / delete wired to ctrl-chords so plain typing always goes
 // to the search box.
 
-import { DynamicBorder, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { Container, Text } from "@earendil-works/pi-tui";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { defaultsFlow, piPreference, setMainDefault } from "./lib/defaults.ts";
+import { readSettings, settingsPath } from "./lib/defaults-store.ts";
+import { pickerDialog } from "./lib/picker-dialog.ts";
+import { confirmAction, editForm, tableSelect } from "./lib/tui.ts";
 import { addFlow, deleteFlow, updateFlow, type FlowCtx } from "./lib/flows.ts";
-import { ModelPicker, rankModels, type PickerAction } from "./lib/picker.ts";
+import { rankModels } from "./lib/picker.ts";
 import {
   loadConfig,
   loadConfigFile,
@@ -76,51 +79,50 @@ function syncLocalConfig(pi: ExtensionAPI, ctx: any): ModelsConfig | null {
   return effective;
 }
 
-/** Re-read model configuration from disk and switch the session to the given model. */
+/** Stage option changes until the user explicitly saves. */
 async function optionsFlow(ctx: any, config: ModelsConfig): Promise<void> {
-  for (;;) {
-    const settings = loadSettings();
-    const writeLabel =
-      settings.writeMode === "overlay" ? "BMS overlay (models.bms.json)" : "Pi config (models.json)";
-    const hidden = settings.disabledProviders.length;
-    const pick = await ctx.ui.select("BMS options", [
-      `Write mode: ${writeLabel}`,
-      `Provider filters: ${hidden} hidden`,
-      "Done",
-    ]);
-    if (!pick || pick === "Done") return;
-
-    if (pick.startsWith("Write mode:")) {
-      const mode = await ctx.ui.select("Where should BMS write model changes?", [
-        "BMS overlay (models.bms.json)",
-        "Pi config (models.json)",
-      ]);
-      if (!mode) continue;
-      settings.writeMode = mode.startsWith("BMS overlay") ? "overlay" : "direct";
-      saveSettings(settings);
-      ctx.ui.notify(`BMS write mode: ${settings.writeMode}.`, "info");
-      continue;
-    }
-
-    const providers = Object.keys(config.providers ?? {}).sort();
-    for (;;) {
-      const current = loadSettings();
-      const options = providers.map((provider) =>
-        `${current.disabledProviders.includes(provider) ? "[ ]" : "[x]"} ${provider}`,
-      );
-      const choice = await ctx.ui.select(
-        "Providers shown in /bms (select to toggle, ESC when done)",
-        options,
-      );
-      if (!choice) break;
-      const provider = choice.slice(4);
-      const disabled = new Set(current.disabledProviders);
-      if (disabled.has(provider)) disabled.delete(provider);
-      else disabled.add(provider);
-      current.disabledProviders = [...disabled].sort();
-      saveSettings(current);
-    }
-  }
+  const settings = loadSettings();
+  const providers = Object.keys(config.providers ?? {}).sort();
+  const writeLabel = () => settings.writeMode === "overlay" ? "BMS overlay (models.bms.json)" : "Pi config (models.json)";
+  await editForm(ctx, {
+    title: "Models / Options",
+    fields: [
+      { key: "placement", label: "Result placement", value: settings.resultPlacement === "above" ? "Above prompt" : "Below prompt",
+        description: "The best match stays nearest the search line. Arrow keys follow the displayed direction.",
+        edit: async () => {
+          const value = await tableSelect(ctx, { title: "Models / Options / Result placement", initialValue: settings.resultPlacement,
+            rows: [{ value: "below", label: "Below prompt", description: "Pi-style results. Down moves into the list." }, { value: "above", label: "Above prompt", description: "Results grow upward. Up moves into the list." }] });
+          if (!value) return;
+          settings.resultPlacement = value as "above" | "below";
+          return value === "above" ? "Above prompt" : "Below prompt";
+        } },
+      { key: "write", label: "Write mode", value: writeLabel(),
+        description: "Overlay keeps BMS edits separate from models.json. Direct mode edits Pi's model configuration.",
+        edit: async () => {
+          const value = await tableSelect(ctx, { title: "Models / Options / Write mode", initialValue: settings.writeMode,
+            rows: [{ value: "overlay", label: "BMS overlay", description: "models.bms.json" }, { value: "direct", label: "Pi config", description: "models.json" }] });
+          if (!value) return;
+          settings.writeMode = value as "overlay" | "direct";
+          return writeLabel();
+        } },
+      { key: "providers", label: "Providers", value: `${providers.filter(p => !settings.disabledProviders.includes(p)).length} enabled`,
+        description: "Choose a provider to toggle visibility. Esc returns to options; Ctrl+S saves the complete draft.",
+        edit: async () => {
+          let selected: string | undefined;
+          for (;;) {
+            selected = await tableSelect(ctx, { title: "Models / Options / Providers", initialValue: selected, search: true, placement: settings.resultPlacement,
+              rows: providers.map(provider => ({ value: provider, label: `${settings.disabledProviders.includes(provider) ? "[ ]" : "[x]"} ${provider}` })),
+              hint: "↑↓ move  Enter toggle  Esc back" });
+            if (!selected) break;
+            const disabled = new Set(settings.disabledProviders);
+            if (disabled.has(selected)) disabled.delete(selected); else disabled.add(selected);
+            settings.disabledProviders = [...disabled].sort();
+          }
+          return `${providers.filter(p => !settings.disabledProviders.includes(p)).length} enabled`;
+        } },
+    ],
+    onSave: async () => { saveSettings(settings); ctx.ui.notify("BMS options saved.", "info"); return true; },
+  });
 }
 
 async function loadModel(
@@ -165,6 +167,33 @@ export default function (pi: ExtensionAPI) {
     syncLocalConfig(pi, ctx);
   });
 
+  const report = async (ctx: any, action: () => Promise<void>) => {
+    try { await action(); } catch (error) { ctx.ui.notify(`BMS: ${error}`, "error"); }
+  };
+  const addModel = async (ctx: any) => addFlow(ctx, async (provider, modelId) => {
+    if (syncLocalConfig(pi, ctx)) await report(ctx, () => setMainDefault(pi, ctx, provider, modelId));
+  });
+  pi.registerCommand("bms-options", {
+    description: "Configure BMS result placement, write mode, and provider visibility",
+    handler: async (_args, ctx: any) => {
+      if (ctx.mode !== "tui") { ctx.ui.notify("/bms-options needs an interactive terminal.", "warning"); return; }
+      await report(ctx, async () => {
+        const config = syncLocalConfig(pi, ctx);
+        if (config) await optionsFlow(ctx, config);
+      });
+    },
+  });
+  pi.registerCommand("bms-defaults", {
+    description: "Configure Pi and subagent default models and effort levels",
+    handler: async (_args, ctx: any) => {
+      if (ctx.mode !== "tui") { ctx.ui.notify("/bms-defaults needs an interactive terminal.", "warning"); return; }
+      await report(ctx, async () => {
+        const config = syncLocalConfig(pi, ctx);
+        if (config) await defaultsFlow(pi, ctx, config);
+      });
+    },
+  });
+
   pi.registerCommand("bms", {
     description: "Better model select — searchable, usage-ranked model picker",
     handler: async (_args, ctx: any) => {
@@ -173,7 +202,8 @@ export default function (pi: ExtensionAPI) {
         return;
       }
 
-      // Loop so the picker reappears after each add / update / delete.
+      // Preserve search and selection while opening submenus.
+      const pickerState: { query?: string; selectedValue?: string } = {};
       for (;;) {
         const config = syncLocalConfig(pi, ctx);
         if (!config) return;
@@ -200,41 +230,31 @@ export default function (pi: ExtensionAPI) {
             "The effective model configuration has no models. Add one now?",
           );
           if (!add) return;
-          await addFlow(ctx as FlowCtx);
+          await report(ctx, () => addModel(ctx));
           continue;
         }
 
-        const action: PickerAction | undefined = await ctx.ui.custom((tui: any, theme: any, _kb: any, done: any) => {
-          const container = new Container();
-          const accent = (s: string) =>
-            typeof theme?.fg === "function" ? theme.fg("accent", s) : s;
-
-          container.addChild(new DynamicBorder(accent));
-          container.addChild(new Text(accent("Better Model Select"), 1, 0));
-
-          const picker = new ModelPicker(
-            rows,
-            theme,
-            () => tui.requestRender(),
-            (a: PickerAction) => done(a),
-          );
-          picker.focused = true;
-          container.addChild(picker);
-          container.addChild(new DynamicBorder(accent));
-
-          return {
-            render: (w: number) => container.render(w),
-            invalidate: () => container.invalidate(),
-            handleInput: (data: string) => picker.handleInput(data),
-          };
-        });
+        try {
+          const preference = piPreference(readSettings(settingsPath(ctx.cwd, "user")), ctx.isProjectTrusted?.() ? readSettings(settingsPath(ctx.cwd, "project")) : {});
+          for (const row of rows) {
+            row.current = ctx.model?.provider === row.provider && ctx.model?.id === row.modelId;
+            row.default = preference.provider === row.provider && preference.model === row.modelId;
+          }
+        } catch (error) { ctx.ui.notify(`Cannot read defaults: ${error}`, "warning"); }
+        const action = await pickerDialog(ctx, rows, "Models", false, { placement: settings.resultPlacement, state: pickerState });
 
         switch (action?.kind) {
           case "load":
             await loadModel(pi, ctx, action.provider, action.modelId);
             return;
+          case "set-default":
+            await report(ctx, () => setMainDefault(pi, ctx, action.provider, action.modelId));
+            break;
+          case "defaults":
+            await report(ctx, () => defaultsFlow(pi, ctx, config));
+            break;
           case "add":
-            await addFlow(ctx as FlowCtx);
+            await report(ctx, () => addModel(ctx));
             break;
           case "update":
             await updateFlow(
@@ -256,10 +276,11 @@ export default function (pi: ExtensionAPI) {
             await optionsFlow(ctx, config);
             break;
           case "reset": {
-            const ok = await ctx.ui.confirm(
-              "Reset usage statistics?",
-              "Model ranking falls back to alphabetical order.",
-            );
+            const ok = await confirmAction(ctx, {
+              title: "Models / Reset usage",
+              lines: ["Clear all BMS model selection counts and last-used times.", "Ranking returns to alphabetical order. Models and defaults are unchanged."],
+              confirmLabel: "Reset usage",
+            });
             if (ok) {
               saveUsage({ version: 1, counts: {}, lastUsed: {} });
               ctx.ui.notify("Usage statistics cleared.", "info");
@@ -276,6 +297,6 @@ export default function (pi: ExtensionAPI) {
   // Standalone add, kept for muscle memory and non-interactive convenience.
   pi.registerCommand("bms-add", {
     description: "Add a model from a provider's endpoint using the configured write mode",
-    handler: async (_args, ctx: any) => addFlow(ctx as FlowCtx),
+    handler: async (_args, ctx: any) => report(ctx, () => addModel(ctx)),
   });
 }

package/extensions/lib/agents.ts

@@ -0,0 +1,60 @@
+// Optional, isolated adapter: pi-subagents currently has no public discovery RPC.
+// Never vendor a second agent-discovery implementation or execute an agent to list roles.
+import { createRequire } from "node:module";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+
+export interface AgentRole {
+  name: string;
+  model?: string;
+  thinking?: string | false;
+  runner?: unknown;
+  source?: string;
+  modelSource?: unknown;
+}
+export interface AgentDiscovery {
+  roles: AgentRole[];
+  projectRoot: string;
+  warning?: string;
+}
+/** Resolve the owning package, not the directory of its possibly bundled entry point. */
+export function subagentsPackageRoot(entry: string): string {
+  let directory = dirname(entry);
+  for (;;) {
+    try {
+      const manifest = JSON.parse(readFileSync(join(directory, "package.json"), "utf8"));
+      if (manifest.name === "pi-subagents") return directory;
+    } catch { /* keep looking above a bundle or other entry-point directory */ }
+    const parent = dirname(directory);
+    if (parent === directory) throw new Error("Cannot locate pi-subagents package root");
+    directory = parent;
+  }
+}
+export async function discoverRoles(cwd: string, pi: any, provider?: string, trusted = false): Promise<AgentDiscovery> {
+  try {
+    // Resolve only from this extension or the user's trusted Pi package directory.
+    const roots = [import.meta.url, pathToFileURL(join(getAgentDir(), "npm", "package.json")).href];
+    let entry: string | undefined;
+    for (const root of roots) {
+      try { entry = createRequire(root).resolve("pi-subagents"); break; } catch { /* optional package */ }
+    }
+    if (!entry) throw new Error("pi-subagents is not resolvable from BMS or the Pi npm package directory");
+    const base = subagentsPackageRoot(entry);
+    const api = await import(pathToFileURL(join(base, "src/agents/agents.js")).href);
+    if (typeof api.discoverAgents !== "function") throw new Error("Unsupported pi-subagents discovery API");
+    api.clearAgentDiscoveryCache?.();
+    const result = api.discoverAgents(cwd, trusted ? "both" : "user", provider, { projectTrusted: trusted });
+    let roles: AgentRole[] = result.agents;
+    try {
+      const runtime = await import(pathToFileURL(join(base, "src/agents/runtime-agent-registry.js")).href);
+      roles = runtime.mergeRuntimeAgents(pi, result, undefined, { cwd, scope: trusted ? "both" : "user", preferredModelProvider: provider, projectTrusted: trusted }).agents;
+    } catch { /* older versions have filesystem agents only */ }
+    // Native Pi and subagents may choose different roots. Use the subagents settings root for agents.
+    const projectRoot = api.findConfiguredProjectRoot?.(cwd) ?? cwd;
+    return { roles: [...roles].sort((a, b) => a.name.localeCompare(b.name)), projectRoot };
+  } catch (error) {
+    return { roles: [], projectRoot: cwd, warning: `Agent discovery unavailable: ${error}. Pi defaults remain available.` };
+  }
+}

package/extensions/lib/defaults-models.ts

@@ -0,0 +1,15 @@
+import { rankModels, type RankedModel } from "./picker.ts";
+import type { ModelsConfig } from "./store.ts";
+
+/** Assignment menus include authenticated registry models, not only custom models.json entries. */
+export function rankModelsForDefaults(config: ModelsConfig, ctx: any): RankedModel[] {
+  const rows = rankModels(config);
+  const seen = new Set(rows.map(row => `${row.provider}/${row.modelId}`));
+  for (const model of ctx.modelRegistry.getAvailable?.() ?? []) {
+    const key = `${model.provider}/${model.id}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    rows.push({ provider: model.provider, modelId: model.id, label: model.name ?? model.id, count: 0, lastUsed: 0, reasoning: model.reasoning, contextWindow: model.contextWindow });
+  }
+  return rows;
+}

package/extensions/lib/defaults-store.ts

@@ -0,0 +1,108 @@
+// Defaults use native Pi settings. BMS capability hints live separately from models.json.
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { randomUUID } from "node:crypto";
+
+export const EFFORTS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"] as const;
+export type Effort = typeof EFFORTS[number];
+export type Scope = "user" | "project";
+export type JsonObject = Record<string, any>;
+export function isEffort(value: unknown): value is Effort {
+  return typeof value === "string" && (EFFORTS as readonly string[]).includes(value);
+}
+export function object(value: unknown): JsonObject {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("Expected a JSON object");
+  return value as JsonObject;
+}
+export function readSettings(path: string): JsonObject {
+  if (!existsSync(path)) return {};
+  return object(JSON.parse(readFileSync(path, "utf8")));
+}
+/** Fail closed on malformed files; serialize BMS writers and re-read immediately before patching. */
+export function patchSettings(path: string, patch: (settings: JsonObject) => void): void {
+  mkdirSync(dirname(path), { recursive: true });
+  const lock = `${path}.bms-lock`;
+  const fd = openSync(lock, "wx", 0o600);
+  const tmp = `${path}.bms-${randomUUID()}`;
+  try {
+    const settings = readSettings(path);
+    patch(settings);
+    writeFileSync(tmp, JSON.stringify(settings, null, 2) + "\n", { mode: 0o600 });
+    renameSync(tmp, path);
+  } finally {
+    if (existsSync(tmp)) unlinkSync(tmp);
+    closeSync(fd);
+    unlinkSync(lock);
+  }
+}
+export function settingsPath(cwd: string, scope: Scope, agentDir = getAgentDir()): string {
+  return scope === "user" ? join(agentDir, "settings.json") : join(cwd, ".pi", "settings.json");
+}
+export interface Capability {
+  levels: Effort[];
+  source: "provider" | "manual" | "pi";
+}
+export function metadataPath(): string { return join(getAgentDir(), "bms-model-metadata.json"); }
+export function normalizeEfforts(raw: unknown): Effort[] | undefined {
+  if (!Array.isArray(raw) || !raw.length || !raw.every(isEffort)) return undefined;
+  return EFFORTS.filter(level => raw.includes(level));
+}
+export function capabilities(key: string, model?: { reasoning?: boolean; thinkingLevelMap?: Record<string, unknown> }, path = metadataPath()): { levels: Effort[]; source: string } {
+  const stored = readSettings(path)[key];
+  const levels = normalizeEfforts(stored?.levels);
+  if (levels) return { levels, source: stored.source === "provider" ? "Provider metadata" : stored.source === "manual" ? "Manual override" : "Pi standard levels; provider support unverified" };
+  if (model?.reasoning === false) return { levels: ["off"], source: "Non-reasoning model" };
+  // Native maps explicitly mark unsupported Pi levels with null.
+  if (model?.thinkingLevelMap) {
+    const supported = EFFORTS.filter(level => model.thinkingLevelMap![level] !== null);
+    if (supported.length) return { levels: supported, source: "Pi model capability map" };
+  }
+  return { levels: [...EFFORTS], source: "Pi standard levels; provider support unverified" };
+}
+export function saveCapability(key: string, capability: Capability, path = metadataPath()): void {
+  if (!normalizeEfforts(capability.levels)) throw new Error("Choose at least one valid effort level");
+  patchSettings(path, data => { data[key] = capability; });
+}
+export function setPiDefault(data: JsonObject, provider: string, model: string, effort: Effort | undefined): void {
+  data.defaultProvider = provider;
+  data.defaultModel = model;
+  if (effort === undefined) delete data.defaultThinkingLevel;
+  else data.defaultThinkingLevel = effort;
+  // A per-model startup preference would otherwise beat the newly chosen default.
+  if (data.modelThinkingLevels !== undefined) {
+    const levels = object(data.modelThinkingLevels);
+    delete levels[`${provider}/${model}`];
+  }
+}
+export function setRoleField(data: JsonObject, role: string | undefined, field: "model" | "thinking", value: string | false | undefined): void {
+  if (role && ["__proto__", "constructor", "prototype"].includes(role)) throw new Error("Invalid agent name");
+  const sub = data.subagents === undefined ? data.subagents = {} : object(data.subagents);
+  if (!role) {
+    const key = field === "model" ? "defaultModel" : "defaultThinking";
+    if (value === undefined) delete sub[key];
+    else sub[key] = value;
+    return;
+  }
+  const overrides = sub.agentOverrides === undefined ? sub.agentOverrides = {} : object(sub.agentOverrides);
+  const entry = Object.hasOwn(overrides, role) ? object(overrides[role]) : overrides[role] = {};
+  if (value === undefined) delete entry[field];
+  else entry[field] = value;
+  if (!Object.keys(entry).length) delete overrides[role];
+}
+/** Settings-only projection for the menu, not a claim about a running child. */
+export function roleField(user: JsonObject, project: JsonObject, provider: string | undefined, role: string | undefined, field: "model" | "thinking"): { value: unknown; source: string } {
+  for (const [scope, data] of [["Project", project], ["User", user]] as const) {
+    const sub = data.subagents;
+    if (role) {
+      const scoped = provider && sub?.agentOverridesByProvider?.[provider]?.[role];
+      if (scoped && Object.hasOwn(scoped, field)) return { value: scoped[field], source: `${scope}, provider override` };
+      const regular = sub?.agentOverrides?.[role];
+      if (regular && Object.hasOwn(regular, field)) return { value: regular[field], source: `${scope} role override` };
+    } else {
+      const key = field === "model" ? "defaultModel" : "defaultThinking";
+      if (sub && Object.hasOwn(sub, key)) return { value: sub[key], source: `${scope} fallback` };
+    }
+  }
+  return { value: undefined, source: role ? "Agent-defined / fallback" : "Parent session" };
+}