@pi-unipi/fusion 2.17.0

package/src/sidekick-runtime.ts

@@ -0,0 +1,301 @@
+import { spawn as defaultSpawn, type ChildProcess } from "node:child_process";
+import { mkdirSync, unlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { randomUUID } from "node:crypto";
+import { getPiSpawnCommand } from "@pi-unipi/subagents/src/pi-spawn.js";
+import type { EffortLevel, ModelKey } from "./preset.js";
+
+export interface SidekickSpawnConfig {
+  cwd: string;
+  model: ModelKey;
+  thinking: EffortLevel;
+  sessionFile: string;
+  systemPrompt: string;
+  spawn?: typeof defaultSpawn;
+  command?: { command: string; args: string[] };
+}
+
+export interface SidekickUsage {
+  input: number;
+  output: number;
+  cacheRead: number;
+  cacheWrite: number;
+  cost: number;
+}
+
+export interface HandoffProgress {
+  toolCalls: number;
+  recentTools: string[];
+  textTail: string;
+  startedAt: number;
+}
+
+export interface HandoffReport {
+  id: string;
+  status: "completed" | "aborted" | "error" | "interrupted";
+  text: string;
+  usage: SidekickUsage;
+  toolCalls: number;
+  durationMs: number;
+  error?: string;
+}
+
+interface PendingHandoff {
+  id: string;
+  startedAt: number;
+  usage: SidekickUsage;
+  progress: HandoffProgress;
+  resolve: (report: HandoffReport) => void;
+  reject: (error: Error) => void;
+}
+
+const emptyUsage = (): SidekickUsage => ({ input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 });
+
+export class SidekickRuntime {
+  private readonly cfg: SidekickSpawnConfig;
+  private child: ChildProcess | undefined;
+  private promptPath: string | undefined;
+  private pending: PendingHandoff | undefined;
+  private latestHandoff: { id: string; done: Promise<HandoffReport>; report?: HandoffReport } | undefined;
+  private responseText: ((text: string) => void) | undefined;
+  private responseError: ((error: Error) => void) | undefined;
+  private stderrTail = "";
+  private inputBuffer = "";
+  private abortRequested = false;
+  private pendingError: string | undefined;
+  readonly reports = new Map<string, HandoffReport>();
+  readonly usage = emptyUsage();
+
+  constructor(cfg: SidekickSpawnConfig) {
+    this.cfg = cfg;
+  }
+
+  isAlive(): boolean {
+    return this.child !== undefined && (this.child.exitCode === null || this.child.exitCode === undefined) && !this.child.killed;
+  }
+
+  isBusy(): boolean {
+    return this.pending !== undefined;
+  }
+
+  private send(value: Record<string, unknown>): void {
+    if (!this.child?.stdin?.writable) throw new Error("Sidekick process is not writable");
+    this.child.stdin.write(`${JSON.stringify(value)}\n`);
+  }
+
+  private cleanupPrompt(): void {
+    if (!this.promptPath) return;
+    try {
+      unlinkSync(this.promptPath);
+    } catch {
+      /* already removed */
+    }
+    this.promptPath = undefined;
+  }
+
+  private spawn(): void {
+    mkdirSync(dirname(this.cfg.sessionFile), { recursive: true });
+    this.promptPath = join(tmpdir(), `unipi-fusion-${randomUUID()}.txt`);
+    writeFileSync(this.promptPath, this.cfg.systemPrompt, "utf8");
+    const command = this.cfg.command ?? getPiSpawnCommand([
+      "--mode", "rpc",
+      "--session", this.cfg.sessionFile,
+      "--model", this.cfg.model,
+      "--thinking", this.cfg.thinking,
+      "--append-system-prompt", this.promptPath,
+      "--no-skills",
+    ]);
+    const spawn = this.cfg.spawn ?? defaultSpawn;
+    const child = spawn(command.command, command.args, {
+      cwd: this.cfg.cwd,
+      env: { ...process.env, UNIPI_FUSION_CHILD: "1", UNIPI_SUBAGENT_CHILD: "1" },
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+    this.child = child;
+    child.stdout?.on("data", (data: Buffer | string) => this.readStdout(String(data)));
+    child.stderr?.on("data", (data: Buffer | string) => {
+      this.stderrTail = `${this.stderrTail}${String(data)}`.slice(-2048);
+    });
+    child.on("close", () => {
+      this.cleanupPrompt();
+      if (this.pending !== undefined) this.finish("error", undefined, this.stderrTail || "Sidekick process exited");
+    });
+    child.on("error", (error) => {
+      if (this.pending !== undefined) this.finish("error", undefined, error.message);
+    });
+  }
+
+  private readStdout(data: string): void {
+    this.inputBuffer += data;
+    const lines = this.inputBuffer.split("\n");
+    this.inputBuffer = lines.pop() ?? "";
+    for (const raw of lines) {
+      const line = raw.endsWith("\r") ? raw.slice(0, -1) : raw;
+      if (line.length === 0) continue;
+      try {
+        this.handleMessage(JSON.parse(line) as Record<string, unknown>);
+      } catch {
+        continue;
+      }
+    }
+  }
+
+  private handleMessage(message: Record<string, unknown>): void {
+    if (message.type === "response") {
+      const command = message.command;
+      if (command === "prompt" && message.success === false) {
+        const error = new Error(String(message.error ?? "Sidekick prompt rejected"));
+        const current = this.pending;
+        this.pending = undefined;
+        this.responseError = undefined;
+        this.responseText = undefined;
+        current?.reject(error);
+      } else if (command === "get_last_assistant_text") {
+        const data = message.data as Record<string, unknown> | undefined;
+        const text = typeof data?.text === "string" ? data.text : this.pending?.progress.textTail ?? "";
+        this.responseText?.(text);
+        this.responseText = undefined;
+        this.responseError = undefined;
+      }
+      return;
+    }
+    if (message.type === "extension_ui_request") {
+      const method = message.method;
+      if (method === "select" || method === "confirm" || method === "input" || method === "editor") {
+        this.send({ type: "extension_ui_response", id: message.id, cancelled: true });
+      }
+      return;
+    }
+    if (this.pending === undefined) return;
+    if (message.type === "tool_execution_start") {
+      this.pending.progress.toolCalls += 1;
+      const args = message.args === undefined ? "" : JSON.stringify(message.args).replace(/\s+/gu, " ");
+      const summary = `${String(message.toolName ?? "tool")}(${args})`.slice(0, 40);
+      this.pending.progress.recentTools = [...this.pending.progress.recentTools, summary].slice(-6);
+    } else if (message.type === "message_update") {
+      const event = (message.assistantMessageEvent ?? message) as Record<string, unknown>;
+      if (event.type === "text_delta") {
+        const delta = typeof event.delta === "string" ? event.delta : typeof event.text === "string" ? event.text : "";
+        this.pending.progress.textTail = `${this.pending.progress.textTail}${delta}`.slice(-400);
+      }
+    } else if (message.type === "message_end") {
+      const msg = message.message as Record<string, unknown> | undefined;
+      if (msg?.role === "assistant") {
+        if (msg.stopReason === "error" && typeof msg.errorMessage === "string") this.pendingError = msg.errorMessage;
+        const usage = msg.usage as Record<string, unknown> | undefined;
+        if (usage) {
+          const cost = usage.cost as Record<string, unknown> | undefined;
+          this.addUsage(this.pending.usage, {
+            input: usage.input,
+            output: usage.output,
+            cacheRead: usage.cacheRead,
+            cacheWrite: usage.cacheWrite,
+            cost: cost?.total,
+          });
+        }
+      }
+    } else if (message.type === "agent_settled") {
+      this.responseText = undefined;
+      this.responseError = undefined;
+      this.responseText = (text) => this.finish(this.abortRequested ? "aborted" : this.pendingError === undefined ? "completed" : "error", text, this.pendingError);
+      this.responseError = (error) => this.finish("error", undefined, error.message);
+      try {
+        this.send({ type: "get_last_assistant_text" });
+      } catch (error) {
+        this.finish("error", undefined, error instanceof Error ? error.message : String(error));
+      }
+    }
+  }
+
+  private addUsage(target: SidekickUsage, raw: Record<string, unknown>): void {
+    const number = (value: unknown) => (typeof value === "number" && Number.isFinite(value) ? value : 0);
+    target.input += number(raw.input);
+    target.output += number(raw.output);
+    target.cacheRead += number(raw.cacheRead);
+    target.cacheWrite += number(raw.cacheWrite);
+    target.cost += number(raw.cost);
+    if (target !== this.usage) this.addUsage(this.usage, raw);
+  }
+
+  private finish(status: HandoffReport["status"], text?: string, error?: string): void {
+    const current = this.pending;
+    if (current === undefined) return;
+    this.pending = undefined;
+    this.responseText = undefined;
+    this.responseError = undefined;
+    const report: HandoffReport = {
+      id: current.id,
+      status,
+      text: text ?? current.progress.textTail,
+      usage: { ...current.usage },
+      toolCalls: current.progress.toolCalls,
+      durationMs: Date.now() - current.startedAt,
+      ...(error === undefined ? {} : { error }),
+    };
+    this.reports.set(report.id, report);
+    if (this.latestHandoff?.id === report.id) this.latestHandoff.report = report;
+    current.resolve(report);
+    this.abortRequested = false;
+    this.pendingError = undefined;
+  }
+
+  handoff(message: string): { id: string; done: Promise<HandoffReport> } {
+    if (this.pending !== undefined) {
+      this.send({ type: "steer", message });
+      return { id: this.pending.id, done: this.latestHandoff?.done ?? Promise.reject(new Error("Missing handoff")) };
+    }
+    if (!this.isAlive()) this.spawn();
+    const id = randomUUID();
+    const startedAt = Date.now();
+    let resolve!: (report: HandoffReport) => void;
+    let reject!: (error: Error) => void;
+    const done = new Promise<HandoffReport>((res, rej) => {
+      resolve = res;
+      reject = rej;
+    });
+    this.pendingError = undefined;
+    this.pending = {
+      id,
+      startedAt,
+      usage: emptyUsage(),
+      progress: { toolCalls: 0, recentTools: [], textTail: "", startedAt },
+      resolve,
+      reject,
+    };
+    this.latestHandoff = { id, done };
+    try {
+      this.send({ id, type: "prompt", message });
+    } catch (error) {
+      this.finish("error", undefined, error instanceof Error ? error.message : String(error));
+    }
+    return { id, done };
+  }
+
+  progress(id?: string): HandoffProgress | undefined {
+    if (this.pending !== undefined && (id === undefined || id === this.pending.id)) return { ...this.pending.progress, recentTools: [...this.pending.progress.recentTools] };
+    return undefined;
+  }
+
+  latest(): { id: string; done: Promise<HandoffReport>; report?: HandoffReport } | undefined {
+    return this.latestHandoff;
+  }
+
+  async abort(): Promise<void> {
+    if (!this.pending) return;
+    this.abortRequested = true;
+    this.send({ type: "abort" });
+  }
+
+  kill(): void {
+    const child = this.child;
+    if (!child) return;
+    this.cleanupPrompt();
+    child.kill("SIGTERM");
+    const timer = setTimeout(() => {
+      if (child.exitCode === null || child.exitCode === undefined) child.kill("SIGKILL");
+    }, 2000);
+    timer.unref();
+    this.child = undefined;
+  }
+}

package/src/slider.ts

@@ -0,0 +1,37 @@
+export interface SliderCost {
+  input: number;
+  output: number;
+}
+
+export function blendedPrice(cost: SliderCost | undefined): number | undefined {
+  return cost === undefined ? undefined : (cost.input + cost.output) * 0.5;
+}
+
+export function sliderPosition(price: number, min: number, max: number, cells: number): number {
+  if (cells <= 1 || max <= min) return 0;
+  const value = Math.log10(Math.max(price, Number.EPSILON));
+  const low = Math.log10(Math.max(min, Number.EPSILON));
+  const high = Math.log10(Math.max(max, Number.EPSILON));
+  return Math.max(0, Math.min(cells - 1, Math.round(((value - low) / (high - low)) * (cells - 1))));
+}
+
+function hsvToRgb(h: number, s: number, v: number): [number, number, number] {
+  const c = v * s;
+  const x = c * (1 - Math.abs(((h / 60) % 2) - 1));
+  const m = v - c;
+  const [r, g, b] = h < 60 ? [c, x, 0] : h < 120 ? [x, c, 0] : h < 180 ? [0, c, x] : h < 240 ? [0, x, c] : h < 300 ? [x, 0, c] : [c, 0, x];
+  return [Math.round((r + m) * 255), Math.round((g + m) * 255), Math.round((b + m) * 255)];
+}
+
+export function renderSlider(cells: number, markerIndex: number | undefined): string {
+  const count = Math.max(0, cells);
+  let out = "";
+  for (let i = 0; i < count; i++) {
+    if (i === markerIndex) out += "\x1b[97m●";
+    else {
+      const [r, g, b] = hsvToRgb(count <= 1 ? 0 : (270 * i) / (count - 1), 0.85, 0.95);
+      out += `\x1b[38;2;${String(r)};${String(g)};${String(b)}m━`;
+    }
+  }
+  return `${out}\x1b[39m`;
+}

package/src/tools.ts

@@ -0,0 +1,163 @@
+import { Box, Text } from "@earendil-works/pi-tui";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import type { SidekickRuntime, HandoffReport } from "./sidekick-runtime.js";
+
+const SidekickParams = Type.Object({
+  message: Type.String({ description: "A concrete implementation or verification brief for the sidekick" }),
+  block: Type.Optional(Type.Boolean({ description: "Wait for completion (default true)" })),
+});
+const ReadSubagentParams = Type.Object({
+  agent_id: Type.Optional(Type.String({ description: "Handoff id; omit to use the latest handoff" })),
+  block: Type.Optional(Type.Boolean({ description: "Wait for completion" })),
+  timeout: Type.Optional(Type.Number({ description: "Maximum wait in seconds" })),
+});
+
+export interface FusionToolDeps {
+  getRuntime: (ctx: ExtensionContext) => SidekickRuntime | undefined;
+  onReport?: (ctx: ExtensionContext, report: HandoffReport) => void;
+}
+
+function duration(ms: number): string {
+  return `${(ms / 1000).toFixed(1)}s`;
+}
+
+function progressText(runtime: SidekickRuntime, id: string): string {
+  const progress = runtime.progress(id);
+  if (!progress) return "No active handoff progress.";
+  const elapsed = duration(Date.now() - progress.startedAt);
+  const tools = progress.recentTools.length > 0 ? `\n${progress.recentTools.map((tool) => `  ${tool}`).join("\n")}` : "";
+  const tail = progress.textTail.length > 0 ? `\n  ${progress.textTail}` : "";
+  return `◆ sidekick working · ${String(progress.toolCalls)} tool calls · ${elapsed}${tools}${tail}`;
+}
+
+function progressKey(runtime: SidekickRuntime, id: string): string {
+  const progress = runtime.progress(id);
+  return progress === undefined ? "" : `${String(progress.toolCalls)}|${progress.recentTools.join("|")}|${progress.textTail}`;
+}
+
+function reportText(report: HandoffReport): string {
+  return `${report.text}\n\n--- sidekick ${report.id} · ${report.status} · ${String(report.toolCalls)} tool calls · ${duration(report.durationMs)} · in ${String(report.usage.input)} / out ${String(report.usage.output)} tokens`;
+}
+
+function result(text: string, details?: unknown, isError = false): { content: Array<{ type: "text"; text: string }>; details: unknown; isError: boolean } {
+  return { content: [{ type: "text", text }], details: details ?? {}, isError };
+}
+
+async function waitForReport(
+  runtime: SidekickRuntime,
+  id: string,
+  done: Promise<HandoffReport>,
+  signal: AbortSignal | undefined,
+  ctx: ExtensionContext,
+  onUpdate?: (update: unknown) => void,
+  timeoutMs = 2700000,
+): Promise<{ report?: HandoffReport; interrupted?: string; aborted?: boolean }> {
+  const started = Date.now();
+  let lastProgressKey = "";
+  while (true) {
+    if (signal?.aborted) {
+      await runtime.abort();
+      return { aborted: true };
+    }
+    if (ctx.hasPendingMessages?.()) return { interrupted: progressText(runtime, id) };
+    const remaining = timeoutMs - (Date.now() - started);
+    if (remaining <= 0) return {};
+    const timer = new Promise<undefined>((resolve) => setTimeout(() => resolve(undefined), Math.min(500, remaining)));
+    const report = await Promise.race([done, timer]);
+    if (report !== undefined) return { report };
+    const progress = progressText(runtime, id);
+    const key = progressKey(runtime, id);
+    if (key !== lastProgressKey) {
+      lastProgressKey = key;
+      onUpdate?.({ content: [{ type: "text", text: progress }] });
+    }
+  }
+}
+
+function completionMessage(report: HandoffReport): { customType: string; content: string; display: boolean; details: HandoffReport } {
+  return {
+    customType: "sidekick-completion",
+    content: `<subagent_completion_notification agent_id="${report.id}" status="${report.status}">\n${report.text}\n</subagent_completion_notification>`,
+    display: true,
+    details: report,
+  };
+}
+
+type ThemeLike = {
+  fg: (color: string, text: string) => string;
+  bg: (color: string, text: string) => string;
+  bold: (text: string) => string;
+};
+
+function renderCompletionCard(theme: ThemeLike, report: HandoffReport | undefined): Box {
+  const tone = report?.status === "completed" ? "toolSuccessBg" : "toolErrorBg";
+  const head = report
+    ? `${theme.fg(report.status === "completed" ? "success" : "error", "◆")} ${theme.fg("accent", theme.bold(`sidekick done · ${report.id}`))} ${theme.fg("dim", `· ${String(report.toolCalls)} tool calls · ${duration(report.durationMs)}`)}`
+    : `${theme.fg("accent", "◆")} ${theme.fg("accent", theme.bold("sidekick done"))}`;
+  const lines = [head, ...(report?.text.split("\n").slice(0, 6).map((line) => theme.fg("dim", line)) ?? [])];
+  const box = new Box(1, 0, (text) => theme.bg(tone, text));
+  box.addChild(new Text(lines.join("\n"), 0, 0));
+  return box;
+}
+
+export function registerFusionTools(pi: ExtensionAPI, deps: FusionToolDeps): void {
+  pi.registerMessageRenderer("sidekick-completion", (message: { details?: HandoffReport }, _options, theme) => renderCompletionCard(theme as unknown as ThemeLike, message.details));
+
+  pi.registerTool({
+    name: "sidekick",
+    label: "Sidekick",
+    description: "Hand off work to your persistent sidekick subagent (one per session; context and shells persist across handoffs; runs on the same machine). block:true (default) waits and returns the report. block:false returns immediately and the report arrives later as a <subagent_completion_notification>. Calling again while a handoff is running injects the message as an interrupt rather than starting a second sidekick.",
+    parameters: SidekickParams,
+    async execute(_toolCallId, params, signal, onUpdate, ctx) {
+      const runtime = deps.getRuntime(ctx);
+      if (!runtime) return result("Fusion is not active — pick a Fusion pair with /unipi:model.", undefined, true);
+      const handoff = runtime.handoff(params.message);
+      if (params.block === false) {
+        void handoff.done.then((report) => {
+          deps.onReport?.(ctx, report);
+          pi.sendMessage(completionMessage(report) as never, { deliverAs: "followUp", triggerTurn: true } as never);
+        }).catch(() => undefined);
+        return result(`Handoff ${handoff.id} started in the background. You will receive a <subagent_completion_notification agent_id="${handoff.id}"> when it finishes; use read_subagent to wait.`);
+      }
+      const waited = await waitForReport(runtime, handoff.id, handoff.done, signal, ctx, onUpdate ? (update) => onUpdate(update as never) : undefined);
+      if (waited.report) {
+        deps.onReport?.(ctx, waited.report);
+        return result(reportText(waited.report), waited.report, waited.report.status !== "completed");
+      }
+      if (waited.aborted) return result(`${progressText(runtime, handoff.id)}\nHandoff ${handoff.id} aborted.`, undefined, true);
+      if (waited.interrupted) return result(`A user message arrived while the sidekick (agent_id ${handoff.id}) was working. The handoff continues in the background. Act on the user's message first, then call read_subagent({agent_id:"${handoff.id}", block:true}) to collect the report or sidekick({message}) to redirect it.\n${waited.interrupted}`);
+      return result(`Handoff ${handoff.id} is still running.\n${progressText(runtime, handoff.id)}`);
+    },
+  });
+
+  pi.registerTool({
+    name: "read_subagent",
+    label: "Read Sidekick",
+    description: "Read a sidekick handoff report by agent_id (omit for the latest). block:true waits for completion (default timeout 2700s when omitted); block:false returns the current progress snapshot immediately.",
+    parameters: ReadSubagentParams,
+    async execute(_toolCallId, params, signal, onUpdate, ctx) {
+      const runtime = deps.getRuntime(ctx);
+      if (!runtime) return result("Fusion is not active — pick a Fusion pair with /unipi:model.", undefined, true);
+      const latest = runtime.latest();
+      if (!latest) return result("No sidekick handoff has run yet.", undefined, true);
+      const id = params.agent_id ?? latest.id;
+      const selected = runtime.reports.get(id);
+      if (selected) return result(reportText(selected), selected, selected.status !== "completed");
+      if (id !== latest.id) return result(`No sidekick handoff found for ${id}.`, undefined, true);
+      if (params.block !== true) return result(`Handoff ${id} is still running.\n${progressText(runtime, id)}`);
+      const timeoutMs = (params.timeout ?? 2700) * 1000;
+      const waited = await waitForReport(runtime, id, latest.done, signal, ctx, onUpdate ? (update) => onUpdate(update as never) : undefined, timeoutMs);
+      if (waited.report) {
+        deps.onReport?.(ctx, waited.report);
+        return result(reportText(waited.report), waited.report, waited.report.status !== "completed");
+      }
+      if (waited.aborted) return result(`Handoff ${id} aborted.`, undefined, true);
+      if (waited.interrupted) return result(`A user message arrived while the sidekick (agent_id ${id}) was working.\n${waited.interrupted}`);
+      return result(`Handoff ${id} is still running.\n${progressText(runtime, id)}`);
+    },
+  });
+
+}
+
+export { reportText, progressText };