@alexeiled/pi-fusion 0.1.0

package/src/result-extract.ts

@@ -0,0 +1,311 @@
+import type { FailedPanelSummary, PanelOutput } from "./run-builder.js";
+import type { PanelMemberConfig } from "./types.js";
+
+export type ResultExtractErrorCode =
+  "missing-results" | "unknown-result-shape" | "missing-result-field";
+
+export interface ResultExtractError {
+  code: ResultExtractErrorCode;
+  message: string;
+  path: string;
+}
+
+export interface ExtractPanelResultsOptions {
+  panel?: readonly PanelMemberConfig[];
+}
+
+export type ExtractPanelResultsResult =
+  | {
+      ok: true;
+      outputs: PanelOutput[];
+      failures: FailedPanelSummary[];
+      runId?: string;
+    }
+  | { ok: false; error: ResultExtractError };
+
+interface ResultsContainer {
+  payload: Record<string, unknown>;
+  results: readonly unknown[];
+  path: string;
+}
+
+type ChildStatus = "success" | "failed";
+
+export function extractPanelResults(
+  payload: unknown,
+  options: ExtractPanelResultsOptions = {},
+): ExtractPanelResultsResult {
+  const container = findResultsContainer(payload);
+  if (!container.ok) return container;
+
+  const outputs: PanelOutput[] = [];
+  const failures: FailedPanelSummary[] = [];
+  for (const [index, rawResult] of container.results.entries()) {
+    const child = normalizeChildResult(rawResult, index, options);
+    if (!child.ok) return child;
+    if (child.status === "success") outputs.push(child.output);
+    else failures.push(child.failure);
+  }
+
+  const runId = firstString(container.payload.runId, container.payload.id);
+  return {
+    ok: true,
+    outputs,
+    failures,
+    ...(runId ? { runId } : {}),
+  };
+}
+
+function findResultsContainer(
+  payload: unknown,
+):
+  | (ExtractPanelResultsResult & { ok: false })
+  | ({ ok: true } & ResultsContainer) {
+  if (!isRecord(payload)) {
+    return error(
+      "unknown-result-shape",
+      "Subagents result payload must be an object.",
+      "$",
+    );
+  }
+
+  if (Array.isArray(payload.results)) {
+    return { ok: true, payload, results: payload.results, path: "$.results" };
+  }
+
+  if ("results" in payload) {
+    return error(
+      "unknown-result-shape",
+      "Subagents result payload results field must be an array.",
+      "$.results",
+    );
+  }
+
+  if (isRecord(payload.details)) {
+    if (Array.isArray(payload.details.results)) {
+      return {
+        ok: true,
+        payload: { ...payload, ...payload.details },
+        results: payload.details.results,
+        path: "$.details.results",
+      };
+    }
+    if ("results" in payload.details) {
+      return error(
+        "unknown-result-shape",
+        "Subagents result details.results field must be an array.",
+        "$.details.results",
+      );
+    }
+  }
+
+  if (isRecord(payload.data)) return findResultsContainer(payload.data);
+
+  return error(
+    "missing-results",
+    "Subagents result payload did not include a results array.",
+    "$",
+  );
+}
+
+function normalizeChildResult(
+  rawResult: unknown,
+  index: number,
+  options: ExtractPanelResultsOptions,
+):
+  | { ok: true; status: "success"; output: PanelOutput }
+  | { ok: true; status: "failed"; failure: FailedPanelSummary }
+  | { ok: false; error: ResultExtractError } {
+  const path = `$.results[${index}]`;
+  if (!isRecord(rawResult)) {
+    return error(
+      "unknown-result-shape",
+      "Subagents child result must be an object.",
+      path,
+    );
+  }
+
+  const member = options.panel?.[index];
+  const agent = firstString(rawResult.agent, member?.agent);
+  if (!agent) {
+    return error(
+      "missing-result-field",
+      "Subagents child result did not include an agent.",
+      `${path}.agent`,
+    );
+  }
+
+  const artifactPath = extractArtifactPath(rawResult);
+  const sessionPath = firstString(rawResult.sessionPath, rawResult.sessionFile);
+  const status = classifyChildStatus(rawResult);
+
+  if (status === "success") {
+    const output =
+      firstNonBlankString(
+        rawResult.output,
+        rawResult.finalOutput,
+        rawResult.summary,
+        rawResult.text,
+      ) ?? artifactOutput(artifactPath);
+    if (!output) {
+      return error(
+        "missing-result-field",
+        "Successful subagents child result did not include output or an artifact path.",
+        path,
+      );
+    }
+    return {
+      ok: true,
+      status,
+      output: buildPanelOutput({
+        index,
+        member,
+        agent,
+        output,
+        artifactPath,
+        sessionPath,
+      }),
+    };
+  }
+
+  return {
+    ok: true,
+    status,
+    failure: buildFailedPanelSummary({
+      index,
+      member,
+      agent,
+      summary: failureSummary(rawResult, artifactPath),
+      artifactPath,
+      sessionPath,
+    }),
+  };
+}
+
+function classifyChildStatus(result: Record<string, unknown>): ChildStatus {
+  if (result.success === true) return "success";
+  if (result.success === false) return "failed";
+  if (result.timedOut === true || result.interrupted === true) return "failed";
+  if (firstNonBlankString(result.error)) return "failed";
+
+  const status = firstString(result.status, result.state);
+  if (status) {
+    if (status === "completed" || status === "complete") return "success";
+    if (status === "failed" || status === "paused" || status === "detached") {
+      return "failed";
+    }
+  }
+
+  if (typeof result.exitCode === "number") {
+    return result.exitCode === 0 ? "success" : "failed";
+  }
+
+  return firstNonBlankString(result.output, result.finalOutput, result.summary)
+    ? "success"
+    : "failed";
+}
+
+function failureSummary(
+  result: Record<string, unknown>,
+  artifactPath: string | undefined,
+): string {
+  const errorText = firstNonBlankString(result.error);
+  const outputText = firstNonBlankString(
+    result.summary,
+    result.output,
+    result.finalOutput,
+    result.text,
+  );
+  if (errorText && outputText && errorText !== outputText) {
+    return `${errorText}\n\n${outputText}`;
+  }
+  if (errorText) return errorText;
+  if (outputText) return outputText;
+  return artifactOutput(artifactPath) ?? "Panelist failed without a summary.";
+}
+
+function buildPanelOutput(input: {
+  index: number;
+  member: PanelMemberConfig | undefined;
+  agent: string;
+  output: string;
+  artifactPath: string | undefined;
+  sessionPath: string | undefined;
+}): PanelOutput {
+  return {
+    index: input.index,
+    agent: input.agent,
+    output: input.output,
+    ...(input.member?.id ? { id: input.member.id } : {}),
+    ...(input.member?.label ? { label: input.member.label } : {}),
+    ...(input.artifactPath ? { artifactPath: input.artifactPath } : {}),
+    ...(input.sessionPath ? { sessionPath: input.sessionPath } : {}),
+  };
+}
+
+function buildFailedPanelSummary(input: {
+  index: number;
+  member: PanelMemberConfig | undefined;
+  agent: string;
+  summary: string;
+  artifactPath: string | undefined;
+  sessionPath: string | undefined;
+}): FailedPanelSummary {
+  return {
+    index: input.index,
+    agent: input.agent,
+    summary: input.summary,
+    ...(input.member?.id ? { id: input.member.id } : {}),
+    ...(input.member?.label ? { label: input.member.label } : {}),
+    ...(input.artifactPath ? { artifactPath: input.artifactPath } : {}),
+    ...(input.sessionPath ? { sessionPath: input.sessionPath } : {}),
+  };
+}
+
+function extractArtifactPath(
+  result: Record<string, unknown>,
+): string | undefined {
+  const direct = firstString(result.artifactPath, result.savedOutputPath);
+  if (direct) return direct;
+  if (isRecord(result.artifactPaths)) {
+    return firstString(result.artifactPaths.outputPath);
+  }
+  if (isRecord(result.outputReference)) {
+    return firstString(result.outputReference.path);
+  }
+  return undefined;
+}
+
+function artifactOutput(path: string | undefined): string | undefined {
+  return path ? `Output artifact: ${path}` : undefined;
+}
+
+function firstString(...values: readonly unknown[]): string | undefined {
+  for (const value of values) {
+    if (typeof value === "string") return value;
+  }
+  return undefined;
+}
+
+function firstNonBlankString(
+  ...values: readonly unknown[]
+): string | undefined {
+  for (const value of values) {
+    if (typeof value !== "string") continue;
+    const trimmed = value.trim();
+    if (trimmed) return trimmed;
+  }
+  return undefined;
+}
+
+function error(
+  code: ResultExtractErrorCode,
+  message: string,
+  path: string,
+): { ok: false; error: ResultExtractError } {
+  return { ok: false, error: { code, message, path } };
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/src/run-builder.ts

@@ -0,0 +1,273 @@
+import {
+  THINKING_LEVELS,
+  type FusionProfile,
+  type PanelMemberConfig,
+  type ThinkingLevel,
+} from "./types.js";
+
+export interface PanelSubagentTaskParams {
+  agent: string;
+  task: string;
+  output: true;
+  outputMode: "inline";
+  progress: true;
+  skill: false;
+  acceptance: "none";
+  model?: string;
+}
+
+export interface PanelSpawnParams {
+  tasks: PanelSubagentTaskParams[];
+  async: true;
+  clarify: false;
+  concurrency: number;
+  context: "fresh" | "fork";
+  output: true;
+  outputMode: "inline";
+  timeoutMs?: number;
+}
+
+export interface JudgeSpawnParams {
+  agent: string;
+  task: string;
+  async: true;
+  clarify: false;
+  context: "fresh" | "fork";
+  output: true;
+  outputMode: "inline";
+  skill: false;
+  acceptance: "none";
+  model?: string;
+  timeoutMs?: number;
+}
+
+export interface PanelOutput {
+  index: number;
+  agent: string;
+  output: string;
+  id?: string;
+  label?: string;
+  artifactPath?: string;
+  sessionPath?: string;
+}
+
+export interface FailedPanelSummary {
+  index: number;
+  agent: string;
+  summary: string;
+  id?: string;
+  label?: string;
+  artifactPath?: string;
+  sessionPath?: string;
+}
+
+export interface BuildJudgeSpawnParamsInput {
+  profile: FusionProfile;
+  prompt: string;
+  panelOutputs: readonly PanelOutput[];
+  failedPanelists: readonly FailedPanelSummary[];
+}
+
+const PANEL_OUTPUT_CONTRACT = [
+  "## Summary",
+  "## Recommendation",
+  "## Evidence",
+  "## Risks",
+  "## Confidence",
+  "## Open Questions",
+] as const;
+
+const JUDGE_OUTPUT_CONTRACT = [
+  "# Fusion Report",
+  "## Summary",
+  "## Agent Status",
+  "## Consensus",
+  "## Disagreements",
+  "## Unique Insights",
+  "## Blind Spots",
+  "## Recommendation",
+  "## Risks",
+  "## Next Step",
+] as const;
+
+export function appendThinkingSuffix(
+  model: string | undefined,
+  thinking: ThinkingLevel | undefined,
+): string | undefined {
+  if (!model || !thinking) return model;
+  if (hasThinkingSuffix(model)) return model;
+  return `${model}:${thinking}`;
+}
+
+export function buildPanelSpawnParams(
+  profile: FusionProfile,
+  prompt: string,
+): PanelSpawnParams {
+  return {
+    tasks: profile.panel.map((member) => buildPanelTaskParams(member, prompt)),
+    async: true,
+    clarify: false,
+    concurrency: profile.concurrency ?? profile.panel.length,
+    context: profile.context ?? "fresh",
+    output: true,
+    outputMode: "inline",
+    ...(profile.timeoutMs !== undefined
+      ? { timeoutMs: profile.timeoutMs }
+      : {}),
+  };
+}
+
+export function buildJudgeSpawnParams(
+  input: BuildJudgeSpawnParamsInput,
+): JudgeSpawnParams {
+  const model = appendThinkingSuffix(
+    input.profile.judge.model,
+    input.profile.judge.thinking,
+  );
+  return {
+    agent: input.profile.judge.agent,
+    task: buildJudgeTask(input),
+    async: true,
+    clarify: false,
+    context: input.profile.context ?? "fresh",
+    output: true,
+    outputMode: "inline",
+    skill: false,
+    acceptance: "none",
+    ...(model ? { model } : {}),
+    ...(input.profile.timeoutMs !== undefined
+      ? { timeoutMs: input.profile.timeoutMs }
+      : {}),
+  };
+}
+
+function buildPanelTaskParams(
+  member: PanelMemberConfig,
+  prompt: string,
+): PanelSubagentTaskParams {
+  const model = appendThinkingSuffix(member.model, member.thinking);
+  return {
+    agent: member.agent,
+    task: buildPanelTask(member, prompt),
+    output: true,
+    outputMode: "inline",
+    progress: true,
+    skill: false,
+    acceptance: "none",
+    ...(model ? { model } : {}),
+  };
+}
+
+function buildPanelTask(member: PanelMemberConfig, prompt: string): string {
+  const role = member.role?.trim() || "independent analysis and critique";
+  return [
+    `Panel member: ${member.label} (${member.id})`,
+    `Role: ${role}`,
+    "",
+    "Original task:",
+    prompt.trim(),
+    "",
+    "Instructions:",
+    "- Work independently from the other panelists.",
+    "- Do not edit files, stage changes, commit changes, or run destructive commands.",
+    "- Do not ask other agents.",
+    "- Do not run subagents.",
+    "- Use read-only local inspection only when code evidence is needed.",
+    "- Be concise and cite evidence when you inspect files.",
+    "",
+    "Output contract:",
+    ...PANEL_OUTPUT_CONTRACT,
+  ].join("\n");
+}
+
+function buildJudgeTask(input: BuildJudgeSpawnParamsInput): string {
+  const sortedOutputs = [...input.panelOutputs].sort(comparePanelItems);
+  const sortedFailures = [...input.failedPanelists].sort(comparePanelItems);
+  return [
+    "You are the fusion judge.",
+    "Do not edit files. Do not ask other agents. Do not run subagents.",
+    "Synthesize the panel results. Preserve disagreement instead of forcing consensus.",
+    "",
+    "Original task:",
+    input.prompt.trim(),
+    "",
+    "Panel status:",
+    ...formatPanelStatus(sortedOutputs, sortedFailures),
+    "",
+    "Successful panel outputs:",
+    ...formatPanelOutputs(sortedOutputs),
+    "",
+    "Failed panelists:",
+    ...formatFailedPanelists(sortedFailures),
+    "",
+    "Output contract:",
+    ...JUDGE_OUTPUT_CONTRACT,
+  ].join("\n");
+}
+
+function formatPanelStatus(
+  outputs: readonly PanelOutput[],
+  failures: readonly FailedPanelSummary[],
+): string[] {
+  const lines = [
+    `- Successful panelists: ${outputs.length}`,
+    `- Failed panelists: ${failures.length}`,
+  ];
+  for (const output of outputs) {
+    lines.push(`- ${formatPanelName(output)}: succeeded`);
+  }
+  for (const failure of failures) {
+    lines.push(
+      `- ${formatPanelName(failure)}: failed - ${firstLine(failure.summary)}`,
+    );
+  }
+  return lines;
+}
+
+function formatPanelOutputs(outputs: readonly PanelOutput[]): string[] {
+  if (outputs.length === 0) return ["(none)"];
+  return outputs.flatMap((output) => [
+    `## ${formatPanelName(output)}`,
+    `Agent: ${output.agent}`,
+    ...(output.artifactPath ? [`Artifact: ${output.artifactPath}`] : []),
+    ...(output.sessionPath ? [`Session: ${output.sessionPath}`] : []),
+    "",
+    output.output,
+    "",
+  ]);
+}
+
+function formatFailedPanelists(
+  failures: readonly FailedPanelSummary[],
+): string[] {
+  if (failures.length === 0) return ["(none)"];
+  return failures.flatMap((failure) => [
+    `- ${formatPanelName(failure)} (${failure.agent}): ${failure.summary}`,
+    ...(failure.artifactPath ? [`  Artifact: ${failure.artifactPath}`] : []),
+    ...(failure.sessionPath ? [`  Session: ${failure.sessionPath}`] : []),
+  ]);
+}
+
+function formatPanelName(
+  item: Pick<PanelOutput, "index" | "id" | "label">,
+): string {
+  return item.label ?? item.id ?? `Panelist ${item.index + 1}`;
+}
+
+function comparePanelItems(
+  left: Pick<PanelOutput, "index">,
+  right: Pick<PanelOutput, "index">,
+): number {
+  return left.index - right.index;
+}
+
+function firstLine(value: string): string {
+  return value.split(/\r?\n/, 1)[0]?.trim() || "unknown failure";
+}
+
+function hasThinkingSuffix(model: string): boolean {
+  const colonIndex = model.lastIndexOf(":");
+  if (colonIndex === -1) return false;
+  const suffix = model.slice(colonIndex + 1);
+  return (THINKING_LEVELS as readonly string[]).includes(suffix);
+}