pi-better-model-select 0.2.0 → 0.3.0

package/extensions/lib/effort-editor.ts

@@ -1,29 +1,44 @@
 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 async function editModelEfforts(ctx: FlowCtx, key: string, reasoning: boolean, reported?: Effort[]): Promise<EffortDraft | undefined> {
+export function modelEffortDraft(ctx: FlowCtx, key: string, reasoning: boolean, reported?: Effort[]): EffortDraft {
   const existing = capabilities(key, { reasoning });
-  let levels = !reasoning ? ["off" as const] : reported ?? existing.levels;
-  let source: Capability["source"] = reported ? "provider" : existing.source === "Manual override" ? "manual" : "pi";
-  if (reasoning) {
-    const mode = await ctx.ui.select(`Available efforts for ${key}\n${reported ? "Provider metadata" : existing.source}`, ["Use listed levels", "Configure manually"]);
-    if (!mode) return;
-    if (mode === "Configure manually") {
-      const raw = await ctx.ui.input(`Comma-separated Pi efforts: ${EFFORTS.join(", ")}`, levels.join(", "));
-      if (raw === undefined) return;
-      const parsed = normalizeEfforts(raw.split(",").map(value => value.trim()));
-      if (!parsed) { ctx.ui.notify("Choose one or more valid Pi effort levels. Nothing changed.", "warning"); return; }
-      levels = parsed;
-      source = "manual";
-    }
-  }
+  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];
-  const options = ["automatic", ...levels];
-  if (isEffort(previous) && levels.includes(previous)) options.splice(options.indexOf(previous), 1), options.unshift(previous);
-  const preferred = await ctx.ui.select(`Preferred effort when Pi loads ${key}\nCurrent: ${previous ?? "automatic"}. Saved in user modelThinkingLevels, independently of agent role defaults.`, options);
-  if (preferred === undefined) return;
-  return { capability: { levels, source }, preferred: isEffort(preferred) ? preferred : undefined };
+  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[] {