pi-advisor-flow 0.1.5 → 0.1.6

package/README.md

@@ -45,6 +45,10 @@ Enables the Advisor flow. Switches the primary model to the configured Executor
 - _Example:_ `/advisor executor=anthropic/claude-sonnet-5 advisor=openai/gpt-5.6-sol`
 - _Context size:_ `/advisor contextMaxChars=30000` uses up to 30,000 characters of the reconstructed conversation for each consultation. `0` disables history; `Number.MAX_SAFE_INTEGER` represents the complete branch. Larger values increase request cost and can exceed the Advisor model's context window.
 
+### `/advisor-manual [focus]`
+
+Starts an Advisor consultation in parallel without interrupting the Executor's active tool work. An optional `focus` is passed to the Advisor; when it completes, the advice is delivered to the Executor before its next model call. This works while the Executor is mid-turn.
+
 ### `/advisor-settings`
 
 Opens a single keyboard-navigable settings screen. It includes a Claude Code-style context slider with `0`, `10k`, `25k`, `100k`, `200k`, and `ALL`; `0` sends no reconstructed history and `ALL` sends the complete current branch, subject to the Advisor model's context limit.
@@ -89,6 +93,13 @@ All fields are optional. `executor`, `advisor`, and their effort settings are ma
 
 Disables the Advisor flow, removing the `ask_advisor` tool from the active session.
 
+## Publishing releases
+
+Pushing a version tag (`vX.Y.Z`) runs the release workflow. It verifies that the tag matches `package.json`, type-checks, tests, then publishes:
+
+- `pi-advisor-flow` to [npm](https://www.npmjs.com/package/pi-advisor-flow)
+- `@philipbrembeck/pi-advisor-flow` to GitHub Packages, which makes the package appear in this repository’s **Packages** sidebar
+
 ## Local Development
 
 `pi-advisor` uses Bun for rapid testing and TypeScript. Standard commands apply:
@@ -112,5 +123,5 @@ Verify code-splitting correctness and registration logic:
 
 ```bash
 bun test            # Run unit tests
-npm run typecheck   # Perform strict TS checks
+bun run typecheck   # Perform strict TS checks
 ```

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "pi-advisor-flow",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+ssh://git@github.com/philipbrembeck/pi-advisor.git"
+    "url": "https://github.com/philipbrembeck/pi-advisor.git"
   },
   "homepage": "https://github.com/philipbrembeck/pi-advisor",
   "author": "Philip Brembeck",

package/src/commands.ts

