@fiale-plus/pi-rogue-advisor 0.1.3 → 0.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fiale-plus/pi-rogue-advisor",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "PiRogue advisor extension for Pi — multi-model support, SOTA model suggestion, cache-aware session advisory.",
   "type": "module",
   "license": "MIT",

package/src/completions.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, it } from "vitest";
+import { advisorArgumentCompletions, piRogueArgumentCompletions } from "./completions.js";
+
+describe("advisor completions", () => {
+  it("offers top-level advisor continuations", () => {
+    const values = advisorArgumentCompletions("")?.map((i) => i.value);
+    expect(values).toEqual(expect.arrayContaining(["status", "config", "checkins", "review"]));
+  });
+
+  it("offers nested review choices", () => {
+    const values = advisorArgumentCompletions("review ")?.map((i) => i.value);
+    expect(values).toEqual(["light", "strict", "off"]);
+  });
+
+  it("offers check-in choices", () => {
+    const values = advisorArgumentCompletions("checkins ")?.map((i) => i.value);
+    expect(values).toEqual(expect.arrayContaining(["on", "off", "30", "60"]));
+  });
+});
+
+describe("pi-rogue cockpit completions", () => {
+  it("offers umbrella sections", () => {
+    const values = piRogueArgumentCompletions("")?.map((i) => i.value);
+    expect(values).toEqual(expect.arrayContaining(["status", "advisor", "orchestration", "help"]));
+  });
+
+  it("fans out to orchestration shortcuts", () => {
+    const values = piRogueArgumentCompletions("orchestration ")?.map((i) => i.value);
+    expect(values).toEqual(expect.arrayContaining(["goal", "loop", "autoresearch", "autoresearch-lab"]));
+  });
+});

package/src/completions.ts

@@ -0,0 +1,83 @@
+type CompletionItem = { value: string; label: string; description?: string };
+
+function item(value: string, description?: string): CompletionItem {
+  return { value, label: value, ...(description ? { description } : {}) };
+}
+
+function complete(values: Array<[string, string?]>, prefix: string): CompletionItem[] | null {
+  const q = prefix.trimStart().toLowerCase();
+  const items = values.map(([value, description]) => item(value, description));
+  const filtered = q
+    ? items.filter((i) => i.value.startsWith(q))
+    : items;
+  return filtered.length > 0 ? filtered : null;
+}
+
+function completionsForPrefix(prefix: string, topLevel: Array<[string, string?]>, nested: Record<string, Array<[string, string?]>>): CompletionItem[] | null {
+  const q = prefix.trimStart().toLowerCase();
+  if (!q) return complete(topLevel, q);
+
+  const [head, ...rest] = q.split(/\s+/);
+  if (!head) return complete(topLevel, q);
+
+  if (rest.length === 0) {
+    const top = complete(topLevel, head);
+    if (top) return top;
+  }
+
+  const next = nested[head];
+  if (next) {
+    return complete(next, rest.join(" "));
+  }
+
+  return complete(topLevel, q);
+}
+
+const advisorTopLevel: Array<[string, string?]> = [
+  ["status", "show status and configuration"],
+  ["config", "show full config"],
+  ["on", "enable auto mode"],
+  ["off", "disable advisor"],
+  ["mode", "set auto/manual/off"],
+  ["review", "set light/strict/off"],
+  ["checkins", "configure mid-hour check-ins"],
+  ["checkin", "alias for checkins"],
+  ["model", "set or inspect model override"],
+];
+
+const advisorNested: Record<string, Array<[string, string?]>> = {
+  mode: [["auto"], ["manual"], ["off"]],
+  review: [["light"], ["strict"], ["off"]],
+  checkins: [["on"], ["off"], ["10"], ["15"], ["30"], ["60"]],
+  checkin: [["on"], ["off"], ["10"], ["15"], ["30"], ["60"]],
+  model: [["auto"], ["openai-codex/gpt-5.5"], ["anthropic/claude-opus-4-6"]],
+};
+
+const piRogueTopLevel: Array<[string, string?]> = [
+  ["status", "show cockpit"],
+  ["advisor", "advisor status and check-ins"],
+  ["orchestration", "goal/loop/autoresearch shortcuts"],
+  ["checkins", "advisor check-ins"],
+  ["help", "show cockpit help"],
+];
+
+const piRogueNested: Record<string, Array<[string, string?]>> = {
+  advisor: advisorTopLevel,
+  orchestration: [
+    ["goal", "goal commands"],
+    ["loop", "loop commands"],
+    ["autoresearch", "solo research flow"],
+    ["autoresearch-lab", "parallel research flow"],
+    ["status", "show all surfaces"],
+  ],
+  checkins: advisorNested.checkins,
+  help: [["advisor"], ["orchestration"], ["checkins"], ["status"]],
+};
+
+export function advisorArgumentCompletions(prefix: string): CompletionItem[] | null {
+  return completionsForPrefix(prefix, advisorTopLevel, advisorNested);
+}
+
+export function piRogueArgumentCompletions(prefix: string): CompletionItem[] | null {
+  return completionsForPrefix(prefix, piRogueTopLevel, piRogueNested);
+}

