@saccolabs/pi-claude-cli 0.4.0

package/src/event-bridge.ts

@@ -0,0 +1,385 @@
+import type { ClaudeApiEvent, TrackedContentBlock } from "./types";
+import { calculateCost } from "@earendil-works/pi-ai";
+import type {
+  AssistantMessage,
+  AssistantMessageEventStream,
+  Model,
+  TextContent,
+  ThinkingContent,
+  ToolCall,
+} from "@earendil-works/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<any>,
+): 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 any).arguments = block.arguments;
+        } 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 any).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;
+      (contentBlock as any).arguments = finalArgs;
+
+      // 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.
+      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,
+  };
+}

package/src/mcp-config.ts

@@ -0,0 +1,93 @@
+/**
+ * Custom tool discovery and MCP config file generation.
+ *
+ * Discovers non-built-in tools from pi, writes their schemas to a temp file,
+ * and generates an MCP config that points to the schema-only MCP server.
+ */
+
+import { writeFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { tmpdir } from "node:os";
+import { fileURLToPath } from "node:url";
+
+/** The 6 built-in tools that pi handles natively (match pi tool names). */
+const BUILT_IN_TOOL_NAMES = new Set([
+  "read",
+  "write",
+  "edit",
+  "bash",
+  "grep",
+  "find",
+]);
+
+/** A custom tool definition with MCP-compatible schema. */
+export interface McpToolDef {
+  name: string;
+  description: string;
+  inputSchema: Record<string, unknown>;
+}
+
+/**
+ * Get custom tool definitions from pi, filtering out built-in tools.
+ *
+ * @param pi - The pi ExtensionAPI instance
+ * @returns Array of custom tool definitions (empty if all tools are built-in)
+ */
+export function getCustomToolDefs(pi: any): McpToolDef[] {
+  const allTools = pi.getAllTools();
+
+  if (!Array.isArray(allTools)) {
+    return [];
+  }
+
+  return allTools
+    .filter((tool: any) => !BUILT_IN_TOOL_NAMES.has(tool.name))
+    .map((tool: any) => ({
+      name: tool.name,
+      description: tool.description,
+      inputSchema: tool.parameters,
+    }));
+}
+
+/**
+ * Write MCP config and tool schemas to temp files.
+ *
+ * Creates two temp files:
+ * 1. Schema file: JSON array of tool definitions
+ * 2. Config file: MCP config pointing to the schema-only server
+ *
+ * @param toolDefs - Array of custom tool definitions
+ * @returns Path to the MCP config file
+ */
+export function writeMcpConfig(toolDefs: McpToolDef[]): string {
+  // Write tool schemas to temp file
+  const schemaFilePath = join(
+    tmpdir(),
+    `pi-claude-mcp-schemas-${process.pid}.json`,
+  );
+  writeFileSync(schemaFilePath, JSON.stringify(toolDefs));
+
+  // Resolve path to the schema server .cjs file (sibling of this module)
+  const __filename = fileURLToPath(import.meta.url);
+  const __dirname = dirname(__filename);
+  const serverPath = join(__dirname, "mcp-schema-server.cjs");
+
+  // Build MCP config
+  const config = {
+    mcpServers: {
+      "custom-tools": {
+        command: "node",
+        args: [serverPath, schemaFilePath],
+      },
+    },
+  };
+
+  // Write config to temp file
+  const configFilePath = join(
+    tmpdir(),
+    `pi-claude-mcp-config-${process.pid}.json`,
+  );
+  writeFileSync(configFilePath, JSON.stringify(config));
+
+  return configFilePath;
+}

package/src/mcp-schema-server.cjs

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+// Schema-only MCP server. Reads tool schemas from a JSON file.
+// Only implements initialize + tools/list. tools/call is never reached
+// because the parent process kills the Claude subprocess at message_stop
+// before tool execution (break-early pattern).
+"use strict";
+
+const fs = require("fs");
+const readline = require("readline");
+
+const schemaPath = process.argv[2];
+if (!schemaPath) {
+  process.exit(1);
+}
+
+let tools = [];
+try {
+  tools = JSON.parse(fs.readFileSync(schemaPath, "utf-8"));
+} catch {
+  process.exit(1);
+}
+
+const rl = readline.createInterface({ input: process.stdin });
+rl.on("line", (line) => {
+  let msg;
+  try {
+    msg = JSON.parse(line);
+  } catch {
+    return;
+  }
+
+  if (msg.method === "initialize") {
+    const resp = {
+      jsonrpc: "2.0",
+      id: msg.id,
+      result: {
+        protocolVersion: "2024-11-05",
+        capabilities: { tools: {} },
+        serverInfo: { name: "custom-tools", version: "1.0.0" },
+      },
+    };
+    process.stdout.write(JSON.stringify(resp) + "\n");
+  } else if (msg.method === "tools/list") {
+    const resp = { jsonrpc: "2.0", id: msg.id, result: { tools } };
+    process.stdout.write(JSON.stringify(resp) + "\n");
+  }
+  // notifications/initialized: no response needed (notification)
+  // tools/call: never reached (break-early kills subprocess first)
+});