@d3ara1n/pi-command-palette 0.5.0 → 0.5.2

package/README.md

@@ -72,7 +72,7 @@ When a command replaces your editor text, or you run **Editor: Clear Content**,
 
 The "Model: Switch Model" action opens a secondary overlay listing all models with configured API keys. Select one to switch instantly — no need to go through `/model` or `Ctrl+P`.
 
-**Scoped models float to the top**, marked with a ★ (favorite) prefix. "Scoped" here means the same set pi uses for its built-in selector's scoped tab and `Ctrl+P` cycling — the `enabledModels` patterns in your `settings.json` (project `.pi/settings.json` overrides global `~/.pi/agent/settings.json`). Everything else follows alphabetically. If no scope is configured, the list is a plain alphabetical roster — nothing breaks.
+**Scoped models float to the top**, marked with a ★ (favorite) prefix. "Scoped" here means the same set pi uses for its built-in selector's scoped tab and `Ctrl+P` cycling — the `enabledModels` patterns in your `settings.json` (project `.pi/settings.json` overrides global `~/.pi/agent/settings.json`). Everything else follows alphabetically. Filtering preserves that boundary too — scoped matches stay above the rest while you type, rather than collapsing into one score-ordered list. If no scope is configured, the list is a plain alphabetical roster — nothing breaks.
 
 ## Configuration
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@d3ara1n/pi-command-palette",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "type": "module",
   "description": "Global command palette for pi — press Ctrl+Shift+P to search and run commands from anywhere",
   "main": "src/index.ts",

package/src/config.ts

@@ -15,18 +15,12 @@
  */
 
 import * as fs from "node:fs";
-import * as os from "node:os";
 import * as path from "node:path";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
 import type { KeyId } from "@earendil-works/pi-tui";
 
 export const DEFAULT_SHORTCUT = "ctrl+shift+p";
 
