pi-model-control 0.1.9 → 0.1.10

package/extensions/variants.ts

@@ -5,12 +5,11 @@ import type { Focusable } from "@earendil-works/pi-tui";
 import { readFileSync, existsSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
-import { DISPLAY_LEVELS, getSupportedLevels, displayToPi, piToDisplay } from "./shared.js";
+import { getSupportedLevels, displayToPi } from "./shared.js";
 
-interface VariantEntry {
+interface ModelEntry {
   provider: string;
   model: string;
-  thinking: string;
 }
 
 function loadEnabledModels(): Set<string> | null {
@@ -26,11 +25,11 @@ function loadEnabledModels(): Set<string> | null {
   return null;
 }
 
-function generateVariants(ctx: ExtensionCommandContext): VariantEntry[] {
+function getEnabledModels(ctx: ExtensionCommandContext): ModelEntry[] {
   const allModels = ctx.modelRegistry.getAll();
   const enabledSet = loadEnabledModels();
   const seen = new Set<string>();
-  const variants: VariantEntry[] = [];
+  const entries: ModelEntry[] = [];
 
   for (const m of allModels) {
     const key = `${m.provider}/${m.id}`;
@@ -39,31 +38,31 @@ function generateVariants(ctx: ExtensionCommandContext): VariantEntry[] {
 
     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,
-      });
-    }
+    entries.push({ provider: m.provider, model: m.id });
   }
 
-  return variants;
+  return entries;
 }
 
-class ModelSelectorComponent extends Container implements Focusable {
+/**
+ * Универсальный searchable-список для TUI.
+ * Рендерит `renderLine` для каждого элемента, фильтрует по `filterKey`.
+ */
+class SearchableSelector<T> extends Container implements Focusable {
   private searchInput: Input;
   private listContainer: Container;
-  private allVariants: VariantEntry[];
-  private filteredVariants: VariantEntry[];
+  private allItems: T[];
+  private filteredItems: T[];
   private selectedIndex = 0;
-  private onSelectCallback: (variant: VariantEntry) => void;
+  private onSelectCallback: (item: T) => void;
   private onCancelCallback: () => void;
-  private tui: TUI;
   private theme: Theme;
   private headerText: Text;
   private hintText: Text;
+  private headerLabel: string;
+  private filterKey: (item: T) => string;
+  private renderLine: (item: T, isSelected: boolean) => string;
+  private emptyLabel: string;
 
   private _focused = false;
   get focused(): boolean {
@@ -74,22 +73,28 @@ class ModelSelectorComponent extends Container implements Focusable {
     this.searchInput.focused = value;
   }
 
-  constructor(
-    tui: TUI,
-    theme: Theme,
-    variants: VariantEntry[],
-    onSelect: (variant: VariantEntry) => void,
-    onCancel: () => void,
-  ) {
+  constructor(opts: {
+    theme: Theme;
+    items: T[];
+    headerLabel: string;
+    emptyLabel: string;
+    filterKey: (item: T) => string;
+    renderLine: (item: T, isSelected: boolean) => string;
+    onSelect: (item: T) => 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.theme = opts.theme;
+    this.allItems = opts.items;
+    this.filteredItems = opts.items;
+    this.headerLabel = opts.headerLabel;
+    this.emptyLabel = opts.emptyLabel;
+    this.filterKey = opts.filterKey;
+    this.renderLine = opts.renderLine;
+    this.onSelectCallback = opts.onSelect;
+    this.onCancelCallback = opts.onCancel;
+
+    this.addChild(new DynamicBorder((s: string) => opts.theme.fg("accent", s)));
     this.addChild(new Spacer(1));
 
     this.headerText = new Text("", 1, 0);
@@ -98,7 +103,7 @@ class ModelSelectorComponent extends Container implements Focusable {
 
     this.searchInput = new Input();
     this.searchInput.onSubmit = () => {
-      const selected = this.filteredVariants[this.selectedIndex];
+      const selected = this.filteredItems[this.selectedIndex];
       if (selected) this.onSelectCallback(selected);
     };
     this.addChild(this.searchInput);
@@ -111,7 +116,7 @@ class ModelSelectorComponent extends Container implements Focusable {
     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.addChild(new DynamicBorder((s: string) => opts.theme.fg("accent", s)));
 
     this.updateHeader();
     this.updateHints();
@@ -120,7 +125,7 @@ class ModelSelectorComponent extends Container implements Focusable {
 
   private updateHeader(): void {
     this.headerText.setText(
-      this.theme.fg("accent", this.theme.bold(`Models (${this.allVariants.length} variants)`)),
+      this.theme.fg("accent", this.theme.bold(`${this.headerLabel} (${this.allItems.length})`)),
     );
   }
 
@@ -132,44 +137,41 @@ class ModelSelectorComponent extends Container implements Focusable {
 
   private applyFilter(query: string): void {
     if (!query.trim()) {
-      this.filteredVariants = this.allVariants;
+      this.filteredItems = this.allItems;
     } else {
-      this.filteredVariants = fuzzyFilter(this.allVariants, query, (v) => `${v.model} ${v.thinking}`);
+      this.filteredItems = fuzzyFilter(this.allItems, query, this.filterKey);
     }
-    this.selectedIndex = Math.min(this.selectedIndex, Math.max(0, this.filteredVariants.length - 1));
+    this.selectedIndex = Math.min(this.selectedIndex, Math.max(0, this.filteredItems.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));
+    if (this.filteredItems.length === 0) {
+      this.listContainer.addChild(new Text(this.theme.fg("muted", `  ${this.emptyLabel}`), 0, 0));
       return;
     }
 
     const maxVisible = 12;
     const startIndex = Math.max(
       0,
-      Math.min(this.selectedIndex - Math.floor(maxVisible / 2), this.filteredVariants.length - maxVisible),
+      Math.min(this.selectedIndex - Math.floor(maxVisible / 2), this.filteredItems.length - maxVisible),
     );
-    const endIndex = Math.min(startIndex + maxVisible, this.filteredVariants.length);
+    const endIndex = Math.min(startIndex + maxVisible, this.filteredItems.length);
 
     for (let i = startIndex; i < endIndex; i++) {
-      const v = this.filteredVariants[i];
-      if (!v) continue;
+      const item = this.filteredItems[i];
+      if (!item) 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));
+      this.listContainer.addChild(new Text(`${prefix}${this.renderLine(item, isSelected)}`, 0, 0));
     }
 
-    if (startIndex > 0 || endIndex < this.filteredVariants.length) {
+    if (startIndex > 0 || endIndex < this.filteredItems.length) {
       const scrollInfo = this.theme.fg(
         "dim",
-        `  (${this.selectedIndex + 1}/${this.filteredVariants.length})`,
+        `  (${this.selectedIndex + 1}/${this.filteredItems.length})`,
       );
       this.listContainer.addChild(new Text(scrollInfo, 0, 0));
     }
@@ -178,19 +180,19 @@ class ModelSelectorComponent extends Container implements Focusable {
   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;
+      if (this.filteredItems.length === 0) return;
+      this.selectedIndex = this.selectedIndex === 0 ? this.filteredItems.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;
+      if (this.filteredItems.length === 0) return;
+      this.selectedIndex = this.selectedIndex === this.filteredItems.length - 1 ? 0 : this.selectedIndex + 1;
       this.updateList();
       return;
     }
     if (kb.matches(keyData, "tui.select.confirm")) {
-      const selected = this.filteredVariants[this.selectedIndex];
+      const selected = this.filteredItems[this.selectedIndex];
       if (selected) this.onSelectCallback(selected);
       return;
     }
@@ -210,53 +212,97 @@ class ModelSelectorComponent extends Container implements Focusable {
   }
 }
 
+async function pickModel(
+  ctx: ExtensionCommandContext,
+  models: ModelEntry[],
+): Promise<ModelEntry | null> {
+  return ctx.ui.custom<ModelEntry | null>((tui: TUI, theme, _kb, done) => {
+    const selector = new SearchableSelector<ModelEntry>({
+      theme,
+      items: models,
+      headerLabel: "Models",
+      emptyLabel: "No matching models",
+      filterKey: (m) => `${m.provider} ${m.model}`,
+      renderLine: (m, isSelected) => {
+        const color = isSelected ? "accent" : "text";
+        const dim = isSelected ? "accent" : "muted";
+        return `${theme.fg(color, m.model)} ${theme.fg(dim, `(${m.provider})`)}`;
+      },
+      onSelect: (m) => done(m),
+      onCancel: () => done(null),
+    });
+
+    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); },
+    };
+  });
+}
+
+async function pickLevel(
+  ctx: ExtensionCommandContext,
+  levels: string[],
+): Promise<string | null> {
+  return ctx.ui.custom<string | null>((tui: TUI, theme, _kb, done) => {
+    const selector = new SearchableSelector<string>({
+      theme,
+      items: levels,
+      headerLabel: "Thinking level",
+      emptyLabel: "No matching levels",
+      filterKey: (l) => l,
+      renderLine: (l, isSelected) => theme.fg(isSelected ? "accent" : "text", l),
+      onSelect: (l) => done(l),
+      onCancel: () => done(null),
+    });
+
+    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); },
+    };
+  });
+}
+
 export default function (pi: ExtensionAPI) {
   pi.registerCommand("variants", {
-    description: "Switch model + thinking level (searchable)",
+    description: "Switch model + thinking level (searchable, two-step)",
     async handler(_args: string, ctx: ExtensionCommandContext) {
-      const variants = generateVariants(ctx);
+      const models = getEnabledModels(ctx);
 
-      if (variants.length === 0) {
+      if (models.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(v);
-          },
-          () => done(null),
-        );
-
-        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);
+      const chosenModel = await pickModel(ctx, models);
+      if (!chosenModel) return;
+
+      const model = ctx.modelRegistry.find(chosenModel.provider, chosenModel.model);
       if (!model) {
-        ctx.ui.notify(`Model ${result.provider}/${result.model} not found`, "error");
+        ctx.ui.notify(`Model ${chosenModel.provider}/${chosenModel.model} not found`, "error");
         return;
       }
 
+      const levels = getSupportedLevels(model);
+
+      let chosenLevel: string;
+      if (levels.length <= 1) {
+        // У модели нет выбора уровня (или только "default") — не дёргаем UI зря
+        chosenLevel = levels[0] ?? "default";
+      } else {
+        const picked = await pickLevel(ctx, levels);
+        if (picked === null) return;
+        chosenLevel = picked;
+      }
+
       await pi.setModel(model);
-      pi.setThinkingLevel(displayToPi(result.thinking) as any);
-      ctx.ui.notify(`✓ ${result.model} → ${result.thinking}`, "info");
+      pi.setThinkingLevel(displayToPi(chosenLevel) as any);
+      ctx.ui.notify(`✓ ${chosenModel.model} → ${chosenLevel}`, "info");
     },
   });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-model-control",
-  "version": "0.1.9",
+  "version": "0.1.10",
   "description": "Model and thinking level controls for pi — /variants and /thinking commands",
   "type": "module",
   "files": [