@runfusion/fusion 0.1.2 → 0.1.3

package/dist/pi-claude-cli/index.ts

@@ -0,0 +1,131 @@
+/**
+ * Pi extension entry point for pi-claude-cli.
+ *
+ * Registers a custom provider that routes LLM calls through the Claude Code CLI
+ * subprocess using stream-json NDJSON protocol.
+ */
+
+import { getModels } from "@mariozechner/pi-ai";
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { streamViaCli } from "./src/provider.js";
+import {
+  validateCliPresence,
+  validateCliAuth,
+  killAllProcesses,
+} from "./src/process-manager.js";
+import { getCustomToolDefs, writeMcpConfig } from "./src/mcp-config.js";
+
+// Kill all active Claude subprocesses on process exit to prevent orphans
+process.on("exit", killAllProcesses);
+
+const PROVIDER_ID = "pi-claude-cli";
+
+let mcpConfigPath: string | undefined;
+let mcpConfigResolved = false;
+
+/**
+ * Lazily generate MCP config on first request (not at load time).
+ * pi.getAllTools() fails during extension loading; this defers it
+ * until the pi runtime is fully initialized.
+ *
+ * Only locks (sets mcpConfigResolved) when getAllTools() returns a
+ * real array — if it returns undefined/null (registry not ready),
+ * we retry on the next request. Once the registry is ready we
+ * commit to the result even if there are zero custom tools.
+ *
+ * Uses warn-don't-block: failure logs a warning but does not
+ * prevent the provider from functioning (built-ins still work).
+ */
+function ensureMcpConfig(pi: ExtensionAPI): string | undefined {
+  if (mcpConfigResolved) return mcpConfigPath;
+  try {
+    const allTools = pi.getAllTools();
+
+    // Registry not ready yet — don't lock, retry on next call
+    if (!Array.isArray(allTools)) {
+      return mcpConfigPath;
+    }
+
+    // Registry is ready — lock regardless of whether custom tools exist
+    mcpConfigResolved = true;
+
+    const toolDefs = getCustomToolDefs(pi);
+    if (toolDefs.length > 0) {
+      mcpConfigPath = writeMcpConfig(toolDefs);
+      console.error(
+        `[pi-claude-cli] MCP config generated with ${toolDefs.length} custom tool(s)`,
+      );
+    }
+  } catch (err) {
+    console.warn(
+      "[pi-claude-cli] MCP config generation failed, custom tools unavailable:",
+      err,
+    );
+  }
+  return mcpConfigPath;
+}
+
+export default function (pi: ExtensionAPI) {
+  try {
+    // Startup validation
+    validateCliPresence(); // throws if CLI not on PATH
+    validateCliAuth(); // warns if not authenticated
+
+    const catalogModels = getModels("anthropic").map((model) => ({
+      id: model.id,
+      name: model.name,
+      reasoning: model.reasoning,
+      input: model.input,
+      cost: model.cost,
+      contextWindow: model.contextWindow,
+      maxTokens: model.maxTokens,
+    }));
+
+    // Newer models released after the pinned @mariozechner/pi-ai catalog
+    // was generated. Dedupe by id so this list is harmless once the upstream
+    // catalog catches up.
+    // https://platform.claude.com/docs/en/about-claude/models/overview
+    const extraModels: typeof catalogModels = [
+      {
+        id: "claude-opus-4-7",
+        name: "Claude Opus 4.7",
+        reasoning: true,
+        input: ["text", "image"],
+        cost: { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 },
+        contextWindow: 1_000_000,
+        maxTokens: 128_000,
+      },
+    ];
+
+    const seen = new Set(catalogModels.map((m) => m.id));
+    const models = [
+      ...catalogModels,
+      ...extraModels.filter((m) => !seen.has(m.id)),
+    ];
+
+    // Ensure all registered tools are active so pi can execute them.
+    // Some tools (find, grep, ls) are registered but not activated by default.
+    pi.on("session_start", async () => {
+      const allTools = pi.getAllTools();
+      if (Array.isArray(allTools)) {
+        pi.setActiveTools(allTools.map((t: { name: string }) => t.name));
+      }
+    });
+
+    pi.registerProvider(PROVIDER_ID, {
+      baseUrl: "pi-claude-cli",
+      apiKey: "unused",
+      api: "pi-claude-cli",
+      models,
+      streamSimple: (model, context, options) => {
+        const configPath = ensureMcpConfig(pi);
+        return streamViaCli(model, context, {
+          ...options,
+          mcpConfigPath: configPath,
+        });
+      },
+    });
+  } catch (err) {
+    console.error(`[pi-claude-cli] Failed to register provider:`, err);
+  }
+}

