pi-model-sort 0.1.0 → 0.1.2

package/README.md

@@ -36,7 +36,8 @@ The extension works automatically — there are no commands to learn.
 
 ```bash
 # Install, then just use pi normally
-/model                    # Most recently used models now appear at the top
+/model                    # Most recently used models appear at the top
+Ctrl+P / Ctrl+Shift+P     # Cycle through models in last-used order
 pi --list-models          # CLI output is also sorted by last usage
 ```
 
@@ -104,19 +105,25 @@ Session starts
       sortModels — sorts "Scope: all" view
       loadModels — sorts "Scope: scoped" scopedModelItems after load
   → Monkey-patches ModelRegistry.prototype.getAvailable/getAll
+  → Monkey-patches AgentSession.prototype._cycleScopedModel
   → Sort order: current model first → most recent → provider/id alphabetical
   → Patches survive modelRegistry.refresh()
 ```
 
-**Four patches, full coverage:**
+**Five patches, full coverage:**
 
 | Patch | What it affects |
 |-------|----------------|
 | `ModelSelectorComponent.prototype.sortModels` | `/model` TUI picker — "Scope: all" view |
 | `ModelSelectorComponent.prototype.loadModels` | `/model` TUI picker — "Scope: scoped" view (configured cycling models) |
+| `AgentSession.prototype._cycleScopedModel` | `Ctrl+P` / `Ctrl+Shift+P` cycling order (non-destructive swap, cycling does not update last-used to avoid feedback loop) |
 | `ModelRegistry.prototype.getAvailable()` | `/scoped-models` config selector, model resolution |
 | `ModelRegistry.prototype.getAll()` | `--list-models` CLI output |
 
+When no scoped models are configured, Ctrl+P falls through to `_cycleAvailableModel` which calls `getAvailable()` — already sorted by the registry patch.
+
+> **Why cycling doesn't update last-used:** Updating timestamps during Ctrl+P cycling creates a feedback loop — each cycle makes the selected model most-recent, re-sorts it to position 0, and `(currentIndex + 1) % len` always lands on the second model. Models would toggle forever between the top 2. Manual model selection (`/model`, session restore) still updates last-used.
+
 The SDK doesn't expose a sort order for model lists. Monkey-patching the component and registry methods is the only way to control ordering without rebuilding the entire picker UI.
 
 The patches survive `modelRegistry.refresh()` because they wrap the original methods. On reload, the extension detects the prototypes are already patched and just updates the last-used data source.

package/model-sort.ts

@@ -1,11 +1,13 @@
 /**
  * pi-model-sort — sort models in pi by last usage (descending).
  *
- * Strategy: monkey-patches ModelSelectorComponent.prototype.sortModels and
- * loadModels so the /model picker sorts by recency instead of alphabetically
- * by provider — including the "Scope: scoped" view for Ctrl+P cycling.
- * Also patches ModelRegistry.getAvailable() and getAll() so --list-models
- * and the scoped-models config selector benefit from the same ordering.
+ * Strategy: monkey-patches three areas:
+ *   ModelSelectorComponent.prototype.sortModels and loadModels — sorts both
+ *   "Scope: all" and "Scope: scoped" views in the /model TUI picker.
+ *   ModelRegistry.prototype.getAvailable/getAll — sorts --list-models CLI
+ *   and the /scoped-models config selector.
+ *   AgentSession.prototype._cycleScopedModel — sorts the Ctrl+P / Ctrl+Shift+P
+ *   cycling order (non-destructively — the configured order is preserved).
  *
  * Usage tracking is automatic — every model selection (manual, Ctrl+P cycle,
  * or session restore) updates the last-used timestamp. Data persists to
@@ -16,7 +18,7 @@
  */
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { ModelRegistry, ModelSelectorComponent } from "@earendil-works/pi-coding-agent";
+import { AgentSession, ModelRegistry, ModelSelectorComponent } from "@earendil-works/pi-coding-agent";
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
@@ -134,6 +136,47 @@ function unpatchLoadModels(): void {
   origLoadModels = null;
 }
 
+// ModelSelectorComponent filterModels patch — re-applies last-used sort after
+// fuzzyFilter re-orders results by match quality. Without this, typing in the
+// /model picker search box discards the last-used order.
+
+let origFilterModels: ((query: string) => void) | null = null;
+
+function patchFilterModels(getLastUsed: () => Record<string, number>): void {
+  if (origFilterModels !== null) return;
+
+  const proto = ModelSelectorComponent.prototype as unknown as Record<string, unknown>;
+  origFilterModels = proto.filterModels as (query: string) => void;
+
+  proto.filterModels = function (this: Record<string, unknown>, query: string) {
+    origFilterModels!.call(this, query);
+
+    const filtered = this.filteredModels as Array<{ provider: string; id: string; model: unknown }> | undefined;
+    if (!filtered || filtered.length <= 1 || !query) return;
+
+    const lastUsed = getLastUsed();
+    this.filteredModels = sortByLastUsed(filtered, lastUsed, buildCurrentModelKey(this));
+
+    // Re-sync selectedIndex — fuzzyFilter may have moved the current model.
+    const currentKey = buildCurrentModelKey(this);
+    if (currentKey) {
+      const newFiltered = this.filteredModels as Array<{ provider: string; id: string }>;
+      const newIndex = newFiltered.findIndex(
+        (item) => buildModelKey(item.provider, item.id) === currentKey,
+      );
+      if (newIndex >= 0) {
+        this.selectedIndex = newIndex;
+      }
+    }
+  };
+}
+
+function unpatchFilterModels(): void {
+  if (origFilterModels === null) return;
+  (ModelSelectorComponent.prototype as unknown as Record<string, unknown>).filterModels = origFilterModels;
+  origFilterModels = null;
+}
+
 // ModelRegistry getAvailable / getAll patch
 
 const REGISTRY_PATCH_KEY = "__model_sort_registry_patched";
@@ -188,6 +231,55 @@ function unpatchRegistry(registry: PatchedRegistry): void {
   delete raw.__model_sort_orig_getAll;
 }
 
+// AgentSession _cycleScopedModel patch — sorts the scoped models list
+// before cycling so Ctrl+P / Ctrl+Shift+P follows last-used order instead
+// of the configured order. Non-destructive: the session's stored order is
+// temporarily swapped and restored after the cycle lookup.
+
+type ScopedModelEntry = { model: { provider: string; id: string }; thinkingLevel?: string };
+
+let origCycleScopedModel: ((direction: string) => Promise<unknown>) | null = null;
+
+function patchCycleScopedModel(getLastUsed: () => Record<string, number>): void {
+  if (origCycleScopedModel !== null) return;
+
+  const proto = AgentSession.prototype as unknown as Record<string, unknown>;
+  origCycleScopedModel = proto._cycleScopedModel as (direction: string) => Promise<unknown>;
+
+  proto._cycleScopedModel = async function (this: Record<string, unknown>, direction: string) {
+    const lastUsed = getLastUsed();
+    const origScoped = this._scopedModels as ScopedModelEntry[] | undefined;
+
+    if (!origScoped || origScoped.length <= 1) {
+      return origCycleScopedModel!.call(this, direction);
+    }
+
+    // Sort by last-used without mutating the session's stored order.
+    const sorted = [...origScoped].sort((a, b) => {
+      const aKey = buildModelKey(a.model.provider, a.model.id);
+      const bKey = buildModelKey(b.model.provider, b.model.id);
+      const aLast = lastUsed[aKey] ?? 0;
+      const bLast = lastUsed[bKey] ?? 0;
+      if (aLast !== bLast) return bLast - aLast;
+      return a.model.provider.localeCompare(b.model.provider) || a.model.id.localeCompare(b.model.id);
+    });
+
+    // Temporarily swap for the cycle lookup, restore afterward.
+    this._scopedModels = sorted;
+    try {
+      return await origCycleScopedModel!.call(this, direction);
+    } finally {
+      this._scopedModels = origScoped;
+    }
+  };
+}
+
+function unpatchCycleScopedModel(): void {
+  if (origCycleScopedModel === null) return;
+  (AgentSession.prototype as unknown as Record<string, unknown>)._cycleScopedModel = origCycleScopedModel;
+  origCycleScopedModel = null;
+}
+
 // Extension
 
 export default function (pi: ExtensionAPI) {
@@ -200,6 +292,8 @@ export default function (pi: ExtensionAPI) {
     patchRegistry(ctx.modelRegistry as unknown as PatchedRegistry, () => lastUsed);
     patchSortModels(() => lastUsed);
     patchLoadModels(() => lastUsed);
+    patchFilterModels(() => lastUsed);
+    patchCycleScopedModel(() => lastUsed);
 
     if (ctx.hasUI) {
       const count = Object.keys(lastUsed).length;
@@ -212,8 +306,13 @@ export default function (pi: ExtensionAPI) {
     }
   });
 
-  // Track every model selection (manual, Ctrl+P cycle, session restore)
+  // Track model selections (manual, session restore).
+  // Skip "cycle" events — updating lastUsed during Ctrl+P cycling creates
+  // a feedback loop: each cycle step makes the selected model most-recent,
+  // re-sorts it to position 0, then (currentIndex + 1) % len always hits
+  // position 1 — toggling forever between the top 2.
   pi.on("model_select", async (event, _ctx) => {
+    if (event.source === "cycle") return;
     const key = buildModelKey(event.model.provider, event.model.id);
     lastUsed[key] = Date.now();
     writeConfig({ lastUsed });
@@ -223,5 +322,7 @@ export default function (pi: ExtensionAPI) {
   pi.on("session_shutdown", () => {
     unpatchSortModels();
     unpatchLoadModels();
+    unpatchFilterModels();
+    unpatchCycleScopedModel();
   });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-model-sort",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Sort models in pi's /model selector by last usage — most recently used models appear first",
   "type": "module",
   "author": "Tom X Nguyen",