@alexeiled/pi-fusion 0.1.0

package/src/commands.ts

@@ -0,0 +1,273 @@
+import type {
+  ExtensionAPI,
+  ExtensionCommandContext,
+} from "@earendil-works/pi-coding-agent";
+import { readFile } from "node:fs/promises";
+import {
+  getProjectFusionConfigPath,
+  writeProjectFusionConfigTemplate,
+} from "./config.js";
+import { FusionArgsError, FusionConfigError } from "./errors.js";
+
+const FUSION_USAGE =
+  "Usage: /fusion <prompt> | /fusion --profile <name> <prompt> | /fusion status | /fusion stop | /fusion init.";
+const FUSION_HELP = [
+  "Fusion commands",
+  "/fusion <prompt>",
+  "/fusion --profile <name> <prompt>",
+  "/fusion status",
+  "/fusion stop",
+  "/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>;
+  showStatus(ctx: ExtensionCommandContext): Promise<unknown>;
+  cancelActiveRun(ctx: ExtensionCommandContext): Promise<unknown>;
+}
+
+export function registerFusionCommands(
+  pi: Pick<ExtensionAPI, "registerCommand">,
+  handler: FusionRuntimeCommandHandler,
+): void {
+  pi.registerCommand("fusion", {
+    description: "Run a fusion review, or use status/stop/init",
+    handler: async (args: string, ctx: ExtensionCommandContext) => {
+      if (args.trim() === "") {
+        ctx.ui.notify(FUSION_HELP, "info");
+        return;
+      }
+
+      const inlineCommand = parseFusionInlineCommand(args);
+      if (inlineCommand === "init") {
+        await runFusionInit(ctx);
+        return;
+      }
+      if (inlineCommand === "status") {
+        await handler.showStatus(ctx);
+        return;
+      }
+      if (inlineCommand === "stop") {
+        await handler.cancelActiveRun(ctx);
+        return;
+      }
+      await handler.startRun(args, ctx);
+    },
+  });
+}
+
+export async function runFusionInit(
+  ctx: FusionInitContext,
+  deps: FusionInitDeps = {},
+): Promise<FusionInitResult> {
+  if (!ctx.isProjectTrusted()) {
+    ctx.ui.notify(
+      "Project is not trusted. /fusion init did not write .pi/fusion.json.",
+      "error",
+    );
+    return { status: "skipped", reason: "untrusted" };
+  }
+
+  const configPath = getProjectFusionConfigPath(ctx.cwd);
+  if (await fileExists(configPath, deps.readTextFile ?? readUtf8File)) {
+    if (!ctx.hasUI) {
+      ctx.ui.notify(
+        `${configPath} already exists. Run /fusion init in UI mode to confirm overwrite.`,
+        "warning",
+      );
+      return { status: "skipped", reason: "exists", path: configPath };
+    }
+
+    const overwrite = await ctx.ui.confirm(
+      "Overwrite fusion config?",
+      `${configPath} already exists. Overwrite it?`,
+    );
+    if (!overwrite) {
+      ctx.ui.notify("Kept existing .pi/fusion.json.", "info");
+      return { status: "skipped", reason: "cancelled", path: configPath };
+    }
+  }
+
+  const writtenPath = await writeProjectFusionConfigTemplate(ctx.cwd, deps);
+  ctx.ui.notify(`Wrote ${writtenPath}.`, "info");
+  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;
+}
+
+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;
+}
+
+async function fileExists(
+  path: string,
+  readTextFile: (path: string) => Promise<string>,
+): Promise<boolean> {
+  try {
+    await readTextFile(path);
+    return true;
+  } catch (error: unknown) {
+    if (isNodeErrorCode(error, "ENOENT")) return false;
+    const message = error instanceof Error ? error.message : String(error);
+    throw new FusionConfigError(
+      `Could not check fusion config at ${path}: ${message}`,
+    );
+  }
+}
+
+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