package/dist/pi-claude-cli/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@fusion/pi-claude-cli",
+  "version": "0.3.1",
+  "description": "Fusion vendored fork: pi coding-agent extension that routes LLM calls through the Claude Code CLI. Forked from rchern/pi-claude-cli (MIT). See UPSTREAM.md.",
+  "license": "MIT",
+  "private": true,
+  "type": "module",
+  "main": "index.ts",
+  "keywords": [
+    "pi-package"
+  ],
+  "pi": {
+    "extensions": [
+      "index.ts"
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Runfusion/Fusion",
+    "directory": "packages/pi-claude-cli"
+  },
+  "dependencies": {
+    "cross-spawn": "^7.0.6"
+  },
+  "peerDependencies": {
+    "@mariozechner/pi-ai": "*",
+    "@mariozechner/pi-coding-agent": "*"
+  },
+  "devDependencies": {
+    "@types/cross-spawn": "^6.0.6",
+    "@types/node": "^22.0.0",
+    "typescript": "^5.7.0",
+    "vitest": "^3.0.0"
+  },
+  "scripts": {
+    "test": "vitest run --reporter=dot",
+    "typecheck": "tsc --noEmit"
+  }
+}

package/dist/pi-claude-cli/src/control-handler.ts

@@ -0,0 +1,68 @@
+/**
+ * Control protocol handler for Claude CLI stream-json communication.
+ *
+ * Processes control_request messages from Claude CLI stdout and writes
+ * control_response messages to stdin.
+ *
+ * - Custom MCP tools (mcp__custom-tools__*): DENIED — pi executes these
+ * - Everything else (user MCP tools, internal tools): ALLOWED — Claude handles
+ */
+
+import type { ClaudeControlRequest } from "./types";
+import { CUSTOM_TOOLS_MCP_PREFIX } from "./tool-mapping.js";
+
+export const TOOL_EXECUTION_DENIED_MESSAGE =
+  "Tool execution is unavailable in this environment.";
+
+/** Prefix for MCP (Model Context Protocol) tool names. */
+export const MCP_PREFIX = "mcp__";
+
+interface ControlResponse {
+  type: "control_response";
+  request_id: string;
+  response: {
+    subtype: "success";
+    response: {
+      behavior: "allow" | "deny";
+      message?: string;
+    };
+  };
+}
+
+/**
+ * Handle a control_request from the Claude CLI.
+ *
+ * Denies custom MCP tools (mcp__custom-tools__*) so pi can execute them.
+ * Allows everything else (user MCP tools, internal Claude tools).
+ *
+ * @returns true if the tool was allowed, false if denied
+ */
+export function handleControlRequest(
+  msg: ClaudeControlRequest,
+  stdin: NodeJS.WritableStream,
+): boolean {
+  if (!msg.request_id || !msg.request) {
+    console.error(
+      "[pi-claude-cli] Malformed control_request: missing request_id or request object",
+      msg,
+    );
+    return false;
+  }
+
+  const toolName = msg.request?.tool_name ?? "";
+  const isCustomTool = toolName.startsWith(CUSTOM_TOOLS_MCP_PREFIX);
+
+  const response: ControlResponse = {
+    type: "control_response",
+    request_id: msg.request_id,
+    response: {
+      subtype: "success",
+      response: isCustomTool
+        ? { behavior: "deny", message: TOOL_EXECUTION_DENIED_MESSAGE }
+        : { behavior: "allow" },
+    },
+  };
+
+  stdin.write(JSON.stringify(response) + "\n");
+  return !isCustomTool;
+}

