pi-hide-providers 0.1.4 → 0.1.6

package/README.md

@@ -30,7 +30,7 @@ Pi has `enabledModels` in `settings.json` as an allowlist, but maintaining it ma
 - The `/model` selector, `Ctrl+P` cycling, `--list-models`, and session restoration all see only visible models
 - `/hide-models reset` unpatches the registry — all models return immediately
 - Changes via `/hide-models add` and `/hide-models remove` take effect immediately (no reload needed)
-- Interactive `/hide-models` TUI lists visible providers/models first, re-sorting as you hide or show items — same ordering behavior as pi core's `/scoped-models`
+- Interactive `/hide-models` TUI lists visible models first in user-toggle order, then hidden models in their original registry order, and keeps the cursor at the same index after each toggle — matching pi core's `/scoped-models` UX
 - `/hide-models` subcommands for adding, removing, and inspecting rules
 
 No `settings.json` is modified. No 250+ entry explosion. No allowlist semantics.

package/hide-providers.ts

@@ -159,13 +159,6 @@ export default function (pi: ExtensionAPI) {
 
     if (currentRules.length > 0) {
       patchRegistry(ctx.modelRegistry as unknown as PatchedRegistry, () => currentRules);
-
-      if (ctx.hasUI) {
-        ctx.ui.notify(
-          `pi-hide-providers: ${currentRules.length} rule(s) active — getAvailable/getAll/find patched to filter hidden models`,
-          "info",
-        );
-      }
     }
   });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hide-providers",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "Hide providers and models from pi's model selector — filter the /model list and Ctrl+P cycling via a configurable blocklist",
   "type": "module",
   "author": "Tom X Nguyen",
@@ -30,26 +30,25 @@
     "src/",
     "README.md"
   ],
-  "scripts": {
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "test:coverage": "vitest run --coverage",
-    "typecheck": "tsc --noEmit",
-    "lint:dead": "knip --no-gitignore"
-  },
   "devDependencies": {
     "@earendil-works/pi-coding-agent": "0.79.4",
+    "@earendil-works/pi-tui": "0.79.4",
     "@types/node": "25.9.1",
     "@vitest/coverage-v8": "4.1.7",
     "knip": "6.14.1",
     "typescript": "6.0.3",
-    "vitest": "4.1.7",
-    "@earendil-works/pi-tui": "0.79.4"
+    "vitest": "4.1.7"
   },
   "pi": {
     "extensions": [
       "./hide-providers.ts"
     ]
   },
-  "peerDependencies": {}
-}
+  "scripts": {
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "typecheck": "tsc --noEmit",
+    "lint:dead": "knip --no-gitignore"
+  }
+}

package/src/provider-selector.ts

