pi-advisor-flow 0.2.0 → 0.2.1

package/extensions/index.ts

@@ -1,6 +1,11 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { registerCommands } from "../src/commands.js";
-import { registerAdvisorTool } from "../src/tools.js";
+import {
+  consultAdvisor as consultAdvisorImplementation,
+  parseAutomaticDecision as parseAutomaticDecisionImplementation,
+  registerAdvisorTool,
+  runAdvisorGate as runAdvisorGateImplementation,
+} from "../src/tools.js";
 
 export type { AdvisorConfig, GateFailureMode } from "../src/config.js";
 export type {
@@ -12,11 +17,15 @@ export type {
   GateDecision,
   GateTrigger,
 } from "../src/tools.js";
-export {
-  consultAdvisor,
-  parseAutomaticDecision,
-  runAdvisorGate,
-} from "../src/tools.js";
+export const consultAdvisor = (
+  ...args: Parameters<typeof consultAdvisorImplementation>
+) => consultAdvisorImplementation(...args);
+export const parseAutomaticDecision = (
+  ...args: Parameters<typeof parseAutomaticDecisionImplementation>
+) => parseAutomaticDecisionImplementation(...args);
+export const runAdvisorGate = (
+  ...args: Parameters<typeof runAdvisorGateImplementation>
+) => runAdvisorGateImplementation(...args);
 
 export default function (pi: ExtensionAPI) {
   registerAdvisorTool(pi);

package/package.json

@@ -1,14 +1,16 @@
 {
   "devDependencies": {
+    "@biomejs/biome": "2.5.3",
     "@earendil-works/pi-ai": "^0.80.7",
     "@earendil-works/pi-coding-agent": "^0.80.7",
     "@earendil-works/pi-tui": "^0.80.7",
     "@types/node": "^20.11.0",
     "bun-types": "^1.0.0",
+    "husky": "^9.1.7",
+    "lint-staged": "^17.1.0",
     "typebox": "^1.1.38",
     "typescript": "^5.3.3",
-    "ultracite": "7.9.4",
-    "@biomejs/biome": "2.5.3"
+    "ultracite": "7.9.4"
   },
   "name": "pi-advisor-flow",
   "peerDependencies": {
@@ -21,10 +23,16 @@
     "test": "bun test",
     "typecheck": "tsc --noEmit",
     "format": "bunx ultracite fix --linter-enabled=false",
-    "package:check": "npm pack --dry-run --json >/dev/null"
+    "lint": "bunx ultracite check",
+    "lint:fix": "bunx ultracite fix",
+    "package:check": "npm pack --dry-run --json >/dev/null",
+    "prepare": "husky"
+  },
+  "lint-staged": {
+    "*.{json,jsonc,ts}": "bun run lint:fix --"
   },
   "type": "module",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "license": "MIT",
   "repository": {
     "type": "git",

package/src/commands.ts

@@ -114,6 +114,22 @@ type ManualConsult = (
   question?: string,
   signal?: AbortSignal
 ) => Promise<{ markdown: string; thinkingText: string }>;
+type ThinkingLevel = Parameters<ExtensionAPI["setThinkingLevel"]>[0];
+
+const notify = (
+  ctx: ExtensionContext,
+  message: string,
+  level: "error" | "info" | "warning"
+) => {
+  if (ctx.hasUI) {
+    ctx.ui.notify(message, level);
+  }
+};
+
+const findConfiguredModel = (ctx: ExtensionContext, ref: string) => {
+  const [provider, modelId] = splitRef(ref);
+  return ctx.modelRegistry.find(provider, modelId);
+};
 
 export const registerCommands = (
   pi: ExtensionAPI,
@@ -126,6 +142,104 @@ export const registerCommands = (
       consultAdvisor(ctx, question, signal, undefined, "manual"));
   const manualConsultations = new Set<AbortController>();
 
+  const startManualConsultation = (
+    ctx: ExtensionContext,
+    question: string | undefined,
+    controller: AbortController
+  ) => {
+    herdrAdvisorActivity.start();
+    return requestAdvisor(ctx, question, controller.signal)
+      .then(({ markdown }) => {
+        advisorSessionState.recordInvocation({
+          executionEffect: "continued",
+          kind: "markdown",
+          model: advisorRef,
+          trigger: "manual",
+        });
+        if (controller.signal.aborted) {
+          return;
+        }
+        pi.sendMessage(
+          {
+            content: `Manual Advisor consultation${question ? ` (${question})` : ""}:\n\n${markdown}`,
+            customType: "advisor-manual-result",
+            details: { advisor: advisorRef, question, text: markdown },
+            display: true,
+          },
+          {
+            // Steer lets the current turn finish its active work; the Executor sees
+            // the result before its next model call rather than being interrupted.
+            deliverAs: "steer",
+            triggerTurn: true,
+          }
+        );
+      })
+      .catch((error: unknown) => {
+        if (controller.signal.aborted) {
+          return;
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        advisorSessionState.recordInvocation({
+          executionEffect: "continued",
+          failure: "provider-error",
+          kind: "markdown",
+          model: advisorRef,
+          trigger: "manual",
+        });
+        pi.sendMessage(
+          {
+            content: `Manual Advisor consultation failed: ${message}`,
+            customType: "advisor-manual-result",
+            details: {
+              advisor: advisorRef,
+              text: `**Advisor consultation failed:** ${message}`,
+            },
+            display: true,
+          },
+          { deliverAs: "steer", triggerTurn: true }
+        );
+        notify(ctx, `Advisor consultation failed: ${message}`, "error");
+        notifyHerdrAdvisorFailure("Advisor consultation failed", message);
+      })
+      .finally(() => {
+        manualConsultations.delete(controller);
+        herdrAdvisorActivity.finish();
+      });
+  };
+
+  const activateAdvisor = async (args: string, ctx: ExtensionContext) => {
+    loadConfig(ctx);
+    const argumentError = parseArgs(args);
+    if (argumentError) {
+      notify(ctx, argumentError, "error");
+      return;
+    }
+    const executor = findConfiguredModel(ctx, executorRef);
+    if (!executor) {
+      notify(ctx, `Executor model not found: ${executorRef}`, "error");
+      return;
+    }
+    if (!findConfiguredModel(ctx, advisorRef)) {
+      notify(ctx, `Advisor model not found: ${advisorRef}`, "error");
+      return;
+    }
+    if (!(await pi.setModel(executor))) {
+      notify(ctx, `No API key for Executor ${executorRef}`, "error");
+      return;
+    }
+    if (executorEffortRef) {
+      pi.setThinkingLevel(executorEffortRef as ThinkingLevel);
+    }
+    if (!flowEnabled()) {
+      pi.setActiveTools([...pi.getActiveTools(), "ask_advisor"]);
+    }
+    notify(
+      ctx,
+      `Advisor flow ready — Executor: ${executorRef} (thinking: ${executorEffortRef || "default"}) · Advisor: ${advisorRef} (thinking: ${advisorEffortRef || "default"})`,
+      "info"
+    );
+  };
+
   pi.registerEntryRenderer?.(
     "advisor-manual-call",
     (entry, _options, theme) => {
@@ -175,15 +289,13 @@ export const registerCommands = (
   pi.registerCommand("advisor-manual", {
     description:
       "Consult the Advisor in parallel; accepts an optional focused question and fans its response out to the Executor",
-    handler: async (args, ctx) => {
+    handler: (args, ctx) => {
       loadConfig(ctx);
       if (!advisorSessionState.canConsult(advisorMaxCallsPerSessionRef)) {
         const message = "Advisor call budget exhausted for this session.";
-        if (ctx.hasUI) {
-          ctx.ui.notify(message, "warning");
-        }
+        notify(ctx, message, "warning");
         notifyHerdrAdvisorFailure("Advisor budget exhausted", message);
-        return;
+        return Promise.resolve();
       }
       advisorSessionState.consumeCall();
       const question = resolveAdvisorRequest(args);
@@ -196,109 +308,22 @@ export const registerCommands = (
       const controller = new AbortController();
       manualConsultations.add(controller);
       pi.appendEntry?.("advisor-manual-call", { question });
-
-      herdrAdvisorActivity.start();
-      void requestAdvisor(ctx, question, controller.signal)
-        .then(({ markdown }) => {
-          advisorSessionState.recordInvocation({
-            executionEffect: "continued",
-            kind: "markdown",
-            model: advisorRef,
-            trigger: "manual",
-          });
-          const advice = markdown;
-          if (controller.signal.aborted) {
-            return;
-          }
-          pi.sendMessage(
-            {
-              content: `Manual Advisor consultation${question ? ` (${question})` : ""}:\n\n${advice}`,
-              customType: "advisor-manual-result",
-              details: { advisor: advisorRef, question, text: advice },
-              display: true,
-            },
-            {
-              // Steer lets the current turn finish its active work; the Executor sees
-              // the result before its next model call rather than being interrupted.
-              deliverAs: "steer",
-              triggerTurn: true,
-            }
-          );
-        })
-        .catch((error: unknown) => {
-          if (controller.signal.aborted) {
-            return;
-          }
-          const message =
-            error instanceof Error ? error.message : String(error);
-          advisorSessionState.recordInvocation({
-            executionEffect: "continued",
-            failure: "provider-error",
-            kind: "markdown",
-            model: advisorRef,
-            trigger: "manual",
-          });
-          if (ctx.hasUI) {
-            ctx.ui.notify(`Advisor consultation failed: ${message}`, "error");
-          }
-          notifyHerdrAdvisorFailure("Advisor consultation failed", message);
-        })
-        .finally(() => {
-          manualConsultations.delete(controller);
-          herdrAdvisorActivity.finish();
-        });
+      startManualConsultation(ctx, question, controller);
+      return Promise.resolve();
     },
   });
 
   pi.registerCommand("advisor", {
     description:
       "Enable the Executor/Advisor flow and switch to the configured Executor model; accepts contextMaxChars=N",
-    handler: async (args, ctx) => {
-      loadConfig(ctx);
-      const argumentError = parseArgs(args);
-      if (argumentError) {
-        if (ctx.hasUI) {
-          ctx.ui.notify(argumentError, "error");
-        }
-        return;
-      }
-      const [provider, modelId] = splitRef(executorRef);
-      const executor = ctx.modelRegistry.find(provider, modelId);
-      if (!executor) {
-        return ctx.hasUI
-          ? ctx.ui.notify(`Executor model not found: ${executorRef}`, "error")
-          : undefined;
-      }
-      const [ap, am] = splitRef(advisorRef);
-      if (!ctx.modelRegistry.find(ap, am)) {
-        return ctx.hasUI
-          ? ctx.ui.notify(`Advisor model not found: ${advisorRef}`, "error")
-          : undefined;
-      }
-      if (!(await pi.setModel(executor))) {
-        return ctx.hasUI
-          ? ctx.ui.notify(`No API key for Executor ${executorRef}`, "error")
-          : undefined;
-      }
-      if (executorEffortRef) {
-        pi.setThinkingLevel(executorEffortRef as any);
-      }
-      if (!flowEnabled()) {
-        pi.setActiveTools([...pi.getActiveTools(), "ask_advisor"]);
-      }
-      if (ctx.hasUI) {
-        ctx.ui.notify(
-          `Advisor flow ready — Executor: ${executorRef} (thinking: ${executorEffortRef || "default"}) · Advisor: ${advisorRef} (thinking: ${advisorEffortRef || "default"})`,
-          "info"
-        );
-      }
-    },
+    handler: (args, ctx) => activateAdvisor(args, ctx),
   });
 
   pi.registerCommand("advisor-models", {
     description:
       "Select and persist the Executor and Advisor models with reasoning levels",
     handler: async (_args, ctx) => {
+      loadConfig(ctx);
       if (!ctx.hasUI) {
         return;
       }
@@ -442,7 +467,7 @@ export const registerCommands = (
 
   pi.registerCommand("advisor-off", {
     description: "Disable on-demand Advisor calls; keep the current model",
-    handler: async (_args, ctx) => {
+    handler: (_args, ctx) => {
       pi.setActiveTools(
         pi.getActiveTools().filter((name) => name !== "ask_advisor")
       );
@@ -452,6 +477,7 @@ export const registerCommands = (
           "info"
         );
       }
+      return Promise.resolve();
     },
   });
 };