pi-better-model-select 0.1.4 → 0.3.0

package/extensions/lib/defaults.ts

@@ -0,0 +1,237 @@
+import { discoverRoles, type AgentRole } from "./agents.ts";
+import { capabilities, isEffort, patchSettings, readSettings, roleField, setPiDefault, setRoleField, settingsPath, type Effort, type JsonObject, type Scope } from "./defaults-store.ts";
+import { tableSelect, editForm, confirmAction } from "./tui.ts";
+import { rankModelsForDefaults } from "./defaults-models.ts";
+import type { ModelsConfig } from "./store.ts";
+
+export async function chooseEffort(ctx: any, key: string, model?: any, initial?: unknown): Promise<Effort | "automatic" | undefined> {
+  const capability = capabilities(key, model);
+  const levels = [...capability.levels];
+  if (isEffort(initial) && levels.includes(initial)) levels.splice(levels.indexOf(initial), 1), levels.unshift(initial);
+  const title = `Effort for ${key}\n${capability.source}\nAutomatic removes this scope's preference. Pi/provider may clamp unsupported levels.`;
+  // Keep the public helper usable by RPC and legacy headless select mocks.
+  if (typeof ctx.ui.custom !== "function") return ctx.ui.select(title, ["automatic", ...levels]);
+  return await tableSelect(ctx, { title, initialValue: typeof initial === "string" ? initial : "automatic", rows: ["automatic", ...levels].map(value => ({ value, label: value })) }) as Effort | "automatic" | undefined;
+}
+export function piPreference(user: JsonObject, project: JsonObject): { provider?: string; model?: string; effort?: Effort; source: string } {
+  const provider = project.defaultProvider ?? user.defaultProvider;
+  const model = project.defaultModel ?? user.defaultModel;
+  const key = `${provider}/${model}`;
+  const effort = project.modelThinkingLevels?.[key] ?? user.modelThinkingLevels?.[key] ?? project.defaultThinkingLevel ?? user.defaultThinkingLevel;
+  return { provider, model, effort, source: project.defaultModel !== undefined || project.defaultProvider !== undefined ? "Project" : "User / automatic" };
+}
+function trusted(pi: any, ctx: any): boolean {
+  return typeof ctx.isProjectTrusted === "function" ? ctx.isProjectTrusted() : typeof pi.isProjectTrusted === "function" && pi.isProjectTrusted();
+}
+function projectSettings(pi: any, ctx: any, cwd: string): JsonObject { return trusted(pi, ctx) ? readSettings(settingsPath(cwd, "project")) : {}; }
+function confirmDefault(ctx: any, title: string, message: string, confirmLabel: string): Promise<boolean> {
+  return typeof ctx.ui.custom === "function"
+    ? confirmAction(ctx, { title, lines: message.split("\n"), confirmLabel })
+    : ctx.ui.confirm(title, message);
+}
+
+/** Switch first; never replace saved defaults when authentication/model selection fails. */
+export async function setMainDefault(pi: any, ctx: any, provider: string, modelId: string, scope: Scope = "user"): Promise<void> {
+  await applyMainDefault(pi, ctx, provider, modelId, scope);
+}
+async function applyMainDefault(pi: any, ctx: any, provider: string, modelId: string, scope: Scope, selectedEffort?: Effort | "automatic"): Promise<boolean> {
+  if (scope === "project" && !trusted(pi, ctx)) throw new Error("Project is not trusted");
+  await ctx.modelRegistry.refresh();
+  const model = ctx.modelRegistry.find(provider, modelId);
+  if (!model) throw new Error(`Model ${provider}/${modelId} is not in the active registry`);
+  const user = readSettings(settingsPath(ctx.cwd, "user"));
+  const project = projectSettings(pi, ctx, ctx.cwd);
+  const choice = selectedEffort ?? await chooseEffort(ctx, `${provider}/${modelId}`, model, piPreference(user, project).effort);
+  if (choice === undefined) return false;
+  const effort = choice === "automatic" ? undefined : choice;
+  const preview = structuredClone(scope === "user" ? user : project);
+  setPiDefault(preview, provider, modelId, effort);
+  const effective = piPreference(scope === "user" ? preview : user, scope === "project" ? preview : project);
+  const shadowed = effective.provider !== provider || effective.model !== modelId || (effort !== undefined && effective.effort !== effort);
+  if (shadowed && !(await confirmDefault(ctx, "Higher-priority settings", "Project or per-model settings override this preference at startup. Save and use your selection in this session anyway?", "Save and use anyway"))) return false;
+  if (selectedEffort === undefined && !(await confirmDefault(ctx, "Save and use Pi default?", `${provider}/${modelId}, effort ${choice}\nScope: ${scope}\n${settingsPath(ctx.cwd, scope)}`, "Save and use"))) return false;
+  // Parse before changing session state. A malformed file must never be overwritten.
+  readSettings(settingsPath(ctx.cwd, scope));
+  const previousModel = ctx.model;
+  const previousEffort = pi.getThinkingLevel();
+  if (!(await pi.setModel(model))) {
+    ctx.ui.notify("Could not switch model. Defaults were not changed.", "warning");
+    return false;
+  }
+  const requested = effort ?? effective.effort ?? "medium";
+  try {
+    pi.setThinkingLevel(requested);
+    const applied = pi.getThinkingLevel();
+    if (effort !== undefined && applied !== effort && !(await confirmDefault(ctx, "Pi adjusted the effort", `Requested ${effort}; Pi uses ${applied}. Save ${applied} instead?`, `Save ${applied}`))) {
+      if (previousModel) await pi.setModel(previousModel);
+      pi.setThinkingLevel(previousEffort);
+      return false;
+    }
+    patchSettings(settingsPath(ctx.cwd, scope), data => setPiDefault(data, provider, modelId, effort === undefined ? undefined : applied));
+    ctx.ui.notify(`Using ${provider}/${modelId}, effort ${applied}. Saved ${scope} Pi default.${shadowed ? " Higher-priority startup settings still apply." : ""}`, "info");
+    return true;
+  } catch (error) {
+    if (previousModel) await pi.setModel(previousModel);
+    pi.setThinkingLevel(previousEffort);
+    throw error;
+  }
+}
+
+function display(value: unknown): string {
+  if (value === undefined) return "agent-defined / fallback";
+  if (value === false) return "off";
+  return String(value);
+}
+async function assignModel(ctx: any, config: ModelsConfig, title: string): Promise<{ provider: string; modelId: string } | undefined> {
+  const rows = rankModelsForDefaults(config, ctx);
+  if (!rows.length) { ctx.ui.notify("No models available to assign.", "warning"); return; }
+  const value = await tableSelect(ctx, { title, search: true, columns: [{ key: "model", label: "MODEL" }, { key: "provider", label: "PROVIDER" }], rows: rows.map((row, index) => ({ value: String(index), label: row.label, cells: { model: row.modelId, provider: row.provider } })) });
+  const row = value === undefined ? undefined : rows[Number(value)];
+  return row ? { provider: row.provider, modelId: row.modelId } : undefined;
+}
+async function editPiDefault(pi: any, ctx: any, config: ModelsConfig, scope: Scope, user: JsonObject, project: JsonObject): Promise<void> {
+  const current = piPreference(user, project);
+  let provider = current.provider, modelId = current.model;
+  let effort: Effort | "automatic" = current.effort ?? "automatic";
+  let reset = false;
+  const path = settingsPath(ctx.cwd, scope);
+  await editForm(ctx, {
+    title: "Pi session default",
+    hint: `Scope: ${scope}\n${path}\nSave switches the session after validating the model. Higher-priority settings still apply at startup.`,
+    fields: [
+      { key: "model", label: "Model", value: `${provider ?? "auto"}/${modelId ?? "auto"}`, edit: async () => {
+        const action = await tableSelect(ctx, { title: "Pi default model", rows: [{ value: "choose", label: "Choose model" }, { value: "reset", label: "Remove scope defaults", description: "Remove this scope's default model and global effort. Keep other per-model preferences." }] });
+        if (action === undefined) return;
+        if (action === "reset") {
+          if (!(await confirmAction(ctx, { title: "Reset Pi defaults?", lines: [`Scope: ${scope}`, path, "Remove defaultProvider, defaultModel and defaultThinkingLevel only. Session stays unchanged."], confirmLabel: "Reset scope defaults" }))) return;
+          reset = true; return "remove scope defaults";
+        }
+        const selected = await assignModel(ctx, config, "Choose Pi default model");
+        if (!selected) return;
+        provider = selected.provider; modelId = selected.modelId; reset = false;
+        return `${provider}/${modelId}`;
+      } },
+      { key: "effort", label: "Effort", value: effort, edit: async () => {
+        if (!provider || !modelId || reset) { ctx.ui.notify("Choose a model first.", "warning"); return; }
+        const selected = await chooseEffort(ctx, `${provider}/${modelId}`, ctx.modelRegistry.find(provider, modelId), effort);
+        if (selected === undefined) return;
+        effort = selected; return selected;
+      } },
+    ],
+    onSave: async () => {
+      if (scope === "project" && !trusted(pi, ctx)) throw new Error("Project is not trusted");
+      if (reset) {
+        patchSettings(path, data => { delete data.defaultProvider; delete data.defaultModel; delete data.defaultThinkingLevel; });
+        return true;
+      }
+      if (!provider || !modelId) { ctx.ui.notify("Choose a model first.", "warning"); return false; }
+      return applyMainDefault(pi, ctx, provider, modelId, scope, effort);
+    },
+  });
+}
+export async function defaultsFlow(pi: any, ctx: any, config: ModelsConfig): Promise<void> {
+  let scope: Scope = "user";
+  const state = {};
+  for (;;) {
+    const discovery = await discoverRoles(ctx.cwd, pi, ctx.model?.provider, trusted(pi, ctx));
+    const user = readSettings(settingsPath(ctx.cwd, "user"));
+    const project = projectSettings(pi, ctx, ctx.cwd);
+    const agentUser = readSettings(settingsPath(discovery.projectRoot, "user"));
+    const agentProject = projectSettings(pi, ctx, discovery.projectRoot);
+    const main = piPreference(user, project);
+    const roles = discovery.roles;
+    const modelFallback = roleField(agentUser, agentProject, ctx.model?.provider, undefined, "model");
+    const thinkingFallback = roleField(agentUser, agentProject, ctx.model?.provider, undefined, "thinking");
+    const selected = await tableSelect(ctx, {
+      title: "BMS defaults",
+      search: false,
+      state,
+      hint: `Scope: ${scope}. Saved settings, not running children. Agent changes require /reload.\nPi: ${settingsPath(ctx.cwd, scope)}\nAgents: ${settingsPath(discovery.projectRoot, scope)}`,
+      columns: [{ key: "target", label: "TARGET" }, { key: "model", label: "MODEL" }, { key: "effort", label: "EFFORT" }, { key: "source", label: "SOURCE" }],
+      rows: [
+        { value: "0", label: `Scope: ${scope}`, cells: { target: "Scope", model: scope, effort: "", source: "Select to change" } },
+        { value: "1", label: "Pi session", cells: { target: "Pi session", model: `${main.provider ?? "auto"}/${main.model ?? "auto"}`, effort: main.effort ?? "automatic", source: main.source } },
+        { value: "2", label: "Subagent fallback", cells: { target: "Subagent fallback", model: display(modelFallback.value), effort: display(thinkingFallback.value), source: `${modelFallback.source}; ${thinkingFallback.source}` } },
+        ...roles.map((role, index) => {
+          const model = roleField(agentUser, agentProject, ctx.model?.provider, role.name, "model");
+          const effort = roleField(agentUser, agentProject, ctx.model?.provider, role.name, "thinking");
+          return { value: String(index + 3), label: role.name, cells: { target: role.name, model: display(model.value ?? role.model), effort: display(effort.value ?? role.thinking), source: role.runner ? "External runner" : `${model.source}; ${effort.source}` } };
+        }),
+        ...(discovery.warning ? [{ value: "details", label: "Agent discovery details" }] : []),
+        { value: "done", label: "Done" },
+      ],
+    });
+    if (selected === undefined || selected === "done") return;
+    const index = Number(selected);
+    if (index === 0) {
+      if (!trusted(pi, ctx)) { ctx.ui.notify("Project defaults require a trusted project.", "warning"); continue; }
+      scope = scope === "user" ? "project" : "user";
+    } else if (index === 1) {
+      await editPiDefault(pi, ctx, config, scope, user, project);
+    } else if (selected === "details") {
+      ctx.ui.notify(discovery.warning!, "warning");
+    } else {
+      const role = index === 2 ? undefined : roles[index - 3];
+      await editRole(pi, ctx, config, scope, discovery.projectRoot, role, agentUser, agentProject);
+    }
+  }
+}
+async function editRole(pi: any, ctx: any, config: ModelsConfig, scope: Scope, root: string, role: AgentRole | undefined, user: JsonObject, project: JsonObject): Promise<void> {
+  const title = role?.name ?? "Subagent fallback";
+  const path = settingsPath(root, scope);
+  if (role?.runner) {
+    ctx.ui.notify("External runner defaults are not editable with the Pi registry picker. Use the runner's own configuration.", "warning");
+    return;
+  }
+  const local = scope === "user" ? user : project;
+  const entry = role ? local.subagents?.agentOverrides?.[role.name] : undefined;
+  let model: string | undefined = role ? entry?.model : local.subagents?.defaultModel;
+  let effort: string | false | undefined = role ? entry?.thinking : local.subagents?.defaultThinking;
+  let modelChanged = false, effortChanged = false;
+  await editForm(ctx, {
+    title: `${title} defaults`,
+    hint: `Scope: ${scope}\n${path}\nProvider-specific and project overrides still take precedence. Removing effort restores agent-defined/fallback behavior, not parent inheritance.`,
+    fields: [
+      { key: "model", label: "Model", value: model ?? "remove override", edit: async () => {
+        const action = await tableSelect(ctx, { title: `Model for ${title}`, rows: [
+          { value: "choose", label: "Choose model" },
+          { value: "inherit", label: "Inherit parent model", description: "Explicitly use the parent session model." },
+          { value: "remove", label: "Remove model override", description: `Remove only the ${scope} ${title} model override.` },
+        ] });
+        if (action === undefined) return;
+        if (action === "choose") {
+          const selected = await assignModel(ctx, config, `Choose model for ${title}`);
+          if (!selected) return;
+          model = `${selected.provider}/${selected.modelId}`;
+        } else if (action === "inherit") model = "inherit";
+        else {
+          if (!(await confirmAction(ctx, { title: "Remove model override?", lines: [`Target: ${title}`, `Scope: ${scope}`, path], confirmLabel: "Remove override" }))) return;
+          model = undefined;
+        }
+        modelChanged = true;
+        return model ?? "remove override";
+      } },
+      { key: "effort", label: "Effort", value: display(effort), edit: async () => {
+        const effective = modelChanged ? model : roleField(user, project, ctx.model?.provider, role?.name, "model").value ?? role?.model;
+        const ref = typeof effective === "string" && effective !== "inherit" ? effective.replace(/:(off|minimal|low|medium|high|xhigh|max)$/, "") : `${ctx.model?.provider}/${ctx.model?.id}`;
+        const split = ref.indexOf("/");
+        const selected = await chooseEffort(ctx, ref, split > 0 ? ctx.modelRegistry.find(ref.slice(0, split), ref.slice(split + 1)) : undefined, effort);
+        if (selected === undefined) return;
+        if (selected === "automatic" && !(await confirmAction(ctx, { title: "Remove effort override?", lines: [`Target: ${title}`, `Scope: ${scope}`, path, "Restores agent-defined/fallback behavior."], confirmLabel: "Remove override" }))) return;
+        effort = selected === "automatic" ? undefined : selected;
+        effortChanged = true;
+        return effort ?? "remove override";
+      } },
+    ],
+    onSave: async () => {
+      if (scope === "project" && !trusted(pi, ctx)) throw new Error("Project is not trusted");
+      if (!modelChanged && !effortChanged) return true;
+      patchSettings(path, data => {
+        if (modelChanged) setRoleField(data, role?.name, "model", model);
+        if (effortChanged) setRoleField(data, role?.name, "thinking", effort);
+      });
+      ctx.ui.notify(`Saved ${title}. Run /reload to refresh subagent defaults.`, "info");
+      return true;
+    },
+  });
+}

