@d3ara1n/pi-command-palette 0.5.2 → 0.5.3

package/README.md

@@ -1,5 +1,7 @@
 # pi-command-palette
 
+[![npm version](https://img.shields.io/npm/v/@d3ara1n/pi-command-palette)](https://www.npmjs.com/package/@d3ara1n/pi-command-palette) [![npm downloads](https://img.shields.io/npm/dm/@d3ara1n/pi-command-palette)](https://www.npmjs.com/package/@d3ara1n/pi-command-palette) [![license](https://img.shields.io/npm/l/@d3ara1n/pi-command-palette)](https://www.npmjs.com/package/@d3ara1n/pi-command-palette)
+
 Global command palette for [Pi Coding Agent](https://pi.dev) — press **Ctrl+Shift+P** to search and run commands from anywhere.
 
 ## Why?
@@ -8,7 +10,7 @@ Pi's slash commands (`/model`, `/compact`, extension commands, etc.) only work w
 
 ## Dependencies
 
-None.
+- [`@d3ara1n/pi-command-palette-core`](../pi-command-palette-core) — shared registry for native palette commands (pure npm library, installed automatically)
 
 ## Installation
 
@@ -35,6 +37,7 @@ Or add to `~/.pi/agent/settings.json`:
 The palette lists:
 
 - **Built-in actions** — curated shortcuts for common operations (detailed below)
+- **Native commands** — entries registered by other extensions that run a callback directly (see below)
 - **Extension commands** — All registered `/command` entries
 - **Skills & Templates** — Skill commands and prompt templates
 
@@ -64,6 +67,23 @@ Built-in actions are grouped by how they run:
 
 > 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.
 
+### Native commands from other extensions
+
+Extensions built on [`@d3ara1n/pi-command-palette-core`](../pi-command-palette-core) can register palette entries backed by a **direct callback** instead of a `/command` editor fill. They appear above the extension-command entries, and selecting one runs the callback in place — your editor text is never touched, saved, or restored:
+
+```ts
+import { paletteCommandRegistry } from "@d3ara1n/pi-command-palette-core";
+
+paletteCommandRegistry.register({
+  id: "my-plugin:do-thing",
+  label: "My Plugin: Do the Thing",
+  description: "Runs immediately, without touching the editor",
+  run: (pi, ctx) => { /* ... */ },
+});
+```
+
+The registry is read every time the palette opens, so commands can be registered and unregistered at any time. Failures inside `run` are caught and surfaced as an error notification. See the [core package](../pi-command-palette-core) for the full API.
+
 ### Editor text preservation
 
 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.

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "@d3ara1n/pi-command-palette",
-  "version": "0.5.2",
+  "version": "0.5.3",
   "type": "module",
   "description": "Global command palette for pi — press Ctrl+Shift+P to search and run commands from anywhere",
   "main": "src/index.ts",
+  "dependencies": {
+    "@d3ara1n/pi-command-palette-core": "*"
+  },
   "keywords": [
     "pi-package",
     "pi",

package/src/index.test.ts

@@ -1,11 +1,19 @@
 /**
- * Regression tests for model reference parsing and the partitioned fuzzy
- * filter that keeps scoped models on top while searching.
+ * Regression tests for model reference parsing, the partitioned fuzzy
+ * filter that keeps scoped models on top while searching, and the palette
+ * item ordering that keeps built-ins → native commands → editor-fill entries.
  */
 
 import assert from "node:assert/strict";
-import { test } from "node:test";
-import { parseModelRef, partitionedFuzzyFilter } from "./index.ts";
+import { after, test } from "node:test";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { paletteCommandRegistry } from "@d3ara1n/pi-command-palette-core";
+import { buildPaletteItems, parseModelRef, partitionedFuzzyFilter } from "./index.ts";
+
+/** Minimal fake of the pi API surface buildPaletteItems uses. */
+function fakePi(commands: { name: string; description?: string }[]): ExtensionAPI {
+  return { getCommands: () => commands } as unknown as ExtensionAPI;
+}
 
 test("parseModelRef splits provider and model at the first slash", () => {
   assert.deepEqual(parseModelRef("anthropic/claude-sonnet"), {
@@ -64,7 +72,10 @@ test("partitionedFuzzyFilter drops non-matches independently per partition", ()
 
   const result = partitionedFuzzyFilter(primary, secondary, "keep", getText);
 
-  assert.deepEqual(result.map((m) => m.label), ["keep-scoped", "keep-other"]);
+  assert.deepEqual(
+    result.map((m) => m.label),
+    ["keep-scoped", "keep-other"],
+  );
 });
 
 test("partitionedFuzzyFilter returns only primary matches when secondary has none", () => {
@@ -74,5 +85,50 @@ test("partitionedFuzzyFilter returns only primary matches when secondary has non
 
   const result = partitionedFuzzyFilter(primary, secondary, "son", getText);
 
-  assert.deepEqual(result.map((m) => m.label), ["sonnet"]);
+  assert.deepEqual(
+    result.map((m) => m.label),
+    ["sonnet"],
+  );
+});
+
+// ── buildPaletteItems ordering ─────────────────────────────────────
+
+const idsBefore = new Set(paletteCommandRegistry.getAll().map((c) => c.id));
+after(() => {
+  for (const c of paletteCommandRegistry.getAll()) {
+    if (!idsBefore.has(c.id)) paletteCommandRegistry.unregister(c.id);
+  }
+});
+
+test("buildPaletteItems orders built-ins above native commands above editor fills", () => {
+  paletteCommandRegistry.register({
+    id: "test:peek",
+    label: "Peek: Ask This Session",
+    run: () => {},
+  });
+
+  const items = buildPaletteItems(
+    fakePi([{ name: "some-command", description: "extension command" }]),
+  );
+
+  const ranks = items.map((item) =>
+    item.category === "Built-in" ? 0 : item.action.type === "native" ? 1 : 2,
+  );
+  // Monotonically non-decreasing → no editor-fill entry sits above a native
+  // entry, and no native entry sits above a built-in.
+  assert.ok(ranks.every((r, i) => i === 0 || ranks[i - 1] <= r));
+
+  const native = items.find((item) => item.value === "native:test:peek");
+  assert.ok(native);
+  assert.equal(native.label, "Peek: Ask This Session");
+  assert.equal(native.action.type, "native");
+});
+
+test("buildPaletteItems picks up native commands registered after load", () => {
+  // The registry is read at palette-open time, so a late registration must
+  // show up on the next build without any re-init.
+  paletteCommandRegistry.register({ id: "test:late", label: "Registered Late", run: () => {} });
+
+  const items = buildPaletteItems(fakePi([]));
+  assert.ok(items.some((item) => item.value === "native:test:late"));
 });

package/src/index.ts

@@ -14,10 +14,8 @@
  */
 
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import {
-  copyToClipboard,
-  DynamicBorder,
-} from "@earendil-works/pi-coding-agent";
+import { copyToClipboard, DynamicBorder } from "@earendil-works/pi-coding-agent";
+import { paletteCommandRegistry } from "@d3ara1n/pi-command-palette-core";
 import {
   Container,
   type SelectItem,
@@ -33,6 +31,7 @@ import { resolveShortcutKey } from "./config.ts";
 
 type CommandAction =
   | { type: "editor"; text: string }
+  | { type: "native"; id: string }
   | { type: "model-select" }
   | { type: "compact" }
   | { type: "reload" }
@@ -67,7 +66,22 @@ const BUILTIN_ORDER: Record<string, number> = {
 
 // ── Helpers ────────────────────────────────────────────────────────
 
-function buildPaletteItems(pi: ExtensionAPI, ctx: ExtensionContext): PaletteItem[] {
+/**
+ * Sort ranks: built-in actions first, then native commands registered by other
+ * extensions (direct callbacks), then everything that fills the editor with a
+ * `/command`. Lower rank = higher up in the palette.
+ */
+function paletteSortRank(item: PaletteItem): number {
+  if (item.category === "Built-in") return 0;
+  if (item.action.type === "native") return 1;
+  return 2;
+}
+
+/**
+ * @internal — exported for testing; builds the palette item list from
+ * built-ins, the native-command registry, and pi's command registry.
+ */
+export function buildPaletteItems(pi: ExtensionAPI): PaletteItem[] {
   const items: PaletteItem[] = [];
 
   // ── Restore option (if previous editor text was saved) ────────
@@ -156,6 +170,20 @@ function buildPaletteItems(pi: ExtensionAPI, ctx: ExtensionContext): PaletteItem
     action: { type: "clear-editor" },
   });
 
+  // ── Native commands from other extensions ────────────────────
+  // Direct callbacks registered via @d3ara1n/pi-command-palette-core —
+  // executed in place, never touching the editor. Read at palette-open time,
+  // so late registrations are visible the next time the palette opens.
+  for (const cmd of paletteCommandRegistry.getAll()) {
+    items.push({
+      value: `native:${cmd.id}`,
+      label: cmd.label,
+      description: cmd.description ?? "",
+      category: "Native",
+      action: { type: "native", id: cmd.id },
+    });
+  }
+
   // ── Extension commands, skills, templates ────────────────────
   const commands = pi.getCommands();
   for (const cmd of commands) {
@@ -172,13 +200,13 @@ function buildPaletteItems(pi: ExtensionAPI, ctx: ExtensionContext): PaletteItem
     });
   }
 
-  // Sort: built-in actions first, ordered by BUILTIN_ORDER (then alphabetical
-  // for unlisted built-ins); extension commands follow alphabetically.
+  // Sort: built-in actions first (ordered by BUILTIN_ORDER, then alphabetical),
+  // then native commands, then editor-fill entries — each group alphabetical.
   items.sort((a, b) => {
-    const aBuilt = a.category === "Built-in";
-    const bBuilt = b.category === "Built-in";
-    if (aBuilt !== bBuilt) return aBuilt ? -1 : 1;
-    if (aBuilt) {
+    const ar = paletteSortRank(a);
+    const br = paletteSortRank(b);
+    if (ar !== br) return ar - br;
+    if (ar === 0) {
       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;
@@ -226,10 +254,7 @@ export function partitionedFuzzyFilter<T>(
   getText: (item: T) => string,
 ): T[] {
   if (!query.trim()) return [...primary, ...secondary];
-  return [
-    ...fuzzyFilter(primary, query, getText),
-    ...fuzzyFilter(secondary, query, getText),
-  ];
+  return [...fuzzyFilter(primary, query, getText), ...fuzzyFilter(secondary, query, getText)];
 }
 
 async function showModelSelector(pi: ExtensionAPI, ctx: ExtensionContext): Promise<void> {
@@ -374,7 +399,7 @@ async function showModelSelector(pi: ExtensionAPI, ctx: ExtensionContext): Promi
 async function showCommandPalette(pi: ExtensionAPI, ctx: ExtensionContext): Promise<void> {
   if (!ctx.hasUI) return;
 
-  const paletteItems = buildPaletteItems(pi, ctx);
+  const paletteItems = buildPaletteItems(pi);
   const selectItems: SelectItem[] = paletteItems.map((item) => ({
     value: item.value,
     label: item.label,
@@ -464,6 +489,20 @@ async function showCommandPalette(pi: ExtensionAPI, ctx: ExtensionContext): Prom
   // Execute the selected action
   const action = result.action;
   switch (action.type) {
+    case "native": {
+      const cmd = paletteCommandRegistry.get(action.id);
+      if (!cmd) {
+        ctx.ui.notify(`Palette command not found: ${action.id}`, "warning");
+        break;
+      }
+      try {
+        await cmd.run(pi, ctx);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        ctx.ui.notify(`Palette command "${cmd.label}" failed: ${message}`, "error");
+      }
+      break;
+    }
     case "restore": {
       if (savedEditorText !== null) {
         ctx.ui.setEditorText(savedEditorText);