@midhunxavier/code-flow 0.0.0-stage → 0.1.0-preview.3

package/src/adapters/claude-stream.js

@@ -0,0 +1,58 @@
+class ClaudeStream {
+  constructor(emit) {
+    this.emit = emit;
+  }
+  messageId = "";
+  blocks = /* @__PURE__ */ new Map();
+  lastText = "";
+  partial(event) {
+    if (event?.type === "message_start") {
+      this.messageId = event.message?.id ?? "";
+      this.blocks.clear();
+      return;
+    }
+    if (!this.messageId || !Number.isInteger(event?.index)) return;
+    const messageId = `${this.messageId}:${event.index}`;
+    if (event.type === "content_block_start") {
+      const block = event.content_block;
+      if (!block) return;
+      this.blocks.set(event.index, { type: block.type, id: block.id, name: block.name, input: "", text: block.text ?? "" });
+      if (block.type === "text") this.emit({ kind: "text", messageId, text: block.text ?? "" });
+      if (block.type === "thinking") this.emit({ kind: "thinking", messageId, text: block.thinking ?? "" });
+      if (block.type === "tool_use") this.emit({ kind: "tool_call", callId: block.id, name: block.name, input: JSON.stringify(block.input ?? {}) });
+    } else if (event.type === "content_block_delta") {
+      const block = this.blocks.get(event.index);
+      const delta = event.delta;
+      if (delta?.type === "text_delta") {
+        if (block) {
+          block.text += delta.text;
+          this.lastText = [...this.blocks.values()].filter((b) => b.type === "text").map((b) => b.text).join("\n\n");
+        }
+        this.emit({ kind: "text", messageId, text: delta.text, delta: true });
+      }
+      if (delta?.type === "thinking_delta") this.emit({ kind: "thinking", messageId, text: delta.thinking, delta: true });
+      if (delta?.type === "input_json_delta" && block?.id && block.name) {
+        block.input = (block.input + delta.partial_json).slice(0, 32e3);
+      }
+    }
+  }
+  complete(message) {
+    const content = Array.isArray(message?.content) ? message.content : [];
+    const texts = [];
+    for (const [index, block] of content.entries()) {
+      const messageId = message.id ? `${message.id}:${index}` : void 0;
+      if (block.type === "text" && typeof block.text === "string") {
+        texts.push(block.text);
+        this.emit({ kind: "text", text: block.text, ...messageId ? { messageId } : {} });
+      } else if (block.type === "thinking" && typeof block.thinking === "string") {
+        this.emit({ kind: "thinking", text: block.thinking, ...messageId ? { messageId } : {} });
+      } else if (block.type === "tool_use") {
+        this.emit({ kind: "tool_call", callId: block.id, name: block.name, input: JSON.stringify(block.input ?? {}).slice(0, 32e3) });
+      }
+    }
+    if (texts.length) this.lastText = texts.join("\n\n");
+  }
+}
+export {
+  ClaudeStream
+};

package/src/adapters/claude.js

