@pi-unipi/command-enchantment 2.0.1 → 2.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/command-enchantment",
-  "version": "2.0.1",
+  "version": "2.0.2",
   "description": "Enhanced TUI autocomplete for /unipi:* commands — colored, sorted, and grouped by package",
   "type": "module",
   "license": "MIT",

package/src/__tests__/command-registry.audit.test.ts

@@ -0,0 +1,120 @@
+import { describe, expect, it } from "vitest";
+import { existsSync, globSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+
+function findRepoRoot(start: string): string {
+  let dir = start;
+  while (dir !== dirname(dir)) {
+    if (existsSync(join(dir, "packages", "autocomplete", "src", "constants.ts"))) return dir;
+    dir = dirname(dir);
+  }
+  return start;
+}
+
+const root = findRepoRoot(process.cwd());
+
+function read(path: string): string {
+  return readFileSync(join(root, path), "utf-8");
+}
+
+function collectConstants(): Map<string, string> {
+  const constants = new Map<string, string>([["UNIPI_PREFIX", "unipi:"]]);
+
+  for (const path of globSync("packages/**/*.ts", { cwd: root })) {
+    const text = read(path);
+    for (const obj of text.matchAll(/(?:export\s+)?const\s+(\w+)\s*=\s*\{([\s\S]*?)\}\s*as\s+const/g)) {
+      const [, name, body] = obj;
+      for (const item of body.matchAll(/(\w+):\s*"([^"]+)"/g)) {
+        constants.set(`${name}.${item[1]}`, item[2]);
+      }
+    }
+  }
+
+  return constants;
+}
+
+function evaluateCommandExpression(expr: string, constants: Map<string, string>): string | null {
+  const trimmed = expr.trim();
+
+  if (trimmed.startsWith('"') || trimmed.startsWith("'")) {
+    const quote = trimmed[0];
+    const end = trimmed.indexOf(quote, 1);
+    return end > 0 ? trimmed.slice(1, end) : null;
+  }
+
+  if (trimmed.startsWith("`")) {
+    const end = trimmed.lastIndexOf("`");
+    if (end <= 0) return null;
+    return trimmed.slice(1, end).replace(/\$\{([^}]+)\}/g, (_match, key: string) => {
+      const resolved = constants.get(key.trim());
+      return resolved ?? `\${${key}}`;
+    });
+  }
+
+  return constants.get(trimmed) ?? null;
+}
+
+function registeredCommands(): { commands: Set<string>; nonUnipi: string[]; unresolved: string[] } {
+  const constants = collectConstants();
+  const commands = new Set<string>();
+  const nonUnipi: string[] = [];
+  const unresolved: string[] = [];
+
+  for (const path of globSync("packages/**/*.ts", { cwd: root }).sort()) {
+    const text = read(path);
+    if (!text.includes("registerCommand")) continue;
+
+    for (const match of text.matchAll(/\.registerCommand\(\s*([^,\n]+)/g)) {
+      const expr = match[1].trim();
+
+      // Workflow registers a loop over WORKFLOW_COMMANDS via local `fullCommand`.
+      if (path === "packages/workflow/commands.ts" && expr === "fullCommand") {
+        for (const [key, value] of constants) {
+          if (key.startsWith("WORKFLOW_COMMANDS.")) commands.add(`unipi:${value}`);
+        }
+        continue;
+      }
+
+      const command = evaluateCommandExpression(expr, constants);
+      if (!command || command.includes("${")) {
+        unresolved.push(`${path}: ${expr}`);
+        continue;
+      }
+
+      if (command.startsWith("unipi:")) {
+        commands.add(command);
+      } else {
+        nonUnipi.push(`${command} (${path})`);
+      }
+    }
+  }
+
+  return { commands, nonUnipi, unresolved };
+}
+
+function autocompleteRegistry(): { registry: Set<string>; descriptions: Set<string>; registryPackages: Set<string>; labels: Set<string> } {
+  const text = read("packages/autocomplete/src/constants.ts");
+  const registryBody = text.match(/export const COMMAND_REGISTRY[^=]*= \{([\s\S]*?)\n\};/)?.[1] ?? "";
+  const descriptionsBody = text.match(/export const COMMAND_DESCRIPTIONS[^=]*= \{([\s\S]*?)\n\};/)?.[1] ?? "";
+  const labelsBody = text.match(/export const PACKAGE_LABELS[^=]*= \{([\s\S]*?)\n\};/)?.[1] ?? "";
+
+  const registry = new Set([...registryBody.matchAll(/"(unipi:[^"]+)"\s*:/g)].map((m) => m[1]));
+  const descriptions = new Set([...descriptionsBody.matchAll(/"(unipi:[^"]+)"\s*:/g)].map((m) => m[1]));
+  const registryPackages = new Set([...registryBody.matchAll(/"unipi:[^"]+"\s*:\s*"([^"]+)"/g)].map((m) => m[1]));
+  const labels = new Set([...labelsBody.matchAll(/^\s*"?([a-z][a-z0-9-]*)"?:\s*"/gm)].map((m) => m[1]));
+
+  return { registry, descriptions, registryPackages, labels };
+}
+
+describe("autocomplete command registry audit", () => {
+  it("mirrors every registered /unipi:* command and has no non-unipi package commands", () => {
+    const registered = registeredCommands();
+    const autocomplete = autocompleteRegistry();
+
+    expect(registered.unresolved, "unresolved registerCommand expressions").toEqual([]);
+    expect(registered.nonUnipi, "package commands must use the unipi: prefix").toEqual([]);
+    expect([...registered.commands].sort()).toEqual([...autocomplete.registry].sort());
+    expect([...autocomplete.registry].sort()).toEqual([...autocomplete.descriptions].sort());
+    expect([...autocomplete.registryPackages].filter((pkg) => !autocomplete.labels.has(pkg)).sort()).toEqual([]);
+  });
+});

package/src/constants.ts

@@ -20,6 +20,7 @@ export const PACKAGE_ORDER: string[] = [
   "workflow",
   "ralph",
   "memory",
+  "btw",
   "milestone",
   "mcp",
   "utility",
@@ -41,6 +42,7 @@ export const PACKAGE_COLORS: Record<string, string> = {
   workflow:  `${ESC}[91m`, // Bright Red
   ralph:     `${ESC}[33m`, // Yellow/Orange
   memory:    `${ESC}[93m`, // Bright Yellow
+  btw:       `${ESC}[95m`, // Bright Magenta
   milestone: `${ESC}[32m`, // Green
   mcp:       `${ESC}[32m`, // Green
   utility:   `${ESC}[36m`, // Cyan
@@ -57,7 +59,7 @@ export const PACKAGE_COLORS: Record<string, string> = {
 };
 
 // ─── Command Registry ────────────────────────────────────────────────
-/** Mapping of full command name → package name (80 verified commands) */
+/** Mapping of full command name → package name (88 verified commands) */
 export const COMMAND_REGISTRY: Record<string, string> = {
   // workflow (20 commands)
   "unipi:brainstorm":     "workflow",
@@ -95,6 +97,14 @@ export const COMMAND_REGISTRY: Record<string, string> = {
   "unipi:global-memory-list":   "memory",
   "unipi:memory-settings":   "memory",
 
+  // btw (6 commands)
+  "unipi:btw":           "btw",
+  "unipi:btw-tangent":   "btw",
+  "unipi:btw-new":       "btw",
+  "unipi:btw-clear":     "btw",
+  "unipi:btw-inject":    "btw",
+  "unipi:btw-summarize": "btw",
+
   // mcp (5 commands)
   "unipi:mcp-status":   "mcp",
   "unipi:mcp-sync":     "mcp",
@@ -126,14 +136,16 @@ export const COMMAND_REGISTRY: Record<string, string> = {
   "unipi:web-settings":    "web-api",
   "unipi:web-cache-clear": "web-api",
 
-  // compact (7 commands)
+  // compact (9 commands)
   "unipi:lossless-compact": "compact",
   "unipi:compact":         "compact",
+  "unipi:session-recall":  "compact",
   "unipi:compact-recall":  "compact",
   "unipi:compact-stats":   "compact",
   "unipi:compact-doctor":  "compact",
   "unipi:compact-settings": "compact",
   "unipi:compact-preset":  "compact",
+  "unipi:compact-help":    "compact",
 
   // cocoindex (5 commands)
   "unipi:cocoindex-update":  "cocoindex",
@@ -208,6 +220,13 @@ export const COMMAND_DESCRIPTIONS: Record<string, string> = {
   "unipi:global-memory-list":   "List all project memories",
   "unipi:memory-settings":   "Configure memory settings",
 
+  "unipi:btw":           "Run a parallel side conversation",
+  "unipi:btw-tangent":   "Start a contextless BTW tangent thread",
+  "unipi:btw-new":       "Start a fresh BTW thread with session context",
+  "unipi:btw-clear":     "Dismiss and clear the BTW thread",
+  "unipi:btw-inject":    "Inject the BTW thread into the main agent",
+  "unipi:btw-summarize": "Summarize and inject the BTW thread",
+
   "unipi:mcp-status":   "Show MCP server status",
   "unipi:mcp-sync":     "Sync MCP server connections",
   "unipi:mcp-add":      "Add a new MCP server",
@@ -238,11 +257,13 @@ export const COMMAND_DESCRIPTIONS: Record<string, string> = {
 
   "unipi:lossless-compact": "Immediate zero-LLM compaction",
   "unipi:compact":          "(DEPRECATED) Use /unipi:lossless-compact instead",
-  "unipi:compact-recall":   "Recall a compacted session",
+  "unipi:session-recall":   "Search session history, including compacted-away messages",
+  "unipi:compact-recall":   "(DEPRECATED) Use /unipi:session-recall instead",
   "unipi:compact-stats":    "Show compaction statistics",
   "unipi:compact-doctor":   "Diagnose compaction issues",
   "unipi:compact-settings": "Configure compaction settings",
   "unipi:compact-preset":   "Manage compaction presets",
+  "unipi:compact-help":     "Show compactor command help",
   "unipi:cocoindex-update":  "Run CocoIndex update to index project",
   "unipi:cocoindex-status":  "Show CocoIndex indexing status",
   "unipi:cocoindex-init":    "Initialize CocoIndex pipeline",
@@ -276,6 +297,7 @@ export const PACKAGE_LABELS: Record<string, string> = {
   workflow:  "workflow",
   ralph:     "ralph",
   memory:    "memory",
+  btw:       "btw",
   milestone: "milestone",
   mcp:       "mcp",
   utility:   "utility",
@@ -288,4 +310,5 @@ export const PACKAGE_LABELS: Record<string, string> = {
   footer:    "footer",
   updater:   "updater",
   "input-shortcuts": "input-shortcuts",
+  cocoindex: "cocoindex",
 };