@d3ara1n/pi-command-palette 0.4.2 → 0.5.1

package/README.md

@@ -34,19 +34,45 @@ Or add to `~/.pi/agent/settings.json`:
 
 The palette lists:
 
-- **Built-in actions** — Model selector, New session, Compact, Reload, Fork, Tree, Resume
+- **Built-in actions** — curated shortcuts for common operations (detailed below)
 - **Extension commands** — All registered `/command` entries
 - **Skills & Templates** — Skill commands and prompt templates
 
+### Built-in actions
+
+Built-in actions are grouped by how they run:
+
+**Run immediately** — they call pi's API directly, no editor round-trip:
+
+| Action | What it does |
+|--------|--------------|
+| Model: Switch Model | Open a model selector overlay; switch instantly |
+| Session: Compact | Compact the conversation right away |
+| Editor: Copy Content | Copy current editor text to the clipboard |
+| Editor: Clear Content | Clear the editor, saving the current text to the restore buffer |
+| Restore: Previous Editor Text | Bring back text saved before the last command _(appears only when available)_ |
+
+**Fill the editor** — they insert the matching `/command` for you to submit, just like any extension command:
+
+| Action | Inserts |
+|--------|---------|
+| Session: New | `/new` |
+| Session: Reload | `/reload` |
+| Session: Fork | `/fork` |
+| Session: Tree | `/tree` |
+| Session: Resume | `/resume` |
+
+> Pi ships with more built-in slash commands (e.g. `/export`, `/share`, `/name`, `/settings`). This palette only surfaces a curated subset above — for the rest, type them directly into the editor.
+
 ### Editor text preservation
 
-When a command replaces your current editor text, the original content is saved and a **Restore: Previous Editor Text** entry appears at the top of the palette. Select it to get your text back.
+When a command replaces your editor text, or you run **Editor: Clear Content**, the original content is saved and a **Restore: Previous Editor Text** entry appears at the top of the palette. Select it to get your text back.
 
 ### Model selector
 
 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.4.2",
+  "version": "0.5.1",
   "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/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

@@ -10,14 +10,13 @@
  * - Fuzzy search via SelectList
  * - Floating overlay on top of existing content
  * - Saves editor text before overwriting; offers "Restore" in palette
+ * - Clear editor into the restore buffer
  */
 
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import {
+  copyToClipboard,
   DynamicBorder,
-  getAgentDir,
-  resolveModelScopeWithDiagnostics,
-  SettingsManager,
 } from "@earendil-works/pi-coding-agent";
 import {
   Container,
@@ -37,7 +36,9 @@ type CommandAction =
   | { type: "model-select" }
   | { type: "compact" }
   | { type: "reload" }
-  | { type: "restore" };
+  | { type: "restore" }
+  | { type: "copy-editor" }
+  | { type: "clear-editor" };
 
 interface PaletteItem {
   value: string;
@@ -52,6 +53,18 @@ interface PaletteItem {
 /** Editor text saved before the palette overwrites it. */
 let savedEditorText: string | null = null;
 
+/**
+ * Explicit display order for built-in palette entries (lower = higher up).
+ * Unlisted built-ins fall back to alphabetical, after the listed ones;
+ * non-built-in entries always sort after built-ins.
+ */
+const BUILTIN_ORDER: Record<string, number> = {
+  __model_select: 0,
+  __restore: 1,
+  __copy_editor: 2,
+  __clear_editor: 3,
+};
+
 // ── Helpers ────────────────────────────────────────────────────────
 
 function buildPaletteItems(pi: ExtensionAPI, ctx: ExtensionContext): PaletteItem[] {
@@ -127,6 +140,22 @@ function buildPaletteItems(pi: ExtensionAPI, ctx: ExtensionContext): PaletteItem
     action: { type: "editor", text: "/resume" },
   });
 
+  items.push({
+    value: "__copy_editor",
+    label: "Editor: Copy Content",
+    description: "Copy current editor text to clipboard",
+    category: "Built-in",
+    action: { type: "copy-editor" },
+  });
+
+  items.push({
+    value: "__clear_editor",
+    label: "Editor: Clear Content",
+    description: "Clear editor (recover via Restore)",
+    category: "Built-in",
+    action: { type: "clear-editor" },
+  });
+
   // ── Extension commands, skills, templates ────────────────────
   const commands = pi.getCommands();
   for (const cmd of commands) {
@@ -143,10 +172,17 @@ function buildPaletteItems(pi: ExtensionAPI, ctx: ExtensionContext): PaletteItem
     });
   }
 
-  // Sort: built-in first, then alphabetically within category
+  // Sort: built-in actions first, ordered by BUILTIN_ORDER (then alphabetical
+  // for unlisted built-ins); extension commands follow alphabetically.
   items.sort((a, b) => {
-    if (a.category === "Built-in" && b.category !== "Built-in") return -1;
-    if (a.category !== "Built-in" && b.category === "Built-in") return 1;
+    const aBuilt = a.category === "Built-in";
+    const bBuilt = b.category === "Built-in";
+    if (aBuilt !== bBuilt) return aBuilt ? -1 : 1;
+    if (aBuilt) {
+      const ai = BUILTIN_ORDER[a.value] ?? Number.MAX_SAFE_INTEGER;
+      const bi = BUILTIN_ORDER[b.value] ?? Number.MAX_SAFE_INTEGER;
+      if (ai !== bi) return ai - bi;
+    }
     return a.label.localeCompare(b.label);
   });
 
@@ -169,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> {
@@ -211,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) => {
@@ -253,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.
@@ -454,6 +499,29 @@ async function showCommandPalette(pi: ExtensionAPI, ctx: ExtensionContext): Prom
       ctx.ui.setEditorText("/reload");
       break;
     }
+    case "copy-editor": {
+      const text = ctx.ui.getEditorText();
+      if (text && text.trim()) {
+        await copyToClipboard(text);
+        ctx.ui.notify("Copied editor text to clipboard", "info");
+      } else {
+        ctx.ui.notify("Editor is empty", "warning");
+      }
+      break;
+    }
+    case "clear-editor": {
+      // Save current editor text to the restore buffer before clearing, so
+      // the built-in Restore action can bring it back.
+      const currentText = ctx.ui.getEditorText();
+      if (currentText && currentText.trim()) {
+        savedEditorText = currentText;
+        ctx.ui.setEditorText("");
+        ctx.ui.notify("Cleared editor — use Restore to recover", "info");
+      } else {
+        ctx.ui.notify("Editor is empty", "warning");
+      }
+      break;
+    }
   }
 }