@@ -0,0 +1,282 @@
+import { discoverModels } from "./model-discovery.js";
+import { managedPermissionProblem } from "./managed-permissions.js";
+import { prepareAgentTools } from "./agent-tools.js";
+import { AGENT_TOOL_ALLOWLIST } from "../agent-tools.js";
+import { ClaudeStream } from "./claude-stream.js";
+import { classifyError, cliErrorLine, resetFromText } from "./errors.js";
+import { commandExists, describeFailure, processErrorKind, startJsonlProcess, stderrTail, stringify, truncate, unknownEvents } from "./process.js";
+import { adapterTeamCapabilities, prepareTeamTools, TEAM_NESTED_DENYLIST, TEAM_TOOL_ALLOWLIST } from "./team-tools.js";
+const READ_TOOLS = [
+  "Read",
+  "Grep",
+  "Glob",
+  "Bash(git diff *)",
+  "Bash(git log *)",
+  "Bash(git show *)",
+  "Bash(git status *)",
+  "Bash(ls *)"
+];
+const GIT_READ_DENY = ["Bash(git *--out*)", "Bash(git *--no-index*)"];
+const IGNORED_TYPES = /* @__PURE__ */ new Set(["stream_event", "tool_progress", "tool_use_summary", "auth_status", "keep_alive", "control_request", "control_response", "control_cancel_request"]);
+const IGNORED_BLOCKS = /* @__PURE__ */ new Set(["redacted_thinking"]);
+const DEFAULT_WRITE_TOOLS = [
+  ...READ_TOOLS,
+  "Bash(git add *)",
+  "Bash(npm *)",
+  "Bash(npx *)",
+  "Bash(node *)",
+  "Bash(pnpm *)",
+  "Bash(yarn *)",
+  "Bash(python3 *)",
+  "Bash(pytest *)",
+  "Bash(uv *)",
+  "Bash(poetry *)",
+  "Bash(cargo *)",
+  "Bash(go *)",
+  "Bash(make *)",
+  "Bash(mkdir *)"
+];
+function writeTools(trust = "standard") {
+  if (trust === "safe") return READ_TOOLS;
+  if (trust === "trusted") return [...READ_TOOLS, "Bash"];
+  const env = process.env.CODEFLOW_CLAUDE_WRITE_TOOLS;
+  return env ? env.split(",").map((t) => t.trim()).filter(Boolean) : DEFAULT_WRITE_TOOLS;
+}
+const claudeAdapter = {
+  id: "claude",
+  discoverModels: (context) => discoverModels("claude", context),
+  displayName: "Claude Code",
+  binary: "claude",
+  available: () => commandExists("claude"),
+  // The CLI has no model-listing command; it accepts these aliases (always the latest
+  // model of each family) or any full model name.
+  async catalog() {
+    return {
+      models: [
+        { id: "fable", label: "Fable (latest)" },
+        { id: "opus", label: "Opus (latest)" },
+        { id: "sonnet", label: "Sonnet (latest)" },
+        { id: "haiku", label: "Haiku (latest)" }
+      ],
+      efforts: ["low", "medium", "high", "xhigh", "max"],
+      allowCustom: true
+    };
+  },
+  async run(opts, onEvent) {
+    const permissionProblem = await managedPermissionProblem("claude", opts);
+    if (permissionProblem) return permissionProblem;
+    const supportsTools = !opts.agentContainer && opts.teamTools && (await adapterTeamCapabilities("claude")).scopedTools === "tested";
+    const teamTools = supportsTools ? await prepareTeamTools(opts.teamTools) : void 0;
+    const agentTools = opts.agentTools && !opts.agentContainer && opts.permissions?.externalTools !== "disabled" ? await prepareAgentTools(opts.agentTools) : void 0;
+    if (opts.agentContainer) onEvent({ kind: "status", text: `Claude runs in Docker image ${opts.agentContainer.image}. Live team tools are unavailable in containers; use structured outcomes and next-turn replies.` });
+    else if (opts.teamTools && !teamTools) onEvent({ kind: "status", text: "This Claude CLI has no verified per-turn team tools; use structured outcomes and next-turn replies." });
+    try {
+      const interactive = !!(opts.conversation || opts.interactiveApprovals || opts.onQuestion);
+      const args = ["-p", "--output-format", "stream-json", "--verbose", "--include-partial-messages"];
+      if (interactive) args.push("--input-format", "stream-json", "--permission-prompt-tool", "stdio");
+      if (opts.permissions && !opts.conversation) args.push("--settings", '{"ultracode":false,"disableWorkflows":true,"disableAllHooks":true}');
+      if (opts.resumeSessionId) args.push("--resume", opts.resumeSessionId);
+      else if (opts.forkSessionId) args.push("--resume", opts.forkSessionId, "--fork-session");
+      if (opts.model) args.push("--model", opts.model);
+      if (opts.effort) args.push("--effort", opts.effort);
+      if (opts.jsonSchema) args.push("--json-schema", JSON.stringify(opts.jsonSchema));
+      if (teamTools) args.push("--mcp-config", teamTools.claudeConfig, "--strict-mcp-config");
+      else if (opts.permissions?.externalTools === "disabled") args.push("--mcp-config", '{"mcpServers":{}}', "--strict-mcp-config");
+      if (agentTools) args.push("--mcp-config", agentTools.claudeConfig);
+      if (opts.permissions?.externalTools === "disabled") args.push("--no-chrome");
+      const collaborationTools = [...teamTools ? TEAM_TOOL_ALLOWLIST : [], ...agentTools ? AGENT_TOOL_ALLOWLIST : []];
+      const full = opts.mode === "write" && opts.trust === "full";
+      const allowedTools = full ? [] : [...opts.mode === "write" ? writeTools(opts.trust) : READ_TOOLS, ...collaborationTools];
+      const limitedShell = !full && !allowedTools.includes("Bash");
+      const deniedTools = [...opts.mode === "read" ? ["Edit", "Write", "NotebookEdit"] : [], ...opts.questionProtocol === "structured" || opts.permissions?.nativeDelegation === false ? TEAM_NESTED_DENYLIST : [], ...opts.permissions?.externalTools === "disabled" ? ["WebSearch", "WebFetch"] : []];
+      const denied = [deniedTools.join(","), limitedShell ? GIT_READ_DENY.join(",") : ""].filter(Boolean);
+      if (denied.length) args.push("--disallowedTools", ...denied);
+      if (full) args.push("--permission-mode", "bypassPermissions");
+      else args.push("--permission-mode", opts.mode === "write" ? "acceptEdits" : "default", "--allowedTools", allowedTools.join(","));
+      let sessionId;
+      let finalText = "";
+      let lastAssistantText = "";
+      let resultError;
+      let sawResult = false;
+      let structured;
+      let rejected;
+      const unknown = unknownEvents("claude");
+      const stream = new ClaudeStream(onEvent);
+      const controls = /* @__PURE__ */ new Map();
+      const cancelControls = () => {
+        for (const controller of controls.values()) controller.abort();
+      };
+      opts.signal?.addEventListener("abort", cancelControls, { once: true });
+      const handleControl = async (msg) => {
+        const id = msg.request_id;
+        if (typeof id !== "string" || controls.has(id)) return;
+        const controller = new AbortController();
+        controls.set(id, controller);
+        const request = msg.request ?? {};
+        const isQuestion = request.tool_name === "AskUserQuestion";
+        const timer = setTimeout(() => controller.abort(), isQuestion ? 6e5 : 12e4);
+        let response = { behavior: "deny", message: "This action was not approved. Ask the user in your response if you need help." };
+        proc.pauseIdle(true);
+        try {
+          if (sawResult || opts.signal?.aborted) return;
+          const work = async () => {
+            if (request.subtype !== "can_use_tool") return;
+            const input = request.input ?? {};
+            if (isQuestion && opts.onQuestion && Array.isArray(input.questions)) {
+              const questions = input.questions.map((q, index) => ({ id: String(index), question: q.question, options: q.options?.map((o) => o.label) }));
+              const answers = await opts.onQuestion(questions, controller.signal);
+              if (answers) response = { behavior: "allow", updatedInput: { ...input, answers: Object.fromEntries(questions.map((q) => [q.question, answers[q.id]])) } };
+            } else if (opts.interactiveApprovals && opts.onApproval && typeof request.tool_name === "string") {
+              if (opts.mode === "read") return;
+              const encoded = JSON.stringify(input);
+              if (encoded.length > 16e3) return;
+              const decision = await opts.onApproval({ id, kind: "tool", toolName: request.tool_name, input: encoded, cwd: opts.cwd }, controller.signal);
+              if (decision === "approve") response = { behavior: "allow", updatedInput: input };
+            }
+          };
+          await Promise.race([work(), new Promise((resolve) => controller.signal.addEventListener("abort", () => resolve(), { once: true }))]);
+          if (!sawResult && !opts.signal?.aborted) proc.send({ type: "control_response", response: { subtype: "success", request_id: id, response: controller.signal.aborted ? { behavior: "deny", message: "Request expired or was cancelled" } : response } });
+        } catch (error2) {
+          if (!sawResult) proc.send({ type: "control_response", response: { subtype: "error", request_id: id, error: String(error2) } });
+        } finally {
+          clearTimeout(timer);
+          controller.abort();
+          controls.delete(id);
+          proc.pauseIdle(controls.size > 0);
+        }
+      };
+      const proc = startJsonlProcess({
+        agentContainer: opts.agentContainer ? { config: opts.agentContainer, mode: opts.mode } : void 0,
+        command: "claude",
+        args,
+        input: interactive ? void 0 : opts.prompt,
+        interactive,
+        cwd: opts.cwd,
+        signal: opts.signal,
+        timeoutMs: opts.timeoutMs,
+        idleTimeoutMs: opts.idleTimeoutMs,
+        isPaused: opts.isPaused,
+        onText: (line) => onEvent({ kind: "status", text: line }),
+        onJson: (msg) => {
+          switch (msg.type) {
+            case "stream_event":
+              stream.partial(msg.event);
+              break;
+            case "control_request":
+              void handleControl(msg);
+              break;
+            case "control_cancel_request":
+              controls.get(msg.request_id)?.abort();
+              break;
+            case "system":
+              if (msg.subtype === "init" && msg.session_id) {
+                sessionId = msg.session_id;
+                onEvent({ kind: "session", sessionId: msg.session_id });
+              }
+              break;
+            case "assistant":
+              stream.complete(msg.message);
+              lastAssistantText = stream.lastText;
+              for (const block of msg.message?.content ?? []) {
+                if (!["text", "thinking", "tool_use"].includes(block.type) && !IGNORED_BLOCKS.has(block.type)) {
+                  unknown.add(`${block.type} block`);
+                }
+              }
+              break;
+            case "user":
+              for (const block of msg.message?.content ?? []) {
+                if (block.type !== "tool_result") continue;
+                const output = Array.isArray(block.content) ? block.content.map((c) => c.type === "text" ? c.text : `[${c.type}]`).join("\n") : stringify(block.content ?? "");
+                onEvent({
+                  kind: "tool_result",
+                  callId: block.tool_use_id,
+                  output: truncate(output),
+                  isError: Boolean(block.is_error)
+                });
+              }
+              break;
+            case "rate_limit_event": {
+              const info = msg.rate_limit_info ?? {};
+              const windows = {};
+              for (const [name, w] of Object.entries(info.unifiedWindows ?? {})) {
+                windows[name] = { utilization: w?.utilization, resetsAt: w?.resetsAt ? w.resetsAt * 1e3 : void 0 };
+              }
+              if (!Object.keys(windows).length && (info.utilization !== void 0 || info.resetsAt)) {
+                windows[info.rateLimitType ?? "limit"] = { utilization: info.utilization, resetsAt: info.resetsAt ? info.resetsAt * 1e3 : void 0 };
+              }
+              onEvent({ kind: "quota", status: info.status ?? "unknown", windows });
+              if (info.status && info.status !== "allowed") onEvent({ kind: "status", text: `Claude rate limit: ${info.status}` });
+              if (info.status === "rejected") {
+                const full2 = Object.values(windows).filter((w) => (w.utilization ?? 0) >= 1 && w.resetsAt).map((w) => w.resetsAt);
+                rejected = { resetsAt: info.resetsAt ? info.resetsAt * 1e3 : full2.length ? Math.max(...full2) : void 0 };
+              }
+              break;
+            }
+            case "result":
+              sawResult = true;
+              cancelControls();
+              if (interactive) proc.endInput();
+              proc.resultSeen();
+              finalText = typeof msg.result === "string" ? msg.result : lastAssistantText;
+              if (msg.session_id) sessionId = msg.session_id;
+              if (msg.structured_output !== void 0) structured = msg.structured_output;
+              if (msg.is_error || /^error/.test(msg.subtype ?? "")) resultError = resultErrorText(msg);
+              onEvent({
+                kind: "usage",
+                // Writing to the prompt cache is billed as input; reading from it is counted apart.
+                inputTokens: (msg.usage?.input_tokens ?? 0) + (msg.usage?.cache_creation_input_tokens ?? 0),
+                outputTokens: msg.usage?.output_tokens,
+                cacheReadTokens: msg.usage?.cache_read_input_tokens,
+                costUsd: msg.total_cost_usd
+              });
+              if (Array.isArray(msg.permission_denials) && msg.permission_denials.length) {
+                const names = msg.permission_denials.map((d) => d.tool_name).join(", ");
+                onEvent({ kind: "status", text: `Denied in headless mode: ${names}` });
+              }
+              break;
+            default:
+              if (!IGNORED_TYPES.has(msg.type)) unknown.add(msg.type);
+          }
+        }
+      });
+      if (interactive) {
+        proc.send({ type: "control_request", request_id: "codeflow-init", request: { subtype: "initialize", hooks: {} } });
+        proc.send({ type: "user", message: { role: "user", content: opts.prompt } });
+      }
+      const outcome = await proc.outcome;
+      cancelControls();
+      opts.signal?.removeEventListener("abort", cancelControls);
+      const drift = unknown.report();
+      if (drift) onEvent({ kind: "status", text: drift });
+      if (sawResult && !resultError && !outcome.aborted) return { ok: true, finalText, sessionId, structured };
+      const tail = stderrTail(outcome);
+      const error = resultError ? `${resultError}${tail && !resultError.includes(tail) ? `
+${tail}` : ""}` : !sawResult && outcome.exitCode === 0 ? `claude exited without a result${tail ? `: ${tail}` : ""}` : describeFailure("claude", outcome);
+      const own = resultError ?? cliErrorLine(outcome.stderr);
+      let errorKind = processErrorKind(outcome) ?? classifyError(own);
+      if (rejected && (errorKind === "other" || errorKind === "rate_limit")) errorKind = "usage_limit";
+      const resetsAt = errorKind === "usage_limit" ? rejected?.resetsAt ?? resetFromText(own) : void 0;
+      onEvent({ kind: "error", message: error });
+      return {
+        ok: false,
+        finalText: finalText || stream.lastText || lastAssistantText,
+        sessionId: errorKind === "session_not_found" ? void 0 : sessionId,
+        error,
+        errorKind,
+        ...resetsAt && { resetsAt }
+      };
+    } finally {
+      await teamTools?.cleanup();
+      await agentTools?.cleanup();
+    }
+  }
+};
+function resultErrorText(msg) {
+  if (msg.is_error && typeof msg.result === "string" && msg.result.trim()) return msg.result.trim();
+  const errors = Array.isArray(msg.errors) ? msg.errors.filter((e) => typeof e === "string" && e).join("; ") : "";
+  const what = msg.subtype === "error_max_turns" ? "Claude stopped at its turn limit" : msg.subtype === "error_max_budget_usd" ? "Claude stopped at its budget limit" : msg.subtype === "error_during_execution" ? "Claude stopped with an error during execution" : `Claude reported an error${msg.subtype && msg.subtype !== "success" ? ` (${msg.subtype})` : ""}`;
+  return errors ? `${what}: ${errors}` : what;
+}
+export {
+  claudeAdapter
+};