@@ -0,0 +1,256 @@
+import { CONFIG_DIR_NAME, getAgentDir } from "@earendil-works/pi-coding-agent";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { FusionConfigError } from "./errors.js";
+import {
+  THINKING_LEVELS,
+  type FusionConfig,
+  type FusionContextMode,
+  type FusionProfile,
+  type JudgeConfig,
+  type PanelMemberConfig,
+  type ThinkingLevel,
+} from "./types.js";
+
+export const FUSION_CONFIG_FILE = "fusion.json";
+export const DEFAULT_PROFILE_NAME = "quality";
+export const PANEL_AGENT = "pi-fusion.fusion-panelist";
+export const JUDGE_AGENT = "pi-fusion.fusion-judge";
+
+export interface FusionConfigLoadContext {
+  cwd: string;
+  isProjectTrusted(): boolean;
+}
+
+interface FileReadDeps {
+  readTextFile?: (path: string) => Promise<string>;
+  agentDir?: string;
+}
+
+interface FileWriteDeps {
+  writeTextFile?: (path: string, content: string) => Promise<void>;
+  ensureDir?: (path: string) => Promise<void>;
+}
+
+export interface ResolvedFusionProfile {
+  name: string;
+  profile: FusionProfile;
+}
+
+export function createDefaultFusionConfig(): FusionConfig {
+  return {
+    defaultProfile: DEFAULT_PROFILE_NAME,
+    profiles: {
+      [DEFAULT_PROFILE_NAME]: {
+        panel: [
+          {
+            id: "architect",
+            label: "Architect",
+            agent: PANEL_AGENT,
+            thinking: "high",
+            role: "architecture, tradeoffs, and failure modes",
+          },
+          {
+            id: "implementer",
+            label: "Implementer",
+            agent: PANEL_AGENT,
+            thinking: "medium",
+            role: "implementation details, API contracts, and edge cases",
+          },
+          {
+            id: "tester",
+            label: "Tester",
+            agent: PANEL_AGENT,
+            thinking: "medium",
+            role: "test strategy, regressions, and verification",
+          },
+        ],
+        judge: {
+          agent: JUDGE_AGENT,
+          thinking: "high",
+        },
+        concurrency: 3,
+        timeoutMs: 300_000,
+        context: "fresh",
+      },
+    },
+  };
+}
+
+export function getProjectFusionConfigPath(cwd: string): string {
+  return join(cwd, CONFIG_DIR_NAME, FUSION_CONFIG_FILE);
+}
+
+export function getGlobalFusionConfigPath(agentDir = getAgentDir()): string {
+  return join(agentDir, FUSION_CONFIG_FILE);
+}
+
+export function getFusionConfigTemplate(): string {
+  return `${JSON.stringify(createDefaultFusionConfig(), null, 2)}\n`;
+}
+
+export async function loadFusionConfig(
+  ctx: FusionConfigLoadContext,
+  deps: FileReadDeps = {},
+): Promise<FusionConfig> {
+  const readTextFile = deps.readTextFile ?? readUtf8File;
+
+  if (ctx.isProjectTrusted()) {
+    const projectPath = getProjectFusionConfigPath(ctx.cwd);
+    const projectConfig = await readOptionalConfig(projectPath, readTextFile);
+    if (projectConfig) return projectConfig;
+  }
+
+  const globalPath = getGlobalFusionConfigPath(deps.agentDir);
+  const globalConfig = await readOptionalConfig(globalPath, readTextFile);
+  return globalConfig ?? createDefaultFusionConfig();
+}
+
+export function resolveProfile(
+  config: FusionConfig,
+  requested?: string,
+): ResolvedFusionProfile {
+  const name = requested?.trim() || config.defaultProfile;
+  const profile = config.profiles[name];
+  if (!profile) {
+    const knownProfiles =
+      Object.keys(config.profiles).sort().join(", ") || "none";
+    throw new FusionConfigError(
+      `Unknown fusion profile "${name}". Known profiles: ${knownProfiles}.`,
+    );
+  }
+  if (profile.panel.length === 0) {
+    throw new FusionConfigError(
+      `Fusion profile "${name}" must define at least one panel member.`,
+    );
+  }
+  return { name, profile };
+}
+
+export async function writeProjectFusionConfigTemplate(
+  cwd: string,
+  deps: FileWriteDeps = {},
+): Promise<string> {
+  const configPath = getProjectFusionConfigPath(cwd);
+  const ensureDir = deps.ensureDir ?? mkdirRecursive;
+  const writeTextFile = deps.writeTextFile ?? writeUtf8File;
+  await ensureDir(dirname(configPath));
+  await writeTextFile(configPath, getFusionConfigTemplate());
+  return configPath;
+}
+
+async function readOptionalConfig(
+  path: string,
+  readTextFile: (path: string) => Promise<string>,
+): Promise<FusionConfig | undefined> {
+  let raw: string;
+  try {
+    raw = await readTextFile(path);
+  } catch (error: unknown) {
+    if (isNodeErrorCode(error, "ENOENT")) return undefined;
+    const message = error instanceof Error ? error.message : String(error);
+    throw new FusionConfigError(
+      `Could not read fusion config at ${path}: ${message}`,
+    );
+  }
+  return parseFusionConfig(raw, path);
+}
+
+export function parseFusionConfig(raw: string, source: string): FusionConfig {
+  let value: unknown;
+  try {
+    value = JSON.parse(raw);
+  } catch (error: unknown) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new FusionConfigError(
+      `Invalid JSON in fusion config at ${source}: ${message}`,
+    );
+  }
+  if (!isFusionConfig(value)) {
+    throw new FusionConfigError(
+      `Invalid fusion config at ${source}. Expected defaultProfile and profiles.`,
+    );
+  }
+  return value;
+}
+
+export function isFusionConfig(value: unknown): value is FusionConfig {
+  if (!isRecord(value)) return false;
+  if (!isNonEmptyString(value.defaultProfile)) return false;
+  if (!isRecord(value.profiles)) return false;
+  return Object.values(value.profiles).every(isFusionProfile);
+}
+
+function isFusionProfile(value: unknown): value is FusionProfile {
+  if (!isRecord(value)) return false;
+  if (!Array.isArray(value.panel) || !value.panel.every(isPanelMemberConfig))
+    return false;
+  if (!isJudgeConfig(value.judge)) return false;
+  if (value.concurrency !== undefined && !isPositiveInteger(value.concurrency))
+    return false;
+  if (value.timeoutMs !== undefined && !isPositiveInteger(value.timeoutMs))
+    return false;
+  if (value.context !== undefined && !isFusionContextMode(value.context))
+    return false;
+  return true;
+}
+
+function isPanelMemberConfig(value: unknown): value is PanelMemberConfig {
+  if (!isRecord(value)) return false;
+  if (!isNonEmptyString(value.id)) return false;
+  if (!isNonEmptyString(value.label)) return false;
+  if (!isNonEmptyString(value.agent)) return false;
+  if (value.model !== undefined && !isNonEmptyString(value.model)) return false;
+  if (value.thinking !== undefined && !isThinkingLevel(value.thinking))
+    return false;
+  if (value.role !== undefined && typeof value.role !== "string") return false;
+  return true;
+}
+
+function isJudgeConfig(value: unknown): value is JudgeConfig {
+  if (!isRecord(value)) return false;
+  if (!isNonEmptyString(value.agent)) return false;
+  if (value.model !== undefined && !isNonEmptyString(value.model)) return false;
+  if (value.thinking !== undefined && !isThinkingLevel(value.thinking))
+    return false;
+  return true;
+}
+
+function isThinkingLevel(value: unknown): value is ThinkingLevel {
+  return (
+    typeof value === "string" &&
+    (THINKING_LEVELS as readonly string[]).includes(value)
+  );
+}
+
+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");
+}
+
+async function writeUtf8File(path: string, content: string): Promise<void> {
+  await writeFile(path, content, "utf8");
+}
+
+async function mkdirRecursive(path: string): Promise<void> {
+  await mkdir(path, { recursive: true });
+}

