pi-model-sort 0.1.3 → 0.2.0

package/README.md

@@ -23,6 +23,7 @@ Pi's `/model` selector sorts models alphabetically by provider. If you have Anth
 
 - **Automatic tracking** — every `/model` switch, `Ctrl+P` cycle, and session restore is recorded with a Unix timestamp
 - **Sort order** — current model first → most recently used descending → provider/id alphabetical fallback
+- **MRU on startup** — new sessions start on your most recently used model instead of `scopedModels[0]` or the hardcoded provider default order
 - **Persistent** — usage data lives in `~/.pi/agent/extensions/pi-model-sort.json`, survives restarts
 - **No config needed** — install and forget; the extension starts tracking on first use
 - **Zero setup** — with no recorded usage, models fall back to the default alphabetical order
@@ -99,7 +100,7 @@ model_select event fires
   → Writes to pi-model-sort.json
   → Next /model opens with updated sort
 
-Session starts
+Session starts (startup / new)
   → Extension reads pi-model-sort.json
   → Monkey-patches ModelSelectorComponent.prototype:
       sortModels — sorts "Scope: all" view
@@ -108,9 +109,12 @@ Session starts
   → Monkey-patches AgentSession.prototype._cycleScopedModel
   → Sort order: current model first → most recent → provider/id alphabetical
   → Patches survive modelRegistry.refresh()
+  → Overrides initial model to MRU via pi.setModel()
+      if pi core chose a different model (scopedModels[0], defaultModelPerProvider)
+      only on startup and new session starts — not resume, reload, or fork
 ```
 
-**Five patches, full coverage:**
+**Five patches + MRU startup override, full coverage:**
 
 | Patch | What it affects |
 |-------|----------------|
@@ -119,6 +123,7 @@ Session starts
 | `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 |
+| `pi.setModel()` on `session_start` | MRU model selection on startup and `/new` — overrides pi core's default |
 
 When no scoped models are configured, Ctrl+P falls through to `_cycleAvailableModel` which calls `getAvailable()` — already sorted by the registry patch.
 

package/model-sort.ts

@@ -26,6 +26,7 @@ import {
   buildModelKey,
   CONFIG_FILENAME,
   type ModelSortConfig,
+  parseModelKey,
   sortByLastUsed,
 } from "./src/index.js";
 
@@ -149,10 +150,29 @@ function patchFilterModels(getLastUsed: () => Record<string, number>): void {
   origFilterModels = proto.filterModels as (query: string) => void;
 
   proto.filterModels = function (this: Record<string, unknown>, query: string) {
-    origFilterModels!.call(this, query);
+    // Suppress the original's updateList() call — we'll call it once after
+    // re-sorting to avoid a double-render.
+    const origUpdateList = this.updateList as () => void;
+    this.updateList = (() => {}) as unknown as () => void;
+
+    try {
+      origFilterModels!.call(this, query);
+    } finally {
+      this.updateList = origUpdateList as unknown as () => void;
+    }
+
+    // Empty query: nothing to re-sort (activeModels is already sorted by our
+    // sortModels/loadModels patches), just render the original result.
+    if (!query) {
+      origUpdateList.call(this);
+      return;
+    }
 
     const filtered = this.filteredModels as Array<{ provider: string; id: string; model: unknown }> | undefined;
-    if (!filtered || filtered.length <= 1 || !query) return;
+    if (!filtered || filtered.length <= 1) {
+      origUpdateList.call(this);
+      return;
+    }
 
     const lastUsed = getLastUsed();
     this.filteredModels = sortByLastUsed(filtered, lastUsed, buildCurrentModelKey(this));
@@ -169,9 +189,8 @@ function patchFilterModels(getLastUsed: () => Record<string, number>): void {
       }
     }
 
-    // Re-render — the original filterModels already called updateList() before
-    // we re-sorted, so the UI is stale until the next input event.
-    (this.updateList as () => void)();
+    // Render once with the final sorted list.
+    origUpdateList.call(this);
   };
 }
 
@@ -284,12 +303,32 @@ function unpatchCycleScopedModel(): void {
   origCycleScopedModel = null;
 }
 
+// MRU model lookup — finds the most recently used model that exists in the
+// registry and has auth configured. Returns undefined if no usable model found.
+
+function findMruModel(
+  lastUsed: Record<string, number>,
+  registry: { find(provider: string, modelId: string): unknown; hasConfiguredAuth(model: unknown): boolean },
+): unknown | undefined {
+  const sorted = Object.entries(lastUsed).sort(([, a], [, b]) => b - a);
+  for (const [key] of sorted) {
+    const parsed = parseModelKey(key);
+    if (!parsed) continue;
+    const [provider, modelId] = parsed;
+    const model = registry.find(provider, modelId);
+    if (model && registry.hasConfiguredAuth(model)) {
+      return model;
+    }
+  }
+  return undefined;
+}
+
 // Extension
 
 export default function (pi: ExtensionAPI) {
   let lastUsed: Record<string, number> = {};
 
-  pi.on("session_start", async (_event, ctx) => {
+  pi.on("session_start", async (event, ctx) => {
     const config = readConfig();
     lastUsed = config.lastUsed;
 
@@ -299,6 +338,26 @@ export default function (pi: ExtensionAPI) {
     patchFilterModels(() => lastUsed);
     patchCycleScopedModel(() => lastUsed);
 
+    // Override initial model to MRU on new sessions.
+    // Pi core picks the saved default if in scope, otherwise scopedModels[0].
+    // This hijack switches to the most recently used model instead, so your
+    // actual usage history determines the default — not alphabetical scope order.
+    if (
+      (event.reason === "startup" || event.reason === "new") &&
+      Object.keys(lastUsed).length > 0
+    ) {
+      const mruModel = findMruModel(lastUsed, ctx.modelRegistry);
+      const currentModel = ctx.model as { provider: string; id: string } | undefined;
+      if (
+        mruModel &&
+        (!currentModel ||
+          currentModel.provider !== (mruModel as { provider: string }).provider ||
+          currentModel.id !== (mruModel as { id: string }).id)
+      ) {
+        await pi.setModel(mruModel as Parameters<typeof pi.setModel>[0]);
+      }
+    }
+
     if (ctx.hasUI) {
       const count = Object.keys(lastUsed).length;
       ctx.ui.notify(

package/package.json

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

package/src/index.ts

@@ -10,6 +10,13 @@ export interface ModelSortConfig {
   lastUsed: Record<string, number>;
 }
 
+/** Parse a model key into [provider, modelId]. Returns undefined if malformed. */
+export function parseModelKey(key: string): [provider: string, modelId: string] | undefined {
+  const idx = key.indexOf("/");
+  if (idx === -1) return undefined;
+  return [key.substring(0, idx), key.substring(idx + 1)];
+}
+
 /** Build a stable model key from provider and model id. */
 export function buildModelKey(provider: string, modelId: string): string {
   return `${provider}/${modelId}`;