-function getAgentDir(): string {
-  const envDir = process.env.PI_AGENT_DIR;
-  if (envDir) return envDir;
-  return path.join(os.homedir(), ".pi", "agent");
-}
-
 function readSettings(filePath: string): Record<string, unknown> {
   try {
     if (!fs.existsSync(filePath)) return {};

package/src/index.test.ts

@@ -1,11 +1,11 @@
 /**
- * Regression tests for model reference parsing.
- * Run: node --test packages/pi-command-palette/src/index.test.ts
+ * Regression tests for model reference parsing and the partitioned fuzzy
+ * filter that keeps scoped models on top while searching.
  */
 
 import assert from "node:assert/strict";
 import { test } from "node:test";
-import { parseModelRef } from "./index.ts";
+import { parseModelRef, partitionedFuzzyFilter } from "./index.ts";
 
 test("parseModelRef splits provider and model at the first slash", () => {
   assert.deepEqual(parseModelRef("anthropic/claude-sonnet"), {
@@ -23,3 +23,56 @@ test("parseModelRef preserves empty provider or model segments", () => {
   assert.deepEqual(parseModelRef("/model"), { provider: "", modelId: "model" });
   assert.deepEqual(parseModelRef("provider/"), { provider: "provider", modelId: "" });
 });
+
+// ── partitionedFuzzyFilter ─────────────────────────────────────────
+
+test("partitionedFuzzyFilter concatenates partitions unchanged for empty query", () => {
+  const primary = [{ label: "A" }, { label: "B" }];
+  const secondary = [{ label: "C" }, { label: "D" }];
+  const getText = (m: { label: string }) => m.label;
+
+  assert.deepEqual(
+    partitionedFuzzyFilter(primary, secondary, "", getText).map((m) => m.label),
+    ["A", "B", "C", "D"],
+  );
+  // Whitespace-only is treated as no query.
+  assert.deepEqual(
+    partitionedFuzzyFilter(primary, secondary, "   ", getText).map((m) => m.label),
+    ["A", "B", "C", "D"],
+  );
+});
+
+test("partitionedFuzzyFilter keeps the primary partition on top while filtering", () => {
+  const primary = [{ label: "alpha-scoped" }, { label: "beta-scoped" }];
+  const secondary = [{ label: "alpha-other" }, { label: "beta-other" }];
+  const getText = (m: { label: string }) => m.label;
+
+  const result = partitionedFuzzyFilter(primary, secondary, "alpha", getText);
+
+  // Both groups match, but the scoped (primary) match must come first — a
+  // single fuzzyFilter pass would have ranked them by score and could flip
+  // the order.
+  assert.equal(result.length, 2);
+  assert.equal(result[0].label, "alpha-scoped");
+  assert.equal(result[1].label, "alpha-other");
+});
+
+test("partitionedFuzzyFilter drops non-matches independently per partition", () => {
+  const primary = [{ label: "keep-scoped" }, { label: "drop-scoped" }];
+  const secondary = [{ label: "keep-other" }, { label: "drop-other" }];
+  const getText = (m: { label: string }) => m.label;
+
+  const result = partitionedFuzzyFilter(primary, secondary, "keep", getText);
+
+  assert.deepEqual(result.map((m) => m.label), ["keep-scoped", "keep-other"]);
+});
+
+test("partitionedFuzzyFilter returns only primary matches when secondary has none", () => {
+  const primary = [{ label: "sonnet" }];
+  const secondary = [{ label: "gpt-4o" }, { label: "gemini" }];
+  const getText = (m: { label: string }) => m.label;
+
+  const result = partitionedFuzzyFilter(primary, secondary, "son", getText);
+
+  assert.deepEqual(result.map((m) => m.label), ["sonnet"]);
+});

package/src/index.ts

@@ -17,9 +17,6 @@ import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-a
 import {
   copyToClipboard,
   DynamicBorder,
-  getAgentDir,
-  resolveModelScopeWithDiagnostics,
-  SettingsManager,
 } from "@earendil-works/pi-coding-agent";
 import {
   Container,
@@ -208,32 +205,31 @@ export function parseModelRef(modelRef: string): { provider: string; modelId: st
   };
 }
 
+// ── Partitioned fuzzy filter ───────────────────────────────────────
+
 /**
- * Resolve the set of "scoped" model full-ids (`provider/id`) — the same models
- * pi surfaces in its built-in selector's "scoped" tab and Ctrl+P cycling.
+ * Filter two partitions independently and concatenate them in a stable order:
+ * every matching item from `primary`, then every matching item from
+ * `secondary`. Each group is ranked by fuzzy score on its own, so `primary`
+ * always stays on top — a single {@link fuzzyFilter} call flattens both groups
+ * into one score-ordered list and erases the boundary between them.
  *
- * Fully official-API driven, no manual settings parsing:
- * - `SettingsManager.getEnabledModels()` reads the `enabledModels` scope
- *   patterns (global + project merge handled by pi).
- * - `resolveModelScopeWithDiagnostics()` expands those patterns (globs, aliases,
- *   thinking-level suffixes) into concrete models — identical to pi's scope tab.
+ * An empty (or whitespace-only) query returns `[...primary, ...secondary]`
+ * unchanged.
  *
- * Any failure degrades to an empty set: the selector still works, just without
- * the scoped grouping.
+ * @internal — exported for testing; the model selector is the only caller.
  */
-async function resolveScopedModelIds(
-  modelRegistry: ExtensionContext["modelRegistry"],
-  cwd: string,
-): Promise<Set<string>> {
-  try {
-    const settings = SettingsManager.create(cwd, getAgentDir());
-    const patterns = settings.getEnabledModels();
-    if (!patterns || patterns.length === 0) return new Set();
-    const { scopedModels } = await resolveModelScopeWithDiagnostics(patterns, modelRegistry);
-    return new Set(scopedModels.map((s) => `${s.model.provider}/${s.model.id}`));
-  } catch {
-    return new Set();
-  }
+export function partitionedFuzzyFilter<T>(
+  primary: T[],
+  secondary: T[],
+  query: string,
+  getText: (item: T) => string,
+): T[] {
+  if (!query.trim()) return [...primary, ...secondary];
+  return [
+    ...fuzzyFilter(primary, query, getText),
+    ...fuzzyFilter(secondary, query, getText),
+  ];
 }
 
 async function showModelSelector(pi: ExtensionAPI, ctx: ExtensionContext): Promise<void> {
@@ -250,25 +246,36 @@ async function showModelSelector(pi: ExtensionAPI, ctx: ExtensionContext): Promi
     return;
   }
 
-  const scopedIds = await resolveScopedModelIds(ctx.modelRegistry, ctx.cwd);
+  const scopedIds = new Set(ctx.scopedModels.map((s) => `${s.model.provider}/${s.model.id}`));
 
-  // Scoped models float to the top with a ★ prefix (favorites); the rest follow
-  // alphabetically. Within the scoped group we also sort alphabetically so the
-  // ordering is stable and predictable regardless of registry order.
-  const decorated = models.map((m) => {
-    const value = `${m.provider}/${m.id}`;
-    return { model: m, value, scoped: scopedIds.has(value) };
-  });
-  decorated.sort((a, b) => {
-    if (a.scoped !== b.scoped) return a.scoped ? -1 : 1;
-    return a.model.name.localeCompare(b.model.name);
-  });
+  // Build each model's SelectItem alongside whether it's scope-pinned, then
+  // sort into two stable groups — scoped first (★), then the rest —
+  // alphabetical within each. We keep the groups as separate arrays so the
+  // search pipeline below can re-apply the same partitioning.
+  const decorated = models
+    .map((m) => {
+      const value = `${m.provider}/${m.id}`;
+      const scoped = scopedIds.has(value);
+      return {
+        scoped,
+        item: {
+          value,
+          label: scoped ? `${STAR}${m.name}` : m.name,
+          description: m.provider,
+        } satisfies SelectItem,
+      };
+    })
+    .sort((a, b) => {
+      if (a.scoped !== b.scoped) return a.scoped ? -1 : 1;
+      return a.item.label.localeCompare(b.item.label);
+    });
 
-  const items: SelectItem[] = decorated.map((d) => ({
-    value: d.value,
-    label: d.scoped ? `${STAR}${d.model.name}` : d.model.name,
-    description: d.model.provider,
-  }));
+  // Scoped models (★) stay above the rest whether browsing or filtering: each
+  // group is filtered and ranked independently, then concatenated, so a search
+  // never merges the two into one score-ordered list.
+  const scopedItems: SelectItem[] = decorated.filter((d) => d.scoped).map((d) => d.item);
+  const otherItems: SelectItem[] = decorated.filter((d) => !d.scoped).map((d) => d.item);
+  const items: SelectItem[] = [...scopedItems, ...otherItems];
 
   const result = await ctx.ui.custom<string | null>(
     (tui, theme, _kb, done) => {
@@ -292,13 +299,12 @@ async function showModelSelector(pi: ExtensionAPI, ctx: ExtensionContext): Promi
       const queryText = new Text(theme.fg("accent", "> "), 1, 0);
 
       function applyQuery() {
-        const filtered = query
-          ? fuzzyFilter(
-              items,
-              query,
-              (item: SelectItem) => `${item.label} ${item.description ?? ""}`,
-            )
-          : items;
+        const filtered = partitionedFuzzyFilter(
+          scopedItems,
+          otherItems,
+          query,
+          (item: SelectItem) => `${item.label} ${item.description ?? ""}`,
+        );
         // FRAGILE: SelectList has no public filter/setItems API, so we poke its
         // private filteredItems directly. If pi-tui renames it, filtering breaks
         // silently with no compile error.