package/src/errors.ts

@@ -0,0 +1,13 @@
+export class FusionConfigError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "FusionConfigError";
+  }
+}
+
+export class FusionArgsError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "FusionArgsError";
+  }
+}

package/src/index.ts

@@ -0,0 +1,34 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { registerFusionCommands } from "./commands.js";
+import {
+  FusionOrchestrator,
+  SUBAGENT_ASYNC_COMPLETE_EVENT,
+} from "./orchestrator.js";
+import { FusionRunStore } from "./run-store.js";
+import { SubagentsRpcClient } from "./subagents-rpc.js";
+
+export default function fusionExtension(pi: ExtensionAPI): void {
+  const orchestrator = new FusionOrchestrator({
+    rpc: new SubagentsRpcClient({ events: pi.events }),
+    runStore: new FusionRunStore({ persistence: pi }),
+    sendMessage: (message) => pi.sendMessage(message),
+  });
+
+  registerFusionCommands(pi, orchestrator);
+
+  const unsubscribeComplete = pi.events.on(
+    SUBAGENT_ASYNC_COMPLETE_EVENT,
+    (payload) => {
+      void orchestrator.handleSubagentComplete(payload);
+    },
+  );
+
+  pi.on("session_start", async (_event, ctx) => {
+    await orchestrator.restore(ctx);
+  });
+
+  pi.on("session_shutdown", () => {
+    orchestrator.clearUi();
+    if (typeof unsubscribeComplete === "function") unsubscribeComplete();
+  });
+}