package/src/extension.ts

@@ -5,6 +5,7 @@ import { Box, Text } from "@earendil-works/pi-tui";
 import { completeSimple, type ThinkingLevel } from "@earendil-works/pi-ai";
 import { Type } from "typebox";
 import { featureFile, readText, truncate, writeText } from "./internal.js";
+import { advisorArgumentCompletions, piRogueArgumentCompletions } from "./completions.js";
 import {
   appendRouteLog,
   binaryGatePredict,
@@ -666,10 +667,48 @@ export function registerAdvisor(pi: ExtensionAPI): void {
   // ── /pi-rogue cockpit ──────────────────────────────────────────────────
   pi.registerCommand("pi-rogue", {
     description: "Show PiRogue cockpit: advisor, check-ins, and orchestration command pointers",
-    handler: async (_args, ctx) => {
+    getArgumentCompletions: (prefix: string) => piRogueArgumentCompletions(prefix),
+    handler: async (args, ctx) => {
       const cfg = loadConfig();
       const state = loadState();
+      const arg = String(args ?? "").trim().toLowerCase();
       setPiRogueStatus(ctx, cfg, state);
+
+      if (!arg || arg === "status" || arg === "help") {
+        ctx.ui.notify(piRogueCockpitText(cfg, state, readText(CURRENT_PATH).trim()), "info");
+        return;
+      }
+
+      if (arg.startsWith("advisor")) {
+        ctx.ui.notify([
+          "Advisor surface:",
+          "  /advisor status",
+          "  /advisor config",
+          "  /advisor checkins on|off|<minutes>",
+          "  /advisor <question>",
+        ].join("\n"), "info");
+        return;
+      }
+
+      if (arg.startsWith("orchestration")) {
+        ctx.ui.notify([
+          "Orchestration surface:",
+          "  /goal show|clear|list|set <text>",
+          "  /loop status|off|clear|stop|<interval> <instruction>",
+          "  /autoresearch status|clear|<instruction>",
+          "  /autoresearch-lab status|clear|<instruction>",
+        ].join("\n"), "info");
+        return;
+      }
+
+      if (arg.startsWith("checkins")) {
+        ctx.ui.notify([
+          `Advisor check-ins: ${cfg.checkins === "off" ? "off" : `${cfg.checkinIntervalMinutes}m`}`,
+          "Use /advisor checkins on|off|<minutes> to change it.",
+        ].join("\n"), "info");
+        return;
+      }
+
       ctx.ui.notify(piRogueCockpitText(cfg, state, readText(CURRENT_PATH).trim()), "info");
     },
   });
@@ -677,6 +716,7 @@ export function registerAdvisor(pi: ExtensionAPI): void {
   // ── /advisor command ───────────────────────────────────────────────────
   pi.registerCommand("advisor", {
     description: "Senior engineering advisor. Usage: /advisor [on|off|status|config|question]",
+    getArgumentCompletions: (prefix: string) => advisorArgumentCompletions(prefix),
     handler: async (args, ctx) => {
       const a = String(args ?? "").trim().toLowerCase();
       const [cmd, ...rest] = a.split(/\s+/);