@@ -61,6 +61,10 @@ export class HideProviderSelectorComponent implements Component {
   // model data
   private allItems: DisplayItem[] = [];
 
+  // visible model fullIds in the order they were unhidden (mirrors pi core's
+  // enabledIds cycle order in the scoped models selector)
+  private visibleIds: string[] = [];
+
   // current hide rules
   private hiddenRules: HideRule[] = [];
 
@@ -93,7 +97,7 @@ export class HideProviderSelectorComponent implements Component {
     this.done = done;
     this.hiddenRules = deduplicateRules(currentRules);
 
-    // Build display items
+    // Build display items in the original registry order.
     for (const m of allModels) {
       this.allItems.push({
         fullId: `${m.provider}/${m.id}`,
@@ -103,9 +107,12 @@ export class HideProviderSelectorComponent implements Component {
         hidden: isHidden(currentRules, m.provider, m.id),
       });
     }
-    // Enabled (visible) providers/models first, then alphabetical within each group
-    this.sortItems(this.allItems);
-    this.filteredItems = [...this.allItems];
+    // Track visible models in original order initially; toggle order changes
+    // during the session, matching pi core's /scoped-models behavior.
+    this.visibleIds = this.allItems
+      .filter((i) => !i.hidden)
+      .map((i) => i.fullId);
+    this.filteredItems = this.buildItems();
 
     this.searchInput = new Input();
     this.listContainer = new Container();
@@ -271,27 +278,24 @@ export class HideProviderSelectorComponent implements Component {
   private refresh(): void {
     const query = this.searchInput.getValue();
 
-    // Recompute hidden status on the canonical full list first, then sort it.
-    // This ensures both allItems and filteredItems stay ordered as enabled
-    // (visible) models first, disabled (hidden) models second.
+    // Recompute hidden status, then rebuild the list in pi core's order:
+    // visible models in user-toggle order, followed by hidden models in
+    // original registry order.
     for (const item of this.allItems) {
       item.hidden = isHidden(this.hiddenRules, item.provider, item.modelId);
     }
-    this.sortItems(this.allItems);
 
+    const items = this.buildItems();
     this.filteredItems = query
       ? fuzzyFilter(
-          this.allItems,
+          items,
           query,
           (i) => `${i.provider} ${i.modelId} ${i.provider}/${i.modelId} ${i.modelName}`,
         )
-      : [...this.allItems];
-
-    // Ensure filtered results also honor enabled-first ordering.
-    this.sortItems(this.filteredItems);
+      : items;
 
-    // Keep the cursor at the same relative position after re-sorting. The
-    // selected model may change, which matches pi's /scoped-models behavior.
+    // Keep the cursor at the same numeric index after re-sorting. The selected
+    // model may change, matching pi core's /scoped-models behavior.
     this.selectedIndex = Math.min(
       this.selectedIndex,
       Math.max(0, this.filteredItems.length - 1),
@@ -300,27 +304,30 @@ export class HideProviderSelectorComponent implements Component {
     this.updateList();
   }
 
-  /** Sort items so enabled (visible) models come before disabled (hidden)
-   *  models, then alphabetically by provider and model id. Each model is ranked
-   *  individually — a single visible model in a provider does not pull the whole
-   *  provider to the top.
+  /** Build the display order used by pi core's scoped models selector:
+   *  visible models first in the order they were unhidden, then hidden models
+   *  in their original registry order.
    */
-  private sortItems(items: DisplayItem[]): void {
-    items.sort((a, b) => {
-      // Visible models first, then hidden models.
-      if (a.hidden !== b.hidden) {
-        return a.hidden ? 1 : -1;
+  private buildItems(): DisplayItem[] {
+    const visibleSet = new Set(this.visibleIds);
+    const result: DisplayItem[] = [];
+
+    // Visible models in user-toggle order.
+    for (const fullId of this.visibleIds) {
+      const item = this.allItems.find((i) => i.fullId === fullId);
+      if (item && !item.hidden) {
+        result.push(item);
       }
+    }
 
-      // Then alphabetical by provider.
-      const providerCompare = a.provider.localeCompare(b.provider);
-      if (providerCompare !== 0) {
-        return providerCompare;
+    // Hidden models in original registry order.
+    for (const item of this.allItems) {
+      if (item.hidden && !visibleSet.has(item.fullId)) {
+        result.push(item);
       }
+    }
 
-      // Then alphabetical by model id.
-      return a.modelId.localeCompare(b.modelId);
-    });
+    return result;
   }
 
   private updateList(): void {
@@ -433,12 +440,20 @@ export class HideProviderSelectorComponent implements Component {
             !(r.provider === item.provider && r.model === item.modelId),
         );
       }
+
+      // Newly visible model goes to the end of the visible order (pi core).
+      if (!this.visibleIds.includes(item.fullId)) {
+        this.visibleIds.push(item.fullId);
+      }
     } else {
       // Add a rule for this specific model
       this.hiddenRules = deduplicateRules([
         ...this.hiddenRules,
         { provider: item.provider, model: item.modelId },
       ]);
+
+      // Remove from the visible order.
+      this.visibleIds = this.visibleIds.filter((id) => id !== item.fullId);
     }
     this.hasChanges = true;
     this.refresh();
@@ -456,12 +471,25 @@ export class HideProviderSelectorComponent implements Component {
       this.hiddenRules = this.hiddenRules.filter(
         (r) => r.provider !== provider,
       );
+
+      // Append newly visible provider models to the end of the visible order
+      // in original registry order (pi core).
+      const providerIds = providerItems.map((i) => i.fullId);
+      this.visibleIds = [
+        ...this.visibleIds,
+        ...providerIds.filter((id) => !this.visibleIds.includes(id)),
+      ];
     } else {
       // Hide all — add a single provider-level rule
       this.hiddenRules = deduplicateRules([
         ...this.hiddenRules,
         { provider },
       ]);
+
+      // Remove provider models from the visible order.
+      this.visibleIds = this.visibleIds.filter(
+        (id) => !providerItems.some((i) => i.fullId === id),
+      );
     }
     this.hasChanges = true;
     this.refresh();
@@ -496,6 +524,10 @@ export class HideProviderSelectorComponent implements Component {
         }
       }
     }
+
+    // Remove hidden models from the visible order.
+    const hiddenFullIds = new Set(items.map((i) => i.fullId));
+    this.visibleIds = this.visibleIds.filter((id) => !hiddenFullIds.has(id));
   }
 
   /** Remove hide rules for the given items. */
@@ -548,6 +580,13 @@ export class HideProviderSelectorComponent implements Component {
         }
       }
     }
+
+    // Append newly visible models to the end of the visible order (pi core).
+    for (const item of items) {
+      if (!this.visibleIds.includes(item.fullId)) {
+        this.visibleIds.push(item.fullId);
+      }
+    }
   }
 
   /** Close and pass results to `done`. */