@alexeiled/pi-fusion 0.2.1 → 0.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alexeiled/pi-fusion",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "Stronger answers for hard Pi questions via a parallel model panel + judge, built on pi-subagents",
   "type": "module",
   "main": "./src/index.ts",

package/src/commands.ts

@@ -7,10 +7,11 @@ import {
   getProjectFusionConfigPath,
   writeProjectFusionConfigTemplate,
 } from "./config.js";
-import { FusionArgsError, FusionConfigError } from "./errors.js";
+import { FusionConfigError } from "./errors.js";
+import { parseFusionInlineCommand } from "./fusion-args.js";
+import type { ParsedFusionArgs } from "./types.js";
+import { isNodeErrorCode } from "./utils.js";
 
-const FUSION_USAGE =
-  "Usage: /fusion <prompt> | /fusion --profile <name> <prompt> | /fusion status | /fusion stop | /fusion init.";
 const FUSION_HELP = [
   "Fusion commands",
   "/fusion <prompt>",
@@ -20,39 +21,11 @@ const FUSION_HELP = [
   "/fusion init",
 ].join("\n");
 
-export type FusionInlineCommand = "init" | "status" | "stop";
-
-export interface ParsedFusionArgs {
-  prompt: string;
-  profile?: string;
-}
-
-interface FusionInitContext {
-  cwd: string;
-  hasUI: boolean;
-  isProjectTrusted(): boolean;
-  ui: {
-    confirm(title: string, message: string): Promise<boolean>;
-    notify(message: string, type?: "info" | "warning" | "error"): void;
-  };
-}
-
-export interface FusionInitDeps {
-  readTextFile?: (path: string) => Promise<string>;
-  writeTextFile?: (path: string, content: string) => Promise<void>;
-  ensureDir?: (path: string) => Promise<void>;
-}
-
-export type FusionInitResult =
-  | { status: "written"; path: string }
-  | {
-      status: "skipped";
-      reason: "untrusted" | "exists" | "cancelled";
-      path?: string;
-    };
-
 export interface FusionRuntimeCommandHandler {
-  startRun(args: string, ctx: ExtensionCommandContext): Promise<unknown>;
+  startRun(
+    args: string | ParsedFusionArgs,
+    ctx: ExtensionCommandContext,
+  ): Promise<unknown>;
   showStatus(ctx: ExtensionCommandContext): Promise<unknown>;
   cancelActiveRun(ctx: ExtensionCommandContext): Promise<unknown>;
 }
@@ -124,124 +97,29 @@ export async function runFusionInit(
   return { status: "written", path: writtenPath };
 }
 
-export function parseFusionInlineCommand(
-  input: string | readonly string[],
-): FusionInlineCommand | undefined {
-  const tokens =
-    typeof input === "string" ? tokenizeCommandArgs(input) : [...input];
-  if (tokens.length !== 1) return undefined;
-  const command = tokens[0];
-  if (command === "init" || command === "status" || command === "stop") {
-    return command;
-  }
-  return undefined;
+interface FusionInitContext {
+  cwd: string;
+  hasUI: boolean;
+  isProjectTrusted(): boolean;
+  ui: {
+    confirm(title: string, message: string): Promise<boolean>;
+    notify(message: string, type?: "info" | "warning" | "error"): void;
+  };
 }
 
-export function parseFusionArgs(
-  input: string | readonly string[],
-): ParsedFusionArgs {
-  const tokens =
-    typeof input === "string" ? tokenizeCommandArgs(input) : [...input];
-  if (tokens[0] === "/fusion" || tokens[0] === "fusion") tokens.shift();
-
-  let profile: string | undefined;
-  const promptTokens: string[] = [];
-
-  for (let index = 0; index < tokens.length; index++) {
-    const token = tokens[index];
-    if (!token) continue;
-
-    if (
-      promptTokens.length === 0 &&
-      (token === "--profile" || token === "-p")
-    ) {
-      const value = tokens[index + 1];
-      if (!value || value.startsWith("-")) {
-        throw new FusionArgsError(
-          `Missing value for ${token}. ${FUSION_USAGE}`,
-        );
-      }
-      if (profile)
-        throw new FusionArgsError("Profile can only be provided once.");
-      profile = value;
-      index++;
-      continue;
-    }
-
-    if (promptTokens.length === 0 && token.startsWith("--profile=")) {
-      const value = token.slice("--profile=".length).trim();
-      if (!value)
-        throw new FusionArgsError(
-          `Missing value for --profile. ${FUSION_USAGE}`,
-        );
-      if (profile)
-        throw new FusionArgsError("Profile can only be provided once.");
-      profile = value;
-      continue;
-    }
-
-    if (promptTokens.length === 0 && token.startsWith("-")) {
-      throw new FusionArgsError(`Unknown option ${token}. ${FUSION_USAGE}`);
-    }
-
-    promptTokens.push(token, ...tokens.slice(index + 1));
-    break;
-  }
-
-  const prompt = promptTokens.join(" ").trim();
-  if (!prompt) throw new FusionArgsError(FUSION_USAGE);
-  return profile ? { prompt, profile } : { prompt };
+export interface FusionInitDeps {
+  readTextFile?: (path: string) => Promise<string>;
+  writeTextFile?: (path: string, content: string) => Promise<void>;
+  ensureDir?: (path: string) => Promise<void>;
 }
 
-export function tokenizeCommandArgs(input: string): string[] {
-  const tokens: string[] = [];
-  let current = "";
-  let quote: "'" | '"' | undefined;
-  let escaping = false;
-
-  for (const char of input.trim()) {
-    if (escaping) {
-      current += char;
-      escaping = false;
-      continue;
-    }
-
-    if (char === "\\") {
-      escaping = true;
-      continue;
-    }
-
-    if (quote) {
-      if (char === quote) {
-        quote = undefined;
-      } else {
-        current += char;
-      }
-      continue;
-    }
-
-    if (char === "'" || char === '"') {
-      quote = char;
-      continue;
-    }
-
-    if (/\s/.test(char)) {
-      if (current) {
-        tokens.push(current);
-        current = "";
-      }
-      continue;
-    }
-
-    current += char;
-  }
-
-  if (escaping) current += "\\";
-  if (quote)
-    throw new FusionArgsError(`Unclosed ${quote} quote in /fusion arguments.`);
-  if (current) tokens.push(current);
-  return tokens;
-}
+export type FusionInitResult =
+  | { status: "written"; path: string }
+  | {
+      status: "skipped";
+      reason: "untrusted" | "exists" | "cancelled";
+      path?: string;
+    };
 
 async function fileExists(
   path: string,
@@ -259,15 +137,6 @@ async function fileExists(
   }
 }
 
-function isNodeErrorCode(error: unknown, code: string): boolean {
-  return (
-    typeof error === "object" &&
-    error !== null &&
-    "code" in error &&
-    error.code === code
-  );
-}
-
 async function readUtf8File(path: string): Promise<string> {
   return readFile(path, "utf8");
 }

package/src/config.ts

@@ -11,6 +11,12 @@ import {
   type PanelMemberConfig,
   type ThinkingLevel,
 } from "./types.js";
+import {
+  isNodeErrorCode,
+  isNonEmptyString,
+  isPositiveInteger,
+  isRecord,
+} from "./utils.js";
 
 export const FUSION_CONFIG_FILE = "fusion.json";
 export const DEFAULT_PROFILE_NAME = "quality";
@@ -227,22 +233,6 @@ function isFusionContextMode(value: unknown): value is FusionContextMode {
   return value === "fresh" || value === "fork";
 }
 
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-function isNonEmptyString(value: unknown): value is string {
-  return typeof value === "string" && value.trim().length > 0;
-}
-
-function isPositiveInteger(value: unknown): value is number {
-  return typeof value === "number" && Number.isInteger(value) && value > 0;
-}
-
-function isNodeErrorCode(error: unknown, code: string): boolean {
-  return isRecord(error) && error.code === code;
-}
-
 async function readUtf8File(path: string): Promise<string> {
   return readFile(path, "utf8");
 }

package/src/fusion-args.ts

@@ -0,0 +1,126 @@
+import { FusionArgsError } from "./errors.js";
+import type { ParsedFusionArgs } from "./types.js";
+
+const FUSION_USAGE =
+  "Usage: /fusion <prompt> | /fusion --profile <name> <prompt> | /fusion status | /fusion stop | /fusion init.";
+
+export type FusionInlineCommand = "init" | "status" | "stop";
+
+export function parseFusionInlineCommand(
+  input: string | readonly string[],
+): FusionInlineCommand | undefined {
+  const tokens =
+    typeof input === "string" ? tokenizeCommandArgs(input) : [...input];
+  if (tokens.length !== 1) return undefined;
+  const command = tokens[0];
+  if (command === "init" || command === "status" || command === "stop") {
+    return command;
+  }
+  return undefined;
+}
+
+export function parseFusionArgs(
+  input: string | readonly string[],
+): ParsedFusionArgs {
+  const tokens =
+    typeof input === "string" ? tokenizeCommandArgs(input) : [...input];
+  if (tokens[0] === "/fusion" || tokens[0] === "fusion") tokens.shift();
+
+  let profile: string | undefined;
+  const promptTokens: string[] = [];
+
+  for (let index = 0; index < tokens.length; index++) {
+    const token = tokens[index];
+    if (!token) continue;
+
+    if (
+      promptTokens.length === 0 &&
+      (token === "--profile" || token === "-p")
+    ) {
+      const value = tokens[index + 1];
+      if (!value || value.startsWith("-")) {
+        throw new FusionArgsError(
+          `Missing value for ${token}. ${FUSION_USAGE}`,
+        );
+      }
+      if (profile)
+        throw new FusionArgsError("Profile can only be provided once.");
+      profile = value;
+      index++;
+      continue;
+    }
+
+    if (promptTokens.length === 0 && token.startsWith("--profile=")) {
+      const value = token.slice("--profile=".length).trim();
+      if (!value)
+        throw new FusionArgsError(
+          `Missing value for --profile. ${FUSION_USAGE}`,
+        );
+      if (profile)
+        throw new FusionArgsError("Profile can only be provided once.");
+      profile = value;
+      continue;
+    }
+
+    if (promptTokens.length === 0 && token.startsWith("-")) {
+      throw new FusionArgsError(`Unknown option ${token}. ${FUSION_USAGE}`);
+    }
+
+    promptTokens.push(token, ...tokens.slice(index + 1));
+    break;
+  }
+
+  const prompt = promptTokens.join(" ").trim();
+  if (!prompt) throw new FusionArgsError(FUSION_USAGE);
+  return profile ? { prompt, profile } : { prompt };
+}
+
+export function tokenizeCommandArgs(input: string): string[] {
+  const tokens: string[] = [];
+  let current = "";
+  let quote: "'" | '"' | undefined;
+  let escaping = false;
+
+  for (const char of input.trim()) {
+    if (escaping) {
+      current += char;
+      escaping = false;
+      continue;
+    }
+
+    if (char === "\\") {
+      escaping = true;
+      continue;
+    }
+
+    if (quote) {
+      if (char === quote) {
+        quote = undefined;
+      } else {
+        current += char;
+      }
+      continue;
+    }
+
+    if (char === "'" || char === '"') {
+      quote = char;
+      continue;
+    }
+
+    if (/\s/.test(char)) {
+      if (current) {
+        tokens.push(current);
+        current = "";
+      }
+      continue;
+    }
+
+    current += char;
+  }
+
+  if (escaping) current += "\\";
+  if (quote)
+    throw new FusionArgsError(`Unclosed ${quote} quote in /fusion arguments.`);
+  if (current) tokens.push(current);
+  return tokens;
+}

package/src/orchestrator.ts

@@ -4,18 +4,17 @@ import {
   type ResolvedFusionProfile,
 } from "./config.js";
 import { FusionArgsError } from "./errors.js";
+import { parseFusionArgs } from "./fusion-args.js";
+import { decidePanelCompletion } from "./panel-completion.js";
 import {
   renderCancelledReport,
   renderFailureReport,
   renderJudgeReport,
-  renderPanelFailureReport,
-  renderSinglePanelReport,
 } from "./report.js";
 import { extractPanelResults } from "./result-extract.js";
 import {
   appendThinkingSuffix,
   buildFusionChainSpawnParams,
-  buildJudgeSpawnParams,
 } from "./run-builder.js";
 import { FusionRunStore, FusionRunStoreError } from "./run-store.js";
 import {
@@ -35,8 +34,8 @@ import type {
   FusionProfile,
   FusionRun,
   PanelOutput,
+  ParsedFusionArgs,
 } from "./types.js";
-import { parseFusionArgs, type ParsedFusionArgs } from "./commands.js";
 import type { SubagentsTargetParams } from "./subagents-rpc.js";
 
 export const SUBAGENT_ASYNC_COMPLETE_EVENT = "subagent:async-complete";
@@ -124,15 +123,7 @@ export class FusionOrchestrator {
   ): Promise<FusionCommandResult> {
     this.context = ctx;
 
-    let args: ParsedFusionArgs;
-    try {
-      args = typeof input === "string" ? parseFusionArgs(input) : input;
-    } catch (error: unknown) {
-      const message = errorMessage(error);
-      this.notify(ctx, message, "error");
-      return { status: "failed", error: message };
-    }
-
+    const args = typeof input === "string" ? parseFusionArgs(input) : input;
     const existing = this.runStore.getActiveRun();
     if (existing) {
       const message = `Fusion run ${existing.id} is already active.`;
@@ -475,61 +466,13 @@ export class FusionOrchestrator {
       return this.completeActiveRun(report);
     }
 
-    if (extracted.outputs.length === 0) {
-      const report = renderPanelFailureReport({
-        run: updated,
-        failures: extracted.failures,
-        ...withJudgeModel(configuredJudgeModel(profile)),
-      });
-      return this.failActiveRun(
-        "No fusion panelists completed successfully.",
-        report,
-      );
-    }
-
-    if (extracted.outputs.length === 1) {
-      const report = renderSinglePanelReport({
-        run: updated,
-        output: extracted.outputs[0]!,
-        failures: extracted.failures,
-        ...withJudgeModel(configuredJudgeModel(profile)),
-      });
-      return this.completeActiveRun(report);
-    }
-
-    try {
-      const spawnResult = await this.rpc.spawn(
-        buildJudgeSpawnParams({
-          profile,
-          prompt: active.prompt,
-          panelOutputs: extracted.outputs,
-          failedPanelists: extracted.failures,
-        }),
-      );
-      const judgeRunId = extractSubagentRunId(spawnResult);
-      if (!judgeRunId) {
-        throw new FusionArgsError(
-          "pi-subagents spawn did not return a fallback judge run ID.",
-        );
-      }
-      const judgeAsyncDir = extractSubagentAsyncDir(spawnResult);
-      const nextRun = this.runStore.updateRun(active.id, {
-        phase: "judge",
-        judgeRunId,
-        ...(judgeAsyncDir ? { judgeAsyncDir } : {}),
-        panelOutputs: extracted.outputs,
-        panelFailures: extracted.failures,
-      });
-      publishFusionStatus(this.context, nextRun);
-      this.notify(
-        this.context,
-        `Fusion fallback judge started: ${judgeRunId}`,
-        "info",
-      );
-      return { status: "started", run: nextRun };
-    } catch (error: unknown) {
-      return this.failActiveRun(errorMessage(error));
-    }
+    return this.finishPanelCompletion(
+      updated,
+      profile,
+      extracted.outputs,
+      extracted.failures,
+      { fallbackJudge: true },
+    );
   }
 
   private async handleLegacyPanelComplete(
@@ -576,53 +519,57 @@ export class FusionOrchestrator {
       extracted.failures,
     );
 
-    if (extracted.outputs.length === 0) {
-      const report = renderPanelFailureReport({
-        run: updated,
-        failures: extracted.failures,
-        ...withJudgeModel(configuredJudgeModel(profile)),
-      });
-      return this.failActiveRun(
-        "No fusion panelists completed successfully.",
-        report,
-      );
-    }
+    return this.finishPanelCompletion(
+      updated,
+      profile,
+      extracted.outputs,
+      extracted.failures,
+      { fallbackJudge: false },
+    );
+  }
 
-    if (extracted.outputs.length === 1) {
-      const report = renderSinglePanelReport({
-        run: updated,
-        output: extracted.outputs[0]!,
-        failures: extracted.failures,
-        ...withJudgeModel(configuredJudgeModel(profile)),
-      });
-      return this.completeActiveRun(report);
+  private async finishPanelCompletion(
+    run: FusionRun,
+    profile: FusionProfile,
+    panelOutputs: readonly PanelOutput[],
+    panelFailures: readonly FailedPanelSummary[],
+    options: { fallbackJudge: boolean },
+  ): Promise<FusionCommandResult> {
+    const decision = decidePanelCompletion({
+      run,
+      profile,
+      panelOutputs,
+      panelFailures,
+      fallbackJudge: options.fallbackJudge,
+    });
+
+    if (decision.kind === "fail") {
+      return this.failActiveRun(decision.error, decision.report);
+    }
+    if (decision.kind === "complete") {
+      return this.completeActiveRun(decision.report);
     }
 
     try {
-      const spawnResult = await this.rpc.spawn(
-        buildJudgeSpawnParams({
-          profile,
-          prompt: active.prompt,
-          panelOutputs: extracted.outputs,
-          failedPanelists: extracted.failures,
-        }),
-      );
+      const spawnResult = await this.rpc.spawn(decision.params);
       const judgeRunId = extractSubagentRunId(spawnResult);
       if (!judgeRunId) {
-        throw new FusionArgsError(
-          "pi-subagents spawn did not return a judge run ID.",
-        );
+        throw new FusionArgsError(decision.missingRunIdError);
       }
       const judgeAsyncDir = extractSubagentAsyncDir(spawnResult);
-      const nextRun = this.runStore.updateRun(active.id, {
+      const nextRun = this.runStore.updateRun(run.id, {
         phase: "judge",
         judgeRunId,
         ...(judgeAsyncDir ? { judgeAsyncDir } : {}),
-        panelOutputs: extracted.outputs,
-        panelFailures: extracted.failures,
+        panelOutputs: [...panelOutputs],
+        panelFailures: [...panelFailures],
       });
       publishFusionStatus(this.context, nextRun);
-      this.notify(this.context, `Fusion judge started: ${judgeRunId}`, "info");
+      this.notify(
+        this.context,
+        `${decision.notification}: ${judgeRunId}`,
+        "info",
+      );
       return { status: "started", run: nextRun };
     } catch (error: unknown) {
       return this.failActiveRun(errorMessage(error));

package/src/panel-completion.ts

@@ -0,0 +1,85 @@
+import { renderPanelFailureReport, renderSinglePanelReport } from "./report.js";
+import {
+  appendThinkingSuffix,
+  buildJudgeSpawnParams,
+  type JudgeSpawnParams,
+} from "./run-builder.js";
+import type {
+  FailedPanelSummary,
+  FusionProfile,
+  FusionRun,
+  PanelOutput,
+} from "./types.js";
+
+export type PanelCompletionDecision =
+  | { kind: "fail"; error: string; report: string }
+  | { kind: "complete"; report: string }
+  | {
+      kind: "judge";
+      params: JudgeSpawnParams;
+      missingRunIdError: string;
+      notification: string;
+    };
+
+export interface DecidePanelCompletionInput {
+  run: FusionRun;
+  profile: FusionProfile;
+  panelOutputs: readonly PanelOutput[];
+  panelFailures: readonly FailedPanelSummary[];
+  fallbackJudge?: boolean;
+}
+
+export function decidePanelCompletion(
+  input: DecidePanelCompletionInput,
+): PanelCompletionDecision {
+  const judgeModel = configuredJudgeModel(input.profile);
+
+  if (input.panelOutputs.length === 0) {
+    const report = renderPanelFailureReport({
+      run: input.run,
+      failures: input.panelFailures,
+      ...withJudgeModel(judgeModel),
+    });
+    return {
+      kind: "fail",
+      error: "No fusion panelists completed successfully.",
+      report,
+    };
+  }
+
+  if (input.panelOutputs.length === 1) {
+    const report = renderSinglePanelReport({
+      run: input.run,
+      output: input.panelOutputs[0]!,
+      failures: input.panelFailures,
+      ...withJudgeModel(judgeModel),
+    });
+    return { kind: "complete", report };
+  }
+
+  return {
+    kind: "judge",
+    params: buildJudgeSpawnParams({
+      profile: input.profile,
+      prompt: input.run.prompt,
+      panelOutputs: input.panelOutputs,
+      failedPanelists: input.panelFailures,
+    }),
+    missingRunIdError: input.fallbackJudge
+      ? "pi-subagents spawn did not return a fallback judge run ID."
+      : "pi-subagents spawn did not return a judge run ID.",
+    notification: input.fallbackJudge
+      ? "Fusion fallback judge started"
+      : "Fusion judge started",
+  };
+}
+
+function configuredJudgeModel(profile: FusionProfile): string | undefined {
+  return appendThinkingSuffix(profile.judge.model, profile.judge.thinking);
+}
+
+function withJudgeModel(
+  judgeModel: string | undefined,
+): { judgeModel: string } | Record<string, never> {
+  return judgeModel ? { judgeModel } : {};
+}

package/src/run-store.ts

@@ -1,5 +1,6 @@
 import { randomUUID } from "node:crypto";
 import type { FusionPhase, FusionRun } from "./types.js";
+import { isFiniteNumber, isNonEmptyString, isRecord } from "./utils.js";
 
 export const FUSION_RUN_ENTRY_TYPE = "fusion-run";
 
@@ -423,18 +424,6 @@ function isTerminalPhase(value: unknown): value is FusionTerminalPhase {
   return value === "done" || value === "failed" || value === "cancelled";
 }
 
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-function isNonEmptyString(value: unknown): value is string {
-  return typeof value === "string" && value.trim().length > 0;
-}
-
-function isFiniteNumber(value: unknown): value is number {
-  return typeof value === "number" && Number.isFinite(value);
-}
-
 function isPanelOutputArray(
   value: unknown,
 ): value is NonNullable<FusionRun["panelOutputs"]> {

package/src/types.ts

@@ -38,6 +38,11 @@ export interface FusionConfig {
   profiles: Record<string, FusionProfile>;
 }
 
+export interface ParsedFusionArgs {
+  prompt: string;
+  profile?: string;
+}
+
 export interface PanelOutput {
   index: number;
   agent: string;

package/src/utils.ts

@@ -0,0 +1,19 @@
+export function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export function isNonEmptyString(value: unknown): value is string {
+  return typeof value === "string" && value.trim().length > 0;
+}
+
+export function isPositiveInteger(value: unknown): value is number {
+  return typeof value === "number" && Number.isInteger(value) && value > 0;
+}
+
+export function isFiniteNumber(value: unknown): value is number {
+  return typeof value === "number" && Number.isFinite(value);
+}
+
+export function isNodeErrorCode(error: unknown, code: string): boolean {
+  return isRecord(error) && error.code === code;
+}