package/extensions/lib/effort-editor.ts

@@ -0,0 +1,84 @@
+import type { FlowCtx } from "./flows.ts";
+import { editForm, tableSelect } from "./tui.ts";
+import { capabilities, EFFORTS, isEffort, metadataPath, normalizeEfforts, patchSettings, readSettings, saveCapability, settingsPath, type Capability, type Effort } from "./defaults-store.ts";
+
+export interface EffortDraft { capability: Capability; preferred?: Effort }
+export function modelEffortDraft(ctx: FlowCtx, key: string, reasoning: boolean, reported?: Effort[]): EffortDraft {
+  const existing = capabilities(key, { reasoning });
+  const levels = !reasoning ? ["off" as const] : reported ?? existing.levels;
+  const source: Capability["source"] = reported ? "provider" : existing.source === "Manual override" ? "manual" : "pi";
+  const previous = readSettings(settingsPath(ctx.cwd ?? process.cwd(), "user")).modelThinkingLevels?.[key];
+  return { capability: { levels: [...levels], source }, preferred: isEffort(previous) ? previous : undefined };
+}
+export async function editModelEfforts(ctx: FlowCtx, key: string, reasoning: boolean, reported?: Effort[], initial?: EffortDraft): Promise<EffortDraft | undefined> {
+  const draft = structuredClone(initial ?? modelEffortDraft(ctx, key, reasoning, reported));
+  if (!reasoning) draft.capability = { levels: ["off"], source: "pi" };
+  const saved = await editForm(ctx, {
+    title: `Efforts for ${key}`,
+    hint: "Apply returns a draft to the model form. Only the outer Save writes files.",
+    fields: [
+      { key: "levels", label: "Available levels", value: draft.capability.levels.join(", "), description: `Source: ${draft.capability.source}. Provider support may be unverified.`, edit: async () => {
+        if (!reasoning) { ctx.ui.notify("Non-reasoning models only support off.", "info"); return; }
+        const raw = await ctx.ui.input(`Comma-separated Pi efforts: ${EFFORTS.join(", ")}`, draft.capability.levels.join(", "));
+        if (raw === undefined) return;
+        const levels = normalizeEfforts(raw.split(",").map(value => value.trim()));
+        if (!levels) { ctx.ui.notify("Choose one or more valid Pi effort levels.", "warning"); return; }
+        draft.capability = { levels, source: "manual" };
+        return levels.join(", ");
+      } },
+      { key: "preferred", label: "Preferred effort", value: draft.preferred ?? "automatic", description: "Automatic removes the user per-model preference, not agent role defaults.", edit: async () => {
+        const selected = await tableSelect(ctx, { title: `Preferred effort for ${key}`, initialValue: draft.preferred ?? "automatic", rows: ["automatic", ...draft.capability.levels].map(value => ({ value, label: value })) });
+        if (selected === undefined) return;
+        draft.preferred = isEffort(selected) ? selected : undefined;
+        return selected;
+      } },
+    ],
+    onSave: async () => {
+      if (draft.preferred && !draft.capability.levels.includes(draft.preferred)) { ctx.ui.notify("Preferred effort must be available. Choose another effort or automatic.", "warning"); return false; }
+      return true;
+    },
+  });
+  return saved ? draft : undefined;
+}
+/** Do not silently invalidate saved defaults when editing model capability hints. */
+export function effortConflicts(data: Record<string, any>, key: string, levels: readonly Effort[], preferred?: Effort): string[] {
+  const conflicts: string[] = [];
+  const check = (label: string, effort: unknown) => {
+    if (isEffort(effort) && !levels.includes(effort)) conflicts.push(`${label}: ${effort}`);
+  };
+  check("Per-model preference", preferred);
+  if (`${data.defaultProvider}/${data.defaultModel}` === key) check("Pi default", preferred ?? data.defaultThinkingLevel);
+  const sub = data.subagents;
+  if (sub?.defaultModel === key) check("Subagent fallback", sub.defaultThinking);
+  const scan = (entries: Record<string, any> | undefined, prefix: string) => {
+    for (const [name, entry] of Object.entries(entries ?? {})) {
+      if (entry.model === key) check(`${prefix}${name}`, entry.thinking);
+    }
+  };
+  scan(sub?.agentOverrides, "Agent ");
+  for (const [provider, entries] of Object.entries(sub?.agentOverridesByProvider ?? {})) scan(entries as any, `${provider} agent `);
+  return conflicts;
+}
+export function saveModelEfforts(ctx: FlowCtx & { cwd?: string }, key: string, draft: EffortDraft): boolean {
+  const userPath = settingsPath(ctx.cwd ?? process.cwd(), "user");
+  const projectPath = settingsPath(ctx.cwd ?? process.cwd(), "project");
+  const project = ctx.isProjectTrusted?.() ? readSettings(projectPath) : {};
+  const conflicts = [
+    ...effortConflicts(readSettings(userPath), key, draft.capability.levels, draft.preferred),
+    ...effortConflicts(project, key, draft.capability.levels, project.modelThinkingLevels?.[key] ?? draft.preferred).map(value => `Project ${value}`),
+  ];
+  if (conflicts.length) {
+    ctx.ui.notify(`Effort update blocked. Change these defaults in /bms-defaults first: ${conflicts.join("; ")}`, "warning");
+    return false;
+  }
+  // Validate the capability file before writing a preference in a different file.
+  readSettings(metadataPath());
+  patchSettings(userPath, data => {
+    const levels = data.modelThinkingLevels ??= {};
+    if (!levels || typeof levels !== "object" || Array.isArray(levels)) throw new Error("Invalid modelThinkingLevels settings");
+    if (draft.preferred === undefined) delete levels[key];
+    else levels[key] = draft.preferred;
+  });
+  saveCapability(key, draft.capability);
+  return true;
+}