@hienlh/ppm 0.1.0

package/src/providers/claude-binary-finder.ts

@@ -0,0 +1,256 @@
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+
+/**
+ * Represents a discovered Claude CLI installation.
+ * Mirrors opcode's ClaudeInstallation struct.
+ */
+export interface ClaudeInstallation {
+  path: string;
+  version: string | null;
+  source: string;
+}
+
+/**
+ * Source preference score (lower = better).
+ * Mirrors opcode's source_preference() function.
+ */
+function sourcePreference(source: string): number {
+  const order: Record<string, number> = {
+    "which": 1,
+    "homebrew": 2,
+    "system": 3,
+    "nvm-active": 4,
+    "local-bin": 6,
+    "claude-local": 7,
+    "npm-global": 8,
+    "yarn": 9,
+    "bun": 10,
+    "node-modules": 11,
+    "home-bin": 12,
+    "PATH": 13,
+  };
+  if (source.startsWith("nvm")) return 5;
+  return order[source] ?? 14;
+}
+
+/**
+ * Try `which claude` (Unix) to find the binary.
+ * Handles aliased output: "claude: aliased to /path/to/claude".
+ */
+function tryWhichCommand(): ClaudeInstallation | null {
+  try {
+    const result = Bun.spawnSync(["which", "claude"], { stdout: "pipe", stderr: "pipe" });
+    if (result.exitCode !== 0) return null;
+
+    let output = result.stdout.toString().trim();
+    if (!output) return null;
+
+    // Parse aliased output
+    if (output.startsWith("claude:") && output.includes("aliased to")) {
+      output = output.split("aliased to")[1]?.trim() ?? "";
+    }
+    if (!output || !existsSync(output)) return null;
+
+    return { path: output, version: getClaudeVersion(output), source: "which" };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Find Claude installations in NVM directories.
+ * Checks NVM_BIN env var and all NVM node version bin directories.
+ */
+function findNvmInstallations(): ClaudeInstallation[] {
+  const installations: ClaudeInstallation[] = [];
+  const home = process.env.HOME;
+  if (!home) return installations;
+
+  // Check NVM_BIN (current active NVM)
+  const nvmBin = process.env.NVM_BIN;
+  if (nvmBin) {
+    const claudePath = join(nvmBin, "claude");
+    if (existsSync(claudePath)) {
+      installations.push({
+        path: claudePath,
+        version: getClaudeVersion(claudePath),
+        source: "nvm-active",
+      });
+    }
+  }
+
+  // Scan all NVM node versions
+  const nvmDir = join(home, ".nvm", "versions", "node");
+  try {
+    for (const entry of readdirSync(nvmDir) as string[]) {
+      const claudePath = join(nvmDir, entry, "bin", "claude");
+      if (existsSync(claudePath) && statSync(claudePath).isFile()) {
+        installations.push({
+          path: claudePath,
+          version: getClaudeVersion(claudePath),
+          source: `nvm (${entry})`,
+        });
+      }
+    }
+  } catch {
+    // NVM dir doesn't exist — skip
+  }
+
+  return installations;
+}
+
+/**
+ * Check standard installation paths.
+ * Mirrors opcode's find_standard_installations().
+ */
+function findStandardInstallations(): ClaudeInstallation[] {
+  const installations: ClaudeInstallation[] = [];
+  const home = process.env.HOME ?? "";
+
+  const pathsToCheck: [string, string][] = [
+    ["/usr/local/bin/claude", "system"],
+    ["/opt/homebrew/bin/claude", "homebrew"],
+    ["/usr/bin/claude", "system"],
+    [join(home, ".claude/local/claude"), "claude-local"],
+    [join(home, ".local/bin/claude"), "local-bin"],
+    [join(home, ".npm-global/bin/claude"), "npm-global"],
+    [join(home, ".yarn/bin/claude"), "yarn"],
+    [join(home, ".bun/bin/claude"), "bun"],
+    [join(home, "bin/claude"), "home-bin"],
+    [join(home, "node_modules/.bin/claude"), "node-modules"],
+    [join(home, ".config/yarn/global/node_modules/.bin/claude"), "yarn-global"],
+  ];
+
+  for (const [path, source] of pathsToCheck) {
+    if (!path || !existsSync(path)) continue;
+    installations.push({
+      path,
+      version: getClaudeVersion(path),
+      source,
+    });
+  }
+
+  return installations;
+}
+
+/**
+ * Get Claude version by running `<path> --version`.
+ * Extracts semver pattern from output.
+ */
+function getClaudeVersion(binaryPath: string): string | null {
+  try {
+    const result = Bun.spawnSync([binaryPath, "--version"], {
+      stdout: "pipe",
+      stderr: "pipe",
+      timeout: 5000,
+    });
+    if (result.exitCode !== 0) return null;
+    const output = result.stdout.toString();
+    const match = output.match(/(\d+\.\d+\.\d+(?:-[a-zA-Z0-9.-]+)?)/);
+    return match?.[1] ?? null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Compare two semver strings. Returns -1, 0, or 1.
+ */
+function compareVersions(a: string, b: string): number {
+  const pa = a.split(".").map((s) => parseInt(s) || 0);
+  const pb = b.split(".").map((s) => parseInt(s) || 0);
+  const len = Math.max(pa.length, pb.length);
+  for (let i = 0; i < len; i++) {
+    const va = pa[i] ?? 0;
+    const vb = pb[i] ?? 0;
+    if (va > vb) return 1;
+    if (va < vb) return -1;
+  }
+  return 0;
+}
+
+/** Cached binary path — only discovered once per process */
+let cachedBinaryPath: string | null = null;
+
+/**
+ * Find the best Claude CLI binary on the system.
+ * Discovery chain (mirrors opcode):
+ *   1. which claude
+ *   2. NVM paths (active + all versions)
+ *   3. Standard paths (homebrew, system, npm, yarn, bun, etc.)
+ * Selects the installation with the highest version.
+ */
+export function findClaudeBinary(): string {
+  if (cachedBinaryPath) return cachedBinaryPath;
+
+  const installations: ClaudeInstallation[] = [];
+
+  // 1. Try `which` command
+  const whichResult = tryWhichCommand();
+  if (whichResult) installations.push(whichResult);
+
+  // 2. Check NVM paths
+  installations.push(...findNvmInstallations());
+
+  // 3. Check standard paths
+  installations.push(...findStandardInstallations());
+
+  // Deduplicate by path
+  const seen = new Set<string>();
+  const unique = installations.filter((i) => {
+    if (seen.has(i.path)) return false;
+    seen.add(i.path);
+    return true;
+  });
+
+  if (unique.length === 0) {
+    throw new Error(
+      "Claude Code CLI not found. Install via: npm install -g @anthropic-ai/claude-code",
+    );
+  }
+
+  // Select best: highest version, then source preference
+  const best = unique.reduce((a, b) => {
+    if (a.version && b.version) {
+      const cmp = compareVersions(b.version, a.version);
+      if (cmp !== 0) return cmp > 0 ? b : a;
+    } else if (a.version && !b.version) return a;
+    else if (!a.version && b.version) return b;
+    return sourcePreference(a.source) <= sourcePreference(b.source) ? a : b;
+  });
+
+  cachedBinaryPath = best.path;
+  return best.path;
+}
+
+/** Reset cached binary path (for testing) */
+export function resetBinaryCache(): void {
+  cachedBinaryPath = null;
+}
+
+/** Discover all installations (for UI display) */
+export function discoverAllInstallations(): ClaudeInstallation[] {
+  const installations: ClaudeInstallation[] = [];
+  const whichResult = tryWhichCommand();
+  if (whichResult) installations.push(whichResult);
+  installations.push(...findNvmInstallations());
+  installations.push(...findStandardInstallations());
+
+  // Deduplicate and sort by version desc, then source preference
+  const seen = new Set<string>();
+  return installations
+    .filter((i) => {
+      if (seen.has(i.path)) return false;
+      seen.add(i.path);
+      return true;
+    })
+    .sort((a, b) => {
+      if (a.version && b.version) {
+        const cmp = compareVersions(b.version, a.version);
+        if (cmp !== 0) return cmp;
+      } else if (a.version && !b.version) return -1;
+      else if (!a.version && b.version) return 1;
+      return sourcePreference(a.source) - sourcePreference(b.source);
+    });
+}

package/src/providers/claude-code-cli.ts

@@ -0,0 +1,413 @@
+import type {
+  AIProvider,
+  Session,
+  SessionConfig,
+  SessionInfo,
+  ChatEvent,
+  ChatMessage,
+} from "./provider.interface.ts";
+import { findClaudeBinary } from "./claude-binary-finder.ts";
+import { processRegistry } from "./claude-process-registry.ts";
+
+/**
+ * Stream-JSON event types from Claude CLI.
+ * Each line of stdout is one complete JSON object.
+ * Mirrors opcode's line-by-line parsing approach.
+ */
+interface CliSystemEvent {
+  type: "system";
+  subtype: "init" | string;
+  session_id?: string;
+  [key: string]: unknown;
+}
+
+interface CliAssistantEvent {
+  type: "assistant";
+  message: {
+    content: Array<
+      | { type: "text"; text: string }
+      | { type: "tool_use"; name: string; input: unknown; id?: string }
+    >;
+  };
+}
+
+interface CliResultEvent {
+  type: "result";
+  result?: string;
+  session_id?: string;
+  is_error?: boolean;
+}
+
+interface CliToolResultEvent {
+  type: "tool_result";
+  output?: unknown;
+  content?: unknown;
+  is_error?: boolean;
+}
+
+interface CliErrorEvent {
+  type: "error";
+  error?: string;
+  message?: string;
+}
+
+type CliEvent =
+  | CliSystemEvent
+  | CliAssistantEvent
+  | CliResultEvent
+  | CliToolResultEvent
+  | CliErrorEvent
+  | { type: string; [key: string]: unknown };
+
+/**
+ * AI provider that spawns the `claude` CLI as a subprocess.
+ * Architecture mirrors opcode's Rust implementation:
+ *   - Binary discovery chain (claude-binary-finder.ts)
+ *   - Process registry for cancel/kill (claude-process-registry.ts)
+ *   - Line-by-line stream-json parsing (no chunk accumulation)
+ *   - Session ID extraction from init message
+ *   - Continue/resume support via -c and --resume flags
+ */
+export class ClaudeCodeCliProvider implements AIProvider {
+  id = "claude";
+  name = "Claude Code";
+
+  private sessions = new Map<string, Session>();
+  private messageHistory = new Map<string, ChatMessage[]>();
+  /** Maps our session ID → Claude CLI's real session ID (from init message) */
+  private cliSessionIds = new Map<string, string>();
+
+  async createSession(config: SessionConfig): Promise<Session> {
+    const id = crypto.randomUUID();
+    const session: Session = {
+      id,
+      providerId: this.id,
+      title: config.title ?? "New Chat",
+      projectName: config.projectName,
+      createdAt: new Date().toISOString(),
+    };
+    this.sessions.set(id, session);
+    this.messageHistory.set(id, []);
+    return session;
+  }
+
+  async resumeSession(sessionId: string): Promise<Session> {
+    const session = this.sessions.get(sessionId);
+    if (!session) throw new Error(`Session ${sessionId} not found`);
+    return session;
+  }
+
+  async listSessions(): Promise<SessionInfo[]> {
+    return Array.from(this.sessions.values()).map((s) => ({
+      id: s.id,
+      providerId: s.providerId,
+      title: s.title,
+      projectName: s.projectName,
+      createdAt: s.createdAt,
+    }));
+  }
+
+  async deleteSession(sessionId: string): Promise<void> {
+    // Kill running process if any
+    if (processRegistry.isRunning(sessionId)) {
+      await processRegistry.kill(sessionId);
+    }
+    this.sessions.delete(sessionId);
+    this.messageHistory.delete(sessionId);
+    this.cliSessionIds.delete(sessionId);
+  }
+
+  async *sendMessage(
+    sessionId: string,
+    message: string,
+  ): AsyncIterable<ChatEvent> {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      yield { type: "error", message: "Session not found" };
+      return;
+    }
+
+    // Update title from first message
+    if (session.title === "New Chat") {
+      session.title = message.slice(0, 50) + (message.length > 50 ? "..." : "");
+    }
+
+    // Store user message
+    const history = this.messageHistory.get(sessionId) ?? [];
+    history.push({
+      id: crypto.randomUUID(),
+      role: "user",
+      content: message,
+      timestamp: new Date().toISOString(),
+    });
+
+    // Build CLI arguments (mirrors opcode's execute/continue/resume pattern)
+    const args = this.buildCliArgs(sessionId, message);
+
+    // Clean env — remove CLAUDECODE to avoid "nested session" error
+    const env = { ...process.env };
+    delete env.CLAUDECODE;
+
+    // Find binary via discovery chain
+    let binaryPath: string;
+    try {
+      binaryPath = findClaudeBinary();
+    } catch (e) {
+      yield { type: "error", message: (e as Error).message };
+      return;
+    }
+
+    // Spawn process
+    let proc: ReturnType<typeof Bun.spawn>;
+    try {
+      proc = Bun.spawn([binaryPath, ...args], {
+        stdout: "pipe",
+        stderr: "pipe",
+        env,
+      });
+    } catch (e) {
+      yield { type: "error", message: `Failed to spawn claude CLI: ${(e as Error).message}` };
+      return;
+    }
+
+    // Register in process registry (for cancel support)
+    processRegistry.register(sessionId, proc, { prompt: message });
+
+    let assistantContent = "";
+
+    try {
+      // Read stdout line-by-line (mirrors opcode's BufReader::lines())
+      yield* this.readStreamJsonLines(proc, sessionId, (text) => {
+        assistantContent += text;
+      });
+
+      // Check stderr for errors after stdout is done
+      yield* this.readStderrErrors(proc);
+    } catch (e) {
+      yield { type: "error", message: `Stream error: ${(e as Error).message}` };
+    } finally {
+      // Unregister from process registry
+      processRegistry.unregister(sessionId);
+    }
+
+    // Store assistant message
+    history.push({
+      id: crypto.randomUUID(),
+      role: "assistant",
+      content: assistantContent,
+      timestamp: new Date().toISOString(),
+    });
+    this.messageHistory.set(sessionId, history);
+
+    yield { type: "done", sessionId };
+  }
+
+  /** Cancel a running session */
+  async cancelSession(sessionId: string): Promise<boolean> {
+    return processRegistry.kill(sessionId);
+  }
+
+  getMessages(sessionId: string): ChatMessage[] {
+    return this.messageHistory.get(sessionId) ?? [];
+  }
+
+  /**
+   * Build CLI arguments based on session state.
+   * Mirrors opcode's execute_claude_code / continue_claude_code / resume_claude_code.
+   */
+  private buildCliArgs(sessionId: string, message: string): string[] {
+    const cliSessionId = this.cliSessionIds.get(sessionId);
+    const history = this.messageHistory.get(sessionId) ?? [];
+    const userMessageCount = history.filter((m) => m.role === "user").length;
+    const isFirstMessage = userMessageCount <= 1; // Current message already pushed
+
+    const args: string[] = [];
+
+    if (!isFirstMessage && cliSessionId) {
+      // Resume existing CLI session (like opcode's resume_claude_code)
+      args.push("--resume", cliSessionId);
+    } else if (!isFirstMessage) {
+      // Continue most recent session (like opcode's continue_claude_code)
+      args.push("-c");
+    }
+
+    args.push(
+      "-p", message,
+      "--output-format", "stream-json",
+      "--verbose",
+    );
+
+    return args;
+  }
+
+  /**
+   * Read stdout line-by-line and yield ChatEvents.
+   * Each line is a complete JSON object — no chunk accumulation needed.
+   * Mirrors opcode's spawn_claude_process stdout_task.
+   */
+  private async *readStreamJsonLines(
+    proc: ReturnType<typeof Bun.spawn>,
+    sessionId: string,
+    onText: (text: string) => void,
+  ): AsyncGenerator<ChatEvent> {
+    const stdout = proc.stdout as ReadableStream<Uint8Array> | undefined;
+    if (!stdout) {
+      yield { type: "error", message: "Failed to get stdout from claude CLI" };
+      return;
+    }
+
+    const reader = stdout.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      buffer += decoder.decode(value, { stream: true });
+
+      // Split into complete lines
+      const lines = buffer.split("\n");
+      // Keep last partial line in buffer
+      buffer = lines.pop() ?? "";
+
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+
+        // Parse JSON — each line is one complete event
+        let event: CliEvent;
+        try {
+          event = JSON.parse(trimmed) as CliEvent;
+        } catch {
+          continue; // Skip non-JSON lines (e.g. progress indicators)
+        }
+
+        // Process the event — may yield multiple ChatEvents per CLI event
+        for (const chatEvent of this.mapCliEvent(event, sessionId, onText)) {
+          yield chatEvent;
+        }
+      }
+    }
+
+    // Process remaining buffer (last line without trailing newline)
+    if (buffer.trim()) {
+      try {
+        const event = JSON.parse(buffer.trim()) as CliEvent;
+        for (const chatEvent of this.mapCliEvent(event, sessionId, onText)) {
+          yield chatEvent;
+        }
+      } catch {
+        // Ignore incomplete trailing data
+      }
+    }
+  }
+
+  /** Read stderr and yield error events */
+  private async *readStderrErrors(
+    proc: ReturnType<typeof Bun.spawn>,
+  ): AsyncGenerator<ChatEvent> {
+    const stderr = proc.stderr as ReadableStream<Uint8Array> | undefined;
+    if (!stderr) return;
+
+    try {
+      const reader = stderr.getReader();
+      const decoder = new TextDecoder();
+      let stderrContent = "";
+
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        stderrContent += decoder.decode(value, { stream: true });
+      }
+
+      // Only yield if there's meaningful stderr content
+      const trimmed = stderrContent.trim();
+      if (trimmed && !trimmed.includes("ExperimentalWarning")) {
+        yield { type: "error", message: trimmed };
+      }
+    } catch {
+      // Stderr read failure is non-fatal
+    }
+  }
+
+  /**
+   * Map a single CLI stream-json event to a ChatEvent.
+   * Mirrors opcode's event handling in stdout_task.
+   *
+   * CLI output format (one JSON per line):
+   *   {type:"system", subtype:"init", session_id:"..."} — extract session ID
+   *   {type:"assistant", message:{content:[...]}} — text and tool_use blocks
+   *   {type:"result", result:"...", session_id:"..."} — final result (ignored to avoid duplication)
+   *   {type:"tool_result", output:"..."} — tool execution result
+   *   {type:"error", error:"..."} — error event
+   *   {type:"rate_limit_event"} — ignored
+   */
+  /**
+   * Map a single CLI stream-json event to ChatEvent(s).
+   * Returns an array because one `assistant` event can contain
+   * multiple content blocks (text + tool_use interleaved).
+   */
+  private mapCliEvent(
+    event: CliEvent,
+    sessionId: string,
+    onText: (text: string) => void,
+  ): ChatEvent[] {
+    switch (event.type) {
+      case "system": {
+        const sysEvent = event as CliSystemEvent;
+        if (sysEvent.subtype === "init" && sysEvent.session_id) {
+          this.cliSessionIds.set(sessionId, sysEvent.session_id);
+        }
+        return [];
+      }
+
+      case "assistant": {
+        const assistantEvent = event as CliAssistantEvent;
+        const content = assistantEvent.message?.content;
+        if (!Array.isArray(content)) return [];
+
+        // Yield ALL blocks in order — text and tool_use interleaved
+        const events: ChatEvent[] = [];
+        for (const block of content) {
+          if (block.type === "text" && typeof block.text === "string") {
+            onText(block.text);
+            events.push({ type: "text", content: block.text });
+          } else if (block.type === "tool_use") {
+            events.push({
+              type: "tool_use",
+              tool: block.name ?? "unknown",
+              input: block.input ?? {},
+              toolUseId: block.id as string | undefined,
+            });
+          }
+        }
+        return events;
+      }
+
+      case "result":
+        return [];
+
+      case "tool_result": {
+        const trEvent = event as CliToolResultEvent;
+        const output = trEvent.output ?? trEvent.content ?? "";
+        return [{
+          type: "tool_result",
+          output: typeof output === "string" ? output : JSON.stringify(output),
+          isError: !!trEvent.is_error,
+        }];
+      }
+
+      case "error": {
+        const errEvent = event as CliErrorEvent;
+        return [{
+          type: "error",
+          message: errEvent.error ?? errEvent.message ?? "Unknown CLI error",
+        }];
+      }
+
+      default:
+        return [];
+    }
+  }
+}