@@ -1,4 +1,5 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { getMarkdownTheme, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Box, Markdown, Text } from "@earendil-works/pi-tui";
 import {
   advisorCollapseResponsesRef, advisorCompletionGateRef, advisorCustomInvocationRef, advisorFailureGateRef, advisorPlanGateRef,
   advisorRef, advisorEffortRef, executorRef, executorEffortRef,
@@ -7,6 +8,7 @@ import {
   contextMaxCharsRef, loadConfig, saveConfig, parseArgs, splitRef,
 } from "./config.js";
 import { AdvisorSettingsSelector, SearchableModelSelector, type AdvisorSettings, type ContextPreset } from "./ui.js";
+import { adviceForDisplay, consult, renderAdvisorCallBox, resolveAdvisorRequest } from "./tools.js";
 
 const EFFORT_LEVELS = ["Default (Model Default)", "off", "minimal", "low", "medium", "high", "xhigh", "max"];
 
@@ -19,8 +21,66 @@ const CONTEXT_PRESETS: ContextPreset[] = [
   { label: "ALL", value: Number.MAX_SAFE_INTEGER, description: "The complete reconstructed conversation branch. Cost and model context limits apply." },
 ];
 
-export const registerCommands = (pi: ExtensionAPI) => {
+export const registerCommands = (pi: ExtensionAPI, dependencies: { consult?: typeof consult } = {}) => {
   const flowEnabled = () => pi.getActiveTools().includes("ask_advisor");
+  const requestAdvisor = dependencies.consult ?? consult;
+  const manualConsultations = new Set<AbortController>();
+
+  pi.registerEntryRenderer?.("advisor-manual-call", (entry, _options, theme) => {
+    const { question } = (entry.data ?? {}) as { question?: string };
+    return renderAdvisorCallBox(question, theme);
+  });
+
+  pi.registerMessageRenderer?.("advisor-manual-result", (message, { expanded }, theme) => {
+    const details = message.details as { advisor?: string; text?: string } | undefined;
+    const box = new Box(1, 1, (text) => theme.bg("customMessageBg", text));
+    box.addChild(new Text(theme.fg("warning", theme.bold("◆ ADVISOR RESPONSE")), 0, 0));
+    if (details?.advisor) box.addChild(new Text(theme.fg("dim", `  ${details.advisor}`), 0, 0));
+    const advice = details?.text ?? (typeof message.content === "string" ? message.content : "(Advisor returned no advice.)");
+    box.addChild(new Markdown(adviceForDisplay(advice, expanded), 0, 0, getMarkdownTheme()));
+    return box;
+  });
+
+  pi.on("session_shutdown", () => {
+    for (const controller of manualConsultations) controller.abort();
+    manualConsultations.clear();
+  });
+
+  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) => {
+      const question = resolveAdvisorRequest(args);
+      // A single visible progress surface avoids competing consultations overwriting
+      // each other's streamed state. A newer manual request replaces the previous one.
+      for (const pending of manualConsultations) pending.abort();
+      manualConsultations.clear();
+      const controller = new AbortController();
+      manualConsultations.add(controller);
+      pi.appendEntry?.("advisor-manual-call", { question });
+
+      void requestAdvisor(ctx, question, controller.signal)
+        .then(({ advice }) => {
+          if (controller.signal.aborted) return;
+          pi.sendMessage({
+            customType: "advisor-manual-result",
+            content: `Manual Advisor consultation${question ? ` (${question})` : ""}:\n\n${advice}`,
+            display: true,
+            details: { advisor: advisorRef, question, text: advice },
+          }, {
+            // 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);
+          if (ctx.hasUI) ctx.ui.notify(`Advisor consultation failed: ${message}`, "error");
+        })
+        .finally(() => manualConsultations.delete(controller));
+    },
+  });
 
   pi.registerCommand("advisor", {
     description: "Enable the Executor/Advisor flow and switch to the configured Executor model; accepts contextMaxChars=N",

package/src/tools.ts

@@ -13,6 +13,14 @@ export const resolveAdvisorRequest = (question?: string) => question?.trim() ||
 export const advisorMessageText = (conversation: string, question?: string) =>
   `${conversation ? `<conversation>\n${conversation}\n</conversation>` : ""}${question ? `\n\nTargeted focus:\n${question}` : ""}`;
 
+export const renderAdvisorCallBox = (question: string | undefined, theme: any) => {
+  const box = new Box(1, 1, (text) => theme.bg("customMessageBg", text));
+  const label = theme.fg("customMessageLabel", theme.bold("[advisor]"));
+  const title = theme.fg("customMessageText", "Executor → Advisor");
+  box.addChild(new Text(question ? `${label} ${title}\n${theme.fg("dim", `  ${question}`)}` : `${label} ${title}`, 0, 0));
+  return box;
+};
+
 const COLLAPSED_ADVICE_LINES = 12;
 
 export const adviceForDisplay = (advice: string, expanded: boolean) => {
@@ -112,15 +120,8 @@ export const registerAdvisorTool = (pi: ExtensionAPI) => {
     ],
     parameters: Type.Object({ question: Type.Optional(Type.String({ description: "The specific question or decision to get advice on. Omit this for normal reviews: the Advisor already has the conversation context." })) }),
     renderShell: "self",
-    renderCall(args, theme, context) {
-      const box = context.lastComponent instanceof Box ? context.lastComponent : new Box(1, 1, (text) => theme.bg("customMessageBg", text));
-      box.setBgFn((text) => theme.bg("customMessageBg", text));
-      box.clear();
-      const request = args.question?.trim();
-      const label = theme.fg("customMessageLabel", theme.bold("[advisor]"));
-      const title = theme.fg("customMessageText", "Executor → Advisor");
-      box.addChild(new Text(request ? `${label} ${title}\n${theme.fg("dim", `  ${request}`)}` : `${label} ${title}`, 0, 0));
-      return box;
+    renderCall(args, theme, _context) {
+      return renderAdvisorCallBox(args.question?.trim(), theme);
     },
     renderResult(result, { isPartial, expanded }, theme, context) {
       const box = context.lastComponent instanceof Box ? context.lastComponent : new Box(1, 1, (text) => theme.bg("customMessageBg", text));