Pi Integration

const args = [
  "--mode", "rpc",
  "--session-dir", SESSIONS_DIR,  // ~/Library/Application Support/RubberDuck/pi-sessions/
  "--tools", PI_TOOLS.join(","),  // read,write,edit,bash,grep,find
];

if (piModel) {
  args.push("--model", piModel);  // gpt-4o-mini, gpt-4o, etc.
}
if (piProvider) {
  args.push("--provider", piProvider);  // openai, anthropic
}
args.push("--thinking", PI_DEFAULT_THINKING);  // "off" for speed

if (sessionFile) {
  args.push("--session", sessionFile);  // Resume specific session
}
if (continueSession) {
  args.push("-c");  // Continue most recent session
}

this.process = spawn(PI_BINARY, args, {
  cwd: workspacePath,  // Pi executes all commands in workspace
  stdio: ["pipe", "pipe", "pipe"],
  env: { ...process.env },
});

{ "id": "req_abc123", "type": "prompt", "text": "List files in src/" }

{
  "id": "req_abc123",
  "command": "prompt",
  "success": true,
  "data": { ... }
}

sendCommand(command: string, params?: Record<string, unknown>): Promise<PiRpcResponse> {
  const id = generateId();
  const request: PiRpcRequest = { id, type: command, ...params };
  const line = `${JSON.stringify(request)}\n`;

  return new Promise((resolve, reject) => {
    const timer = setTimeout(() => {
      this.pending.delete(id);
      reject(new Error(`Pi command "${command}" timed out after 30s`));
    }, PI_COMMAND_TIMEOUT_MS);

    this.pending.set(id, { command, resolve, reject, timer });
    this.process.stdin?.write(line);
  });
}

{ "type": "message_update", "content": [{ "text": "Here are the files..." }] }
{ "type": "tool_execution_start", "tool": "bash", "args": { "command": "ls src/" } }
{ "type": "tool_execution_update", "stdout": "file1.ts\nfile2.ts\n" }
{ "type": "tool_execution_end", "exit_code": 0 }
{ "type": "agent_end", "reason": "complete" }

const rl = createInterface({ input: this.process.stdout });
rl.on("line", (line) => {
  const msg = JSON.parse(line);
  if (msg.type === "response") {
    this.handleResponse(msg as PiRpcResponse);
  } else {
    // It's an event — forward to all event handlers
    for (const handler of this.eventHandlers) {
      handler(msg as PiEvent);
    }
  }
});

await piProcess.sendCommand("prompt", { text: "Fix the bug in server.ts" });

await piProcess.sendCommand("abort");

const response = await piProcess.sendCommand("get_state");
const { sessionId, sessionFile, sessionName } = response.data;

export class EventBus {
  private subscriptions = new Map<
    string,  // clientId
    Map<string, (event: PiEvent) => void>  // sessionId → handler
  >();

  subscribe(clientId: string, sessionId: string, handler: (event: PiEvent) => void) {
    // ...
  }

  publish(sessionId: string, event: PiEvent) {
    // Send to all clients subscribed to this sessionId
  }
}

# Terminal 1
duck ~/my-repo

# Terminal 2 (same repo)
duck ~/my-repo

[tool] bash: npm test
  PASS tests/app.test.ts
  ...
[tool] ✓ exit 0

[assistant] All tests passed!

~/Library/Application Support/RubberDuck/pi-sessions/
  <sessionId>.jsonl

{"type":"user","content":"Fix the bug"}
{"type":"assistant","content":"I'll help fix that. First, let me check the code."}
{"type":"tool_call","tool":"read","args":{"path":"app.ts"}}
{"type":"tool_result","output":"...file contents..."}

duck attach --session my-feature-work

duck attach -c

# Terminal 1: debug session
duck ~/my-repo --name debug-tests

# Terminal 2: refactor session
duck ~/my-repo --name refactor-module

export class HealthMonitor {
  start() {
    this.interval = setInterval(() => {
      for (const [sessionId, session] of metadataStore.getSessions()) {
        const piProcess = processManager.get(sessionId);
        if (piProcess && !piProcess.isAlive()) {
          // Pi died unexpectedly — clean up
          processManager.remove(sessionId);
          eventBus.publish(sessionId, { type: "pi_died", exitCode: piProcess.getExitCode() });
        }
      }
    }, 30000);
  }
}

{
  "type": "extension_ui_request",
  "ui_type": "confirm",
  "message": "Apply this migration? (y/n)"
}

import { confirm, text } from "@clack/prompts";

export async function handleUIRequest(event: ExtensionUIRequestEvent): Promise<string> {
  if (event.ui_type === "confirm") {
    const answer = await confirm({ message: event.message });
    return answer ? "yes" : "no";
  }
  if (event.ui_type === "input") {
    const answer = await text({ message: event.message });
    return String(answer);
  }
  throw new Error(`Unsupported ui_type: ${event.ui_type}`);
}

await daemonClient.request("extension_ui_response", { sessionId, response });

piProcess.sendUntracked("extension_ui_response", { response });

this.process.on("exit", (code) => {
  this.alive = false;
  this.exitCode = code;
  
  // Reject all pending requests
  for (const [id, pending] of this.pending) {
    clearTimeout(pending.timer);
    pending.reject(new Error(`Pi process exited with code ${code}`));
  }
});

const timer = setTimeout(() => {
  this.pending.delete(id);
  reject(new Error(`Pi command "${command}" timed out after 30s`));
}, PI_COMMAND_TIMEOUT_MS);

{
  "type": "tool_execution_end",
  "id": "tool_abc",
  "exit_code": 1,
  "stderr": "Error: File not found"
}

{
  "id": "req_abc",
  "command": "prompt",
  "success": false,
  "error": "OpenAI API rate limit exceeded"
}

export const PI_BINARY = (() => {
  // 1. Explicit override
  if (process.env.RUBBER_DUCK_PI_BINARY) {
    return process.env.RUBBER_DUCK_PI_BINARY;
  }
  
  // 2. Local node_modules/.bin/pi (for development)
  const localPi = path.join(process.cwd(), "node_modules", ".bin", "pi");
  if (existsSync(localPi)) {
    return localPi;
  }
  
  // 3. System PATH
  return "pi";
})();

export function resolveDefaultPiModel(): string | undefined {
  return process.env.RUBBER_DUCK_PI_MODEL || 
         (process.env.OPENAI_API_KEY ? "gpt-4o-mini" : undefined);
}

export function resolveDefaultPiProvider(): string | undefined {
  return process.env.RUBBER_DUCK_PI_PROVIDER ||
         (process.env.OPENAI_API_KEY ? "openai" : undefined) ||
         (process.env.ANTHROPIC_API_KEY ? "anthropic" : undefined);
}

export const SESSIONS_DIR = path.join(
  APP_SUPPORT,  // ~/Library/Application Support/RubberDuck/
  "pi-sessions"
);

# Requires OPENAI_API_KEY or ANTHROPIC_API_KEY
make e2e-cli