package/dist/pi-claude-cli/src/event-bridge.ts

@@ -0,0 +1,386 @@
+import type { ClaudeApiEvent, TrackedContentBlock } from "./types";
+import { calculateCost } from "@mariozechner/pi-ai";
+import type {
+  Api,
+  AssistantMessage,
+  AssistantMessageEventStream,
+  Model,
+  TextContent,
+  ThinkingContent,
+  ToolCall,
+} from "@mariozechner/pi-ai";
+import {
+  mapClaudeToolNameToPi,
+  translateClaudeArgsToPi,
+  isPiKnownClaudeTool,
+} from "./tool-mapping.js";
+
+/**
+ * Extended tracking for tool_use content blocks during streaming.
+ * Stores the Claude tool name for argument translation at block_stop.
+ */
+interface TrackedToolBlock {
+  type: "tool_use";
+  index: number;
+  id: string;
+  name: string; // Already mapped to pi name
+  claudeName: string; // Original Claude name for arg translation
+  arguments: Record<string, unknown>;
+  partialJson: string;
+}
+
+/** Union of tracked block types for the blocks array. */
+type TrackedBlock = TrackedContentBlock | TrackedToolBlock;
+
+/**
+ * The event bridge interface returned by createEventBridge.
+ * handleEvent processes each Claude API streaming event and pushes
+ * the appropriate pi events to the stream.
+ * getOutput returns the accumulated AssistantMessage.
+ */
+export interface EventBridge {
+  handleEvent(event: ClaudeApiEvent): void;
+  getOutput(): AssistantMessage;
+}
+
+/**
+ * Map Claude API stop reasons to pi's stop reason format.
+ */
+function mapStopReason(
+  reason: string | undefined,
+): "stop" | "length" | "toolUse" {
+  switch (reason) {
+    case "tool_use":
+      return "toolUse";
+    case "max_tokens":
+      return "length";
+    case "end_turn":
+    default:
+      return "stop";
+  }
+}
+
+/**
+ * Create an event bridge that translates Claude API streaming events
+ * into pi's AssistantMessageEventStream events.
+ *
+ * The bridge maintains internal state to track content blocks and
+ * accumulate the final AssistantMessage. It handles:
+ * - text content blocks (start/delta/stop -> text_start/text_delta/text_end)
+ * - message lifecycle (message_start for usage, message_delta for stop reason, message_stop for done)
+ * - unsupported block types (tool_use, thinking) with warnings
+ */
+export function createEventBridge(
+  stream: AssistantMessageEventStream,
+  model: Model<Api>,
+): EventBridge {
+  // Tracked content blocks indexed by Claude's content_block index
+  const blocks: TrackedBlock[] = [];
+
+  // The accumulated output message
+  const output: AssistantMessage = {
+    role: "assistant" as const,
+    content: [] as (TextContent | ThinkingContent | ToolCall)[],
+    api: "pi-claude-cli",
+    provider: model.provider,
+    model: model.id,
+    usage: {
+      input: 0,
+      output: 0,
+      cacheRead: 0,
+      cacheWrite: 0,
+      totalTokens: 0,
+      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+    },
+    stopReason: "stop" as const,
+    timestamp: Date.now(),
+  };
+
+  let started = false;
+
+  function handleEvent(event: ClaudeApiEvent): void {
+    // Emit start event on first message — tells pi to begin incremental rendering
+    if (!started) {
+      stream.push({ type: "start", partial: output });
+      started = true;
+    }
+
+    switch (event.type) {
+      case "message_start":
+        handleMessageStart(event);
+        break;
+      case "content_block_start":
+        handleContentBlockStart(event);
+        break;
+      case "content_block_delta":
+        handleContentBlockDelta(event);
+        break;
+      case "content_block_stop":
+        handleContentBlockStop(event);
+        break;
+      case "message_delta":
+        handleMessageDelta(event);
+        break;
+      case "message_stop":
+        handleMessageStop();
+        break;
+      // Unknown event types are silently ignored
+    }
+  }
+
+  function handleMessageStart(event: ClaudeApiEvent): void {
+    const usage = event.message?.usage;
+    if (usage) {
+      output.usage.input = usage.input_tokens ?? 0;
+      output.usage.output = usage.output_tokens ?? 0;
+      output.usage.cacheRead = usage.cache_read_input_tokens ?? 0;
+      output.usage.cacheWrite = usage.cache_creation_input_tokens ?? 0;
+      output.usage.totalTokens =
+        output.usage.input +
+        output.usage.output +
+        output.usage.cacheRead +
+        output.usage.cacheWrite;
+      calculateCost(model, output.usage);
+    }
+  }
+
+  function handleContentBlockStart(event: ClaudeApiEvent): void {
+    const blockType = event.content_block?.type;
+
+    if (blockType === "text") {
+      const block: TrackedContentBlock = {
+        type: "text",
+        text: "",
+        index: event.index ?? 0,
+      };
+      blocks.push(block);
+      output.content.push({ type: "text" as const, text: "" });
+
+      stream.push({
+        type: "text_start",
+        contentIndex: output.content.length - 1,
+        partial: output,
+      });
+    } else if (blockType === "thinking") {
+      const block: TrackedContentBlock = {
+        type: "thinking",
+        text: "",
+        index: event.index ?? 0,
+      };
+      blocks.push(block);
+      output.content.push({
+        type: "thinking" as const,
+        thinking: "",
+        thinkingSignature: "",
+      });
+
+      stream.push({
+        type: "thinking_start",
+        contentIndex: output.content.length - 1,
+        partial: output,
+      });
+    } else if (blockType === "tool_use") {
+      const claudeName = event.content_block!.name!;
+
+      // Skip internal Claude Code tools (ToolSearch, Task, Agent, etc.)
+      // that pi cannot execute — only emit pi-known tools
+      if (!isPiKnownClaudeTool(claudeName)) {
+        return;
+      }
+
+      const piName = mapClaudeToolNameToPi(claudeName);
+      const id = event.content_block!.id!;
+
+      const block: TrackedToolBlock = {
+        type: "tool_use",
+        index: event.index ?? 0,
+        id,
+        name: piName,
+        claudeName,
+        arguments: {},
+        partialJson: "",
+      };
+      blocks.push(block);
+      output.content.push({
+        type: "toolCall" as const,
+        id,
+        name: piName,
+        arguments: {},
+      } as ToolCall);
+
+      stream.push({
+        type: "toolcall_start",
+        contentIndex: output.content.length - 1,
+        partial: output,
+      });
+    }
+    // Unknown block types silently ignored
+  }
+
+  function handleContentBlockDelta(event: ClaudeApiEvent): void {
+    const deltaType = event.delta?.type;
+
+    if (deltaType === "text_delta" && event.delta!.text != null) {
+      const idx = blocks.findIndex((b) => b.index === event.index);
+      if (idx === -1) return;
+
+      const block = blocks[idx];
+      if (block.type === "text") {
+        block.text += event.delta!.text;
+        const contentBlock = output.content[idx] as TextContent;
+        contentBlock.text = block.text;
+
+        stream.push({
+          type: "text_delta",
+          contentIndex: idx,
+          delta: event.delta!.text,
+          partial: output,
+        });
+      }
+    } else if (
+      deltaType === "thinking_delta" &&
+      event.delta!.thinking != null
+    ) {
+      const idx = blocks.findIndex((b) => b.index === event.index);
+      if (idx === -1) return;
+
+      const block = blocks[idx];
+      if (block.type === "thinking") {
+        block.text += event.delta!.thinking;
+        const contentBlock = output.content[idx] as ThinkingContent;
+        contentBlock.thinking = block.text;
+
+        stream.push({
+          type: "thinking_delta",
+          contentIndex: idx,
+          delta: event.delta!.thinking,
+          partial: output,
+        });
+      }
+    } else if (
+      deltaType === "input_json_delta" &&
+      event.delta!.partial_json != null
+    ) {
+      const idx = blocks.findIndex((b) => b.index === event.index);
+      if (idx === -1) return;
+
+      const block = blocks[idx];
+      if (block.type === "tool_use") {
+        block.partialJson += event.delta!.partial_json;
+
+        // Try to parse accumulated JSON -- on success update args, on failure keep previous
+        try {
+          block.arguments = JSON.parse(block.partialJson);
+          (output.content[idx] as ToolCall).arguments = block.arguments as Record<string, unknown>;
+        } catch {
+          // Partial JSON not yet parseable -- keep previous arguments
+        }
+
+        stream.push({
+          type: "toolcall_delta",
+          contentIndex: idx,
+          delta: event.delta!.partial_json,
+          partial: output,
+        });
+      }
+    } else if (
+      deltaType === "signature_delta" &&
+      event.delta!.signature != null
+    ) {
+      // Accumulate signature on the thinking block
+      const idx = blocks.findIndex((b) => b.index === event.index);
+      if (idx === -1) return;
+
+      const block = blocks[idx];
+      if (block.type === "thinking") {
+        const contentBlock = output.content[idx] as ThinkingContent;
+        contentBlock.thinkingSignature =
+          (contentBlock.thinkingSignature || "") + event.delta!.signature;
+      }
+    }
+  }
+
+  function handleContentBlockStop(event: ClaudeApiEvent): void {
+    const idx = blocks.findIndex((b) => b.index === event.index);
+    if (idx === -1) return;
+
+    const block = blocks[idx];
+    // Clean up the tracking index from the block (no longer needed)
+    delete (block as unknown as Record<string, unknown>).index;
+
+    if (block.type === "text") {
+      stream.push({
+        type: "text_end",
+        contentIndex: idx,
+        content: block.text,
+        partial: output,
+      });
+    } else if (block.type === "thinking") {
+      stream.push({
+        type: "thinking_end",
+        contentIndex: idx,
+        content: block.text,
+        partial: output,
+      });
+    } else if (block.type === "tool_use") {
+      // Final JSON parse with fallback to raw string
+      let finalArgs: Record<string, unknown> | string;
+      try {
+        const parsed = JSON.parse(block.partialJson);
+        finalArgs = translateClaudeArgsToPi(block.claudeName, parsed);
+      } catch {
+        finalArgs = block.partialJson;
+      }
+
+      // Update output.content with final arguments
+      const contentBlock = output.content[idx] as ToolCall;
+      // ToolCall.arguments is typed as Record<string, any> in pi-ai, but we
+      // intentionally emit a raw string when JSON parse fails completely.
+      // Pi handles string arguments gracefully at runtime.
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- finalArgs may be a raw string when JSON parse fails; pi-ai handles it at runtime
+      (contentBlock as any).arguments = finalArgs;
+      const toolCall = {
+        type: "toolCall" as const,
+        id: block.id,
+        name: block.name,
+        arguments: finalArgs,
+      } as ToolCall;
+
+      stream.push({
+        type: "toolcall_end",
+        contentIndex: idx,
+        toolCall,
+        partial: output,
+      });
+    }
+  }
+
+  function handleMessageDelta(event: ClaudeApiEvent): void {
+    if (event.delta?.stop_reason) {
+      output.stopReason = mapStopReason(event.delta.stop_reason);
+    }
+
+    const usage = event.usage;
+    if (usage) {
+      if (usage.input_tokens != null) output.usage.input = usage.input_tokens;
+      if (usage.output_tokens != null)
+        output.usage.output = usage.output_tokens;
+      output.usage.totalTokens =
+        output.usage.input +
+        output.usage.output +
+        output.usage.cacheRead +
+        output.usage.cacheWrite;
+      calculateCost(model, output.usage);
+    }
+  }
+
+  function handleMessageStop(): void {
+    // No-op: done event is pushed by the provider after readline closes.
+    // Pushing done here (synchronously) prevents pi from executing tools.
+  }
+
+  return {
+    handleEvent,
+    getOutput: () => output,
+  };
+}