agex 0.1.0

package/dist/chunk-3FGK7LUI.js

@@ -0,0 +1,849 @@
+// ../run/dist/agents/index.js
+import { execa } from "execa";
+
+// ../run/dist/agents/utils.js
+import { spawn } from "child_process";
+
+// ../run/dist/parsers/claude.js
+function createClaudeParser() {
+  const state = {
+    inThinking: false,
+    inTool: false,
+    currentToolId: null,
+    currentMessageId: null,
+    streamedMessageIds: /* @__PURE__ */ new Set()
+  };
+  function processContentBlock(block) {
+    switch (block.type) {
+      case "thinking":
+        if (block.thinking) {
+          return { type: "thinking_delta", text: block.thinking };
+        }
+        break;
+      case "text":
+        if (block.text) {
+          if (state.inTool) {
+            state.inTool = false;
+            state.currentToolId = null;
+          }
+          return { type: "text", text: block.text };
+        }
+        break;
+      case "tool_use":
+        if (block.name && block.id) {
+          state.inTool = true;
+          state.currentToolId = block.id;
+          return {
+            type: "tool_start",
+            name: block.name,
+            args: block.input
+          };
+        }
+        break;
+      case "tool_result":
+        if (block.tool_use_id && state.currentToolId === block.tool_use_id) {
+          state.inTool = false;
+          state.currentToolId = null;
+          return { type: "tool_end", name: "" };
+        }
+        if (state.inTool) {
+          state.inTool = false;
+          state.currentToolId = null;
+          return { type: "tool_end", name: "" };
+        }
+        break;
+    }
+    return null;
+  }
+  return (line) => {
+    if (!line.startsWith("{")) {
+      return null;
+    }
+    let msg;
+    try {
+      msg = JSON.parse(line);
+    } catch {
+      return null;
+    }
+    switch (msg.type) {
+      case "content_block_start": {
+        if (msg.content_block?.type === "thinking") {
+          state.inThinking = true;
+          return { type: "thinking_start" };
+        }
+        return null;
+      }
+      case "content_block_delta": {
+        if (msg.delta?.type === "thinking_delta" && msg.delta.thinking) {
+          return { type: "thinking_delta", text: msg.delta.thinking };
+        }
+        if (msg.delta?.type === "text_delta" && msg.delta.text) {
+          if (state.currentMessageId) {
+            state.streamedMessageIds.add(state.currentMessageId);
+          }
+          return { type: "text", text: msg.delta.text };
+        }
+        return null;
+      }
+      case "content_block_stop": {
+        if (state.inThinking) {
+          state.inThinking = false;
+          return { type: "thinking_end" };
+        }
+        return null;
+      }
+      case "assistant": {
+        const messageId = msg.message?.id;
+        if (messageId) {
+          state.currentMessageId = messageId;
+        }
+        const content = msg.message?.content;
+        if (!content || !Array.isArray(content)) {
+          return null;
+        }
+        if (messageId && state.streamedMessageIds.has(messageId)) {
+          return null;
+        }
+        for (const block of content) {
+          const event = processContentBlock(block);
+          if (event) {
+            return event;
+          }
+        }
+        return null;
+      }
+      case "user": {
+        const content = msg.message?.content;
+        if (!content || !Array.isArray(content)) {
+          return null;
+        }
+        for (const block of content) {
+          if (block.type === "tool_result") {
+            const toolUseId = block.tool_use_id;
+            if (toolUseId && state.currentToolId === toolUseId) {
+              state.inTool = false;
+              state.currentToolId = null;
+              return { type: "tool_end", name: "" };
+            }
+            if (state.inTool) {
+              state.inTool = false;
+              state.currentToolId = null;
+              return { type: "tool_end", name: "" };
+            }
+          }
+        }
+        return null;
+      }
+      case "system": {
+        if (msg.subtype === "init") {
+          return {
+            type: "init",
+            model: msg.model,
+            tools: msg.tools?.length,
+            mcpServers: msg.mcp_servers?.length
+          };
+        }
+        return null;
+      }
+      case "result": {
+        if (state.inTool) {
+          state.inTool = false;
+          state.currentToolId = null;
+          return { type: "tool_end", name: "" };
+        }
+        if (msg.is_error && msg.result) {
+          return { type: "error", message: msg.result };
+        }
+        const usage = msg.usage ? {
+          inputTokens: msg.usage.input_tokens,
+          outputTokens: msg.usage.output_tokens,
+          costUsd: msg.total_cost_usd
+        } : void 0;
+        return { type: "done", durationMs: msg.duration_ms, usage };
+      }
+      case "error": {
+        if (msg.error) {
+          return { type: "error", message: msg.error };
+        }
+        return null;
+      }
+    }
+    return null;
+  };
+}
+
+// ../run/dist/parsers/codex.js
+function createCodexParser() {
+  const state = {
+    inThinking: false,
+    inTool: false,
+    currentToolId: null
+  };
+  return (line) => {
+    if (!line.startsWith("{")) {
+      return null;
+    }
+    let msg;
+    try {
+      msg = JSON.parse(line);
+    } catch {
+      return null;
+    }
+    switch (msg.type) {
+      case "thread.started": {
+        return { type: "session_start", threadId: msg.thread_id };
+      }
+      case "turn.started": {
+        return { type: "turn_start" };
+      }
+      case "item.started": {
+        const itemType = msg.item?.type;
+        if (itemType === "reasoning") {
+          state.inThinking = true;
+          return { type: "thinking_start" };
+        }
+        if (itemType === "mcp_tool_call") {
+          const server = msg.item?.server ?? "";
+          const tool = msg.item?.tool ?? "";
+          const toolName = server ? `${server}:${tool}` : tool;
+          const args = msg.item?.arguments ?? msg.item?.args ?? msg.item?.input;
+          state.inTool = true;
+          state.currentToolId = msg.item?.id ?? null;
+          return { type: "tool_start", name: toolName, args };
+        }
+        if (itemType === "command_execution") {
+          const command = msg.item?.command ?? "";
+          state.inTool = true;
+          state.currentToolId = msg.item?.id ?? null;
+          return { type: "tool_start", name: "shell", args: { command } };
+        }
+        return null;
+      }
+      case "item.delta": {
+        if (msg.item?.type === "reasoning") {
+          const delta = msg.delta ?? msg.item?.delta;
+          if (delta) {
+            return { type: "thinking_delta", text: delta };
+          }
+        }
+        return null;
+      }
+      case "item.completed": {
+        const itemType = msg.item?.type;
+        if (itemType === "mcp_tool_call" || itemType === "command_execution") {
+          if (state.inTool) {
+            state.inTool = false;
+            state.currentToolId = null;
+            return { type: "tool_end", name: "" };
+          }
+        }
+        if (itemType === "agent_message") {
+          const text = msg.item?.text;
+          if (text) {
+            if (state.inTool) {
+              state.inTool = false;
+              state.currentToolId = null;
+            }
+            return { type: "text", text };
+          }
+        }
+        if (itemType === "reasoning") {
+          const text = msg.item?.text;
+          if (state.inThinking) {
+            state.inThinking = false;
+            if (text) {
+              return { type: "thinking_delta", text };
+            }
+            return { type: "thinking_end" };
+          }
+          if (text) {
+            return { type: "thinking_delta", text };
+          }
+        }
+        return null;
+      }
+      case "turn.completed": {
+        const usage = msg.usage ? {
+          inputTokens: msg.usage.input_tokens,
+          outputTokens: msg.usage.output_tokens
+        } : void 0;
+        if (state.inTool) {
+          state.inTool = false;
+          state.currentToolId = null;
+          return { type: "tool_end", name: "" };
+        }
+        return { type: "turn_end", usage };
+      }
+      case "error": {
+        const errorMsg = typeof msg.error === "object" ? msg.error?.message : msg.error ?? msg.message;
+        if (errorMsg) {
+          return { type: "error", message: errorMsg };
+        }
+        return null;
+      }
+    }
+    return null;
+  };
+}
+
+// ../run/dist/parsers/cursor.js
+function extractToolInfo(toolCall) {
+  if (!toolCall)
+    return null;
+  if (toolCall.mcpToolCall) {
+    const toolName = toolCall.mcpToolCall.args?.toolName || toolCall.mcpToolCall.args?.name;
+    if (toolName) {
+      return { name: toolName, args: toolCall.mcpToolCall.args?.args };
+    }
+  }
+  for (const key of Object.keys(toolCall)) {
+    if (key === "mcpToolCall")
+      continue;
+    if (key.endsWith("ToolCall")) {
+      const toolName = key.replace("ToolCall", "");
+      const callData = toolCall[key];
+      return { name: toolName, args: callData?.args };
+    }
+  }
+  return null;
+}
+function createCursorParser() {
+  const state = { inThinking: false, inTool: false };
+  return (line) => {
+    if (!line.startsWith("{")) {
+      return null;
+    }
+    let msg;
+    try {
+      msg = JSON.parse(line);
+    } catch {
+      return null;
+    }
+    switch (msg.type) {
+      case "system": {
+        if (msg.subtype === "init") {
+          return {
+            type: "init",
+            model: msg.model,
+            sessionId: msg.session_id,
+            cwd: msg.cwd
+          };
+        }
+        return null;
+      }
+      case "assistant": {
+        if (!msg.timestamp_ms) {
+          return null;
+        }
+        const text = msg.message?.content?.[0]?.text;
+        if (text) {
+          return { type: "text", text };
+        }
+        return null;
+      }
+      case "thinking": {
+        if (msg.subtype === "delta") {
+          const text = msg.text;
+          if (text) {
+            if (!state.inThinking) {
+              state.inThinking = true;
+              return { type: "thinking_start" };
+            }
+            return { type: "thinking_delta", text };
+          }
+        } else if (msg.subtype === "completed") {
+          if (state.inThinking) {
+            state.inThinking = false;
+            return { type: "thinking_end" };
+          }
+        }
+        return null;
+      }
+      case "tool_call": {
+        if (msg.subtype === "started") {
+          const toolInfo = extractToolInfo(msg.tool_call);
+          if (toolInfo) {
+            state.inTool = true;
+            return { type: "tool_start", name: toolInfo.name, args: toolInfo.args };
+          }
+        } else if (msg.subtype === "completed") {
+          state.inTool = false;
+          return { type: "tool_end", name: "" };
+        }
+        return null;
+      }
+      case "result": {
+        if (state.inTool) {
+          state.inTool = false;
+        }
+        if (msg.is_error && msg.result) {
+          return { type: "error", message: msg.result };
+        }
+        return { type: "done", durationMs: msg.duration_ms };
+      }
+      case "error": {
+        if (msg.error) {
+          return { type: "error", message: msg.error };
+        }
+        return null;
+      }
+    }
+    return null;
+  };
+}
+
+// ../run/dist/parsers/format.js
+function shouldUseColors() {
+  if (process.env.TINO_NO_COLOR === "1")
+    return false;
+  if (process.env.TINO_COLOR === "1")
+    return true;
+  if (process.env.FORCE_COLOR === "1")
+    return true;
+  return true;
+}
+var useColors = shouldUseColors();
+var colors = {
+  reset: useColors ? "\x1B[0m" : "",
+  dim: useColors ? "\x1B[2m" : "",
+  bold: useColors ? "\x1B[1m" : "",
+  cyan: useColors ? "\x1B[36m" : "",
+  green: useColors ? "\x1B[32m" : "",
+  yellow: useColors ? "\x1B[33m" : "",
+  red: useColors ? "\x1B[31m" : "",
+  magenta: useColors ? "\x1B[35m" : ""
+};
+var box = {
+  topLeft: "\u250C",
+  topRight: "\u2510",
+  bottomLeft: "\u2514",
+  bottomRight: "\u2518",
+  horizontal: "\u2500",
+  vertical: "\u2502"
+};
+var MAX_ARG_LENGTH = 180;
+function escapeValue(value) {
+  if (typeof value === "string") {
+    return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\t/g, "\\t")}"`;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  if (value === null) {
+    return "null";
+  }
+  return JSON.stringify(value);
+}
+function formatToolArgs(args) {
+  if (!args || Object.keys(args).length === 0) {
+    return "";
+  }
+  const formatted = Object.entries(args).map(([key, value]) => `${key}=${escapeValue(value)}`).join(" ");
+  if (formatted.length > MAX_ARG_LENGTH) {
+    return formatted.slice(0, MAX_ARG_LENGTH) + "\u2026";
+  }
+  return formatted;
+}
+function formatThinkingStart() {
+  return `
+
+${colors.dim}${box.topLeft}${box.horizontal} \u{1F4AD} thinking ${box.horizontal.repeat(30)}
+${box.vertical} `;
+}
+function formatThinkingContent(text) {
+  return text.replace(/\n/g, `
+${colors.dim}${box.vertical}${colors.reset} `);
+}
+function formatThinkingEnd() {
+  return `
+${box.bottomLeft}${box.horizontal.repeat(41)}${colors.reset}
+
+`;
+}
+function formatToolStart(name, args) {
+  const argsLine = formatToolArgs(args);
+  let output = `
+
+${colors.dim}${box.topLeft}${box.horizontal}${box.horizontal}${colors.reset} ${colors.cyan}${colors.bold}${name}${colors.reset}
+`;
+  if (argsLine) {
+    output += `${colors.dim}${box.vertical}${colors.reset}  ${argsLine}
+`;
+  }
+  output += `${colors.dim}${box.vertical}${colors.reset}  ${colors.yellow}\u23F3 running...${colors.reset}`;
+  return output;
+}
+function formatToolEnd() {
+  return `\r${colors.dim}${box.vertical}${colors.reset}  ${colors.green}\u2713 done${colors.reset}      
+${colors.dim}${box.bottomLeft}${box.horizontal.repeat(30)}${colors.reset}
+
+`;
+}
+function formatText(text) {
+  return text;
+}
+function formatError(message) {
+  return `
+${colors.red}${colors.bold}\u274C ERROR:${colors.reset} ${colors.red}${message}${colors.reset}
+`;
+}
+function createFormatterState() {
+  return {
+    inTool: false,
+    inThinking: false,
+    currentTool: ""
+  };
+}
+
+// ../run/dist/parsers/index.js
+function createParser(agent) {
+  switch (agent) {
+    case "cursor":
+      return createCursorParser();
+    case "claude":
+      return createClaudeParser();
+    case "codex":
+      return createCodexParser();
+  }
+}
+function createStreamFormatter() {
+  const state = createFormatterState();
+  function format(event) {
+    switch (event.type) {
+      case "session_start":
+        return "";
+      case "turn_start":
+        return "";
+      case "turn_end": {
+        let output = "";
+        if (state.inTool) {
+          state.inTool = false;
+          output += ` ${colors.green}\u2713${colors.reset}
+`;
+        }
+        if (event.usage) {
+          output += `
+${colors.dim}tokens: ${event.usage.inputTokens ?? 0} in / ${event.usage.outputTokens ?? 0} out${colors.reset}
+`;
+        }
+        return output;
+      }
+      case "thinking_start":
+        state.inThinking = true;
+        return formatThinkingStart();
+      case "thinking_delta":
+        if (state.inThinking) {
+          return formatThinkingContent(event.text);
+        }
+        state.inThinking = true;
+        return `${formatThinkingStart()}${formatThinkingContent(event.text)}`;
+      case "thinking_end":
+        if (state.inThinking) {
+          state.inThinking = false;
+          return formatThinkingEnd();
+        }
+        return "";
+      case "text":
+        if (state.inTool) {
+          state.inTool = false;
+          return formatToolEnd() + "\n" + formatText(event.text);
+        }
+        if (state.inThinking) {
+          state.inThinking = false;
+          return formatThinkingEnd() + formatText(event.text);
+        }
+        return formatText(event.text);
+      case "tool_start":
+        if (state.inThinking) {
+          state.inThinking = false;
+        }
+        if (state.inTool) {
+          state.inTool = false;
+          return formatToolEnd() + formatToolStart(event.name, event.args);
+        }
+        state.inTool = true;
+        state.currentTool = event.name;
+        return formatToolStart(event.name, event.args);
+      case "tool_end":
+        if (state.inTool) {
+          state.inTool = false;
+          state.currentTool = "";
+          return formatToolEnd();
+        }
+        return "";
+      case "error":
+        return formatError(event.message);
+      case "init":
+        return "";
+      case "done":
+        if (state.inTool) {
+          state.inTool = false;
+          return ` ${colors.green}\u2713${colors.reset}
+`;
+        }
+        return "";
+    }
+  }
+  function flush() {
+    let output = "";
+    if (state.inThinking) {
+      output += formatThinkingEnd();
+      state.inThinking = false;
+    }
+    if (state.inTool) {
+      output += ` ${colors.green}\u2713${colors.reset}
+`;
+      state.inTool = false;
+    }
+    return output;
+  }
+  return { format, flush };
+}
+function createLineProcessor(agent) {
+  const parser = createParser(agent);
+  const formatter = createStreamFormatter();
+  return {
+    processLine: (line) => {
+      const event = parser(line);
+      if (!event) {
+        return "";
+      }
+      return formatter.format(event);
+    },
+    flush: () => formatter.flush()
+  };
+}
+
+// ../run/dist/agents/utils.js
+function buildEnv({ apiKeyEnv, apiKey, request }) {
+  const forceColor = process.stdout.isTTY ? "1" : process.env.FORCE_COLOR ?? "1";
+  return {
+    ...Object.fromEntries(Object.entries(process.env).filter((entry) => entry[1] !== void 0)),
+    ...Object.fromEntries(Object.entries(request.env ?? {}).filter((entry) => entry[1] !== void 0)),
+    ...apiKey ? { [apiKeyEnv]: apiKey } : {},
+    FORCE_COLOR: forceColor
+  };
+}
+function shellEscape(arg) {
+  if (!/[^a-zA-Z0-9_\-=.:\/]/.test(arg)) {
+    return arg;
+  }
+  return `'${arg.replace(/'/g, "'\\''")}'`;
+}
+async function runWithStreaming({ command, args, request, env, runInShell, stdinInput }) {
+  const startedAt = /* @__PURE__ */ new Date();
+  const escapedArgs = runInShell ? args.map(shellEscape) : args;
+  const baseCommand = [command, ...escapedArgs].join(" ");
+  const execCommand = runInShell ? "/bin/bash" : command;
+  const execArgs = runInShell ? ["-lc", baseCommand] : args;
+  const child = spawn(execCommand, execArgs, {
+    cwd: request.cwd,
+    env,
+    stdio: [stdinInput ? "pipe" : "ignore", "pipe", "pipe"]
+  });
+  if (stdinInput && child.stdin) {
+    child.stdin.write(stdinInput);
+    child.stdin.end();
+  }
+  const stdoutChunks = [];
+  const stderrChunks = [];
+  const formattedChunks = [];
+  const shouldFormat = request.streamOutput ?? false;
+  const lineProcessor = shouldFormat ? createLineProcessor(request.agent) : null;
+  let stdoutBuffer = "";
+  const quietOutput = request.quietOutput ?? false;
+  child.stdout?.on("data", (chunk) => {
+    stdoutChunks.push(chunk);
+    if (lineProcessor) {
+      stdoutBuffer += chunk.toString("utf-8");
+      const lines = stdoutBuffer.split("\n");
+      stdoutBuffer = lines.pop() ?? "";
+      for (const line of lines) {
+        const formatted = lineProcessor.processLine(line);
+        if (formatted) {
+          formattedChunks.push(formatted);
+          if (!quietOutput) {
+            process.stdout.write(formatted);
+          }
+        }
+      }
+    } else if (!quietOutput) {
+      process.stdout.write(chunk);
+    }
+  });
+  child.stderr?.on("data", (chunk) => {
+    stderrChunks.push(chunk);
+    if (!quietOutput) {
+      process.stderr.write(chunk);
+    }
+  });
+  const exitCode = await new Promise((resolve) => {
+    child.on("close", (code) => resolve(code ?? 1));
+  });
+  if (lineProcessor) {
+    if (stdoutBuffer) {
+      const formatted = lineProcessor.processLine(stdoutBuffer);
+      if (formatted) {
+        formattedChunks.push(formatted);
+        if (!quietOutput) {
+          process.stdout.write(formatted);
+        }
+      }
+    }
+    const flushed = lineProcessor.flush();
+    if (flushed) {
+      formattedChunks.push(flushed);
+      if (!quietOutput) {
+        process.stdout.write(flushed);
+      }
+    }
+  }
+  const endedAt = /* @__PURE__ */ new Date();
+  return {
+    output: {
+      agent: request.agent,
+      model: request.model,
+      prompt: request.prompt,
+      startedAt: startedAt.toISOString(),
+      endedAt: endedAt.toISOString(),
+      durationMs: endedAt.getTime() - startedAt.getTime(),
+      exitCode,
+      stdout: Buffer.concat(stdoutChunks).toString("utf-8"),
+      stderr: Buffer.concat(stderrChunks).toString("utf-8"),
+      status: exitCode === 0 ? "success" : "failure"
+    },
+    formattedText: formattedChunks.join("")
+  };
+}
+
+// ../run/dist/agents/claude.js
+var claudeAgent = {
+  name: "claude",
+  command: "claude",
+  runInShell: false,
+  args: ({ model, streamOutput, mcpConfigPath }) => {
+    const args = ["-p", "--dangerously-skip-permissions"];
+    if (streamOutput) {
+      args.push("--output-format", "stream-json", "--verbose");
+    } else {
+      args.push("--output-format", "text");
+    }
+    if (mcpConfigPath) {
+      args.push("--mcp-config", mcpConfigPath);
+    }
+    if (model) {
+      args.push("--model", model);
+    }
+    return args;
+  },
+  apiKeyEnv: "ANTHROPIC_API_KEY",
+  installCommand: "npm i -g @anthropic-ai/claude-code"
+};
+async function runClaude(request, args, env) {
+  return runWithStreaming({
+    command: "claude",
+    args,
+    request,
+    env,
+    runInShell: false,
+    stdinInput: request.prompt
+  });
+}
+
+// ../run/dist/agents/codex.js
+var codexAgent = {
+  name: "codex",
+  command: "codex",
+  runInShell: false,
+  args: ({ workspacePath }) => {
+    const args = ["exec", "--full-auto", "--json", "--skip-git-repo-check"];
+    if (workspacePath) {
+      args.push("-C", workspacePath);
+    }
+    return args;
+  },
+  apiKeyEnv: "OPENAI_API_KEY",
+  installCommand: "npm i -g @openai/codex"
+};
+async function runCodex(request, args, env) {
+  return runWithStreaming({
+    command: "codex",
+    args,
+    request,
+    env,
+    runInShell: false,
+    stdinInput: request.prompt
+  });
+}
+
+// ../run/dist/agents/cursor.js
+var cursorAgent = {
+  name: "cursor",
+  command: "cursor",
+  runInShell: true,
+  args: ({ prompt, model, approveMcps, browser, streamOutput, approvalPolicy, workspacePath }) => {
+    const args = ["agent", "--print", "--force"];
+    args.push("--output-format", streamOutput ? "stream-json" : "text");
+    if (streamOutput) {
+      args.push("--stream-partial-output");
+    }
+    if ((approvalPolicy ?? "on-request") !== "never" && approveMcps) {
+      args.push("--approve-mcps");
+    }
+    if (browser) {
+      args.push("--browser");
+    }
+    if (workspacePath) {
+      args.push("--workspace", workspacePath);
+    }
+    if (model) {
+      args.push("--model", model);
+    }
+    args.push(prompt);
+    return args;
+  },
+  apiKeyEnv: "CURSOR_API_KEY",
+  installCommand: "curl https://cursor.com/install -fsS | bash"
+};
+async function runCursor(request, args, env) {
+  return runWithStreaming({
+    command: "cursor",
+    args,
+    request,
+    env,
+    runInShell: true
+  });
+}
+
+// ../run/dist/agents/index.js
+var AGENTS = {
+  cursor: cursorAgent,
+  claude: claudeAgent,
+  codex: codexAgent
+};
+function getAgentConfig(agent) {
+  return AGENTS[agent];
+}
+async function ensureAgentInstalled(agent, command, installCommand) {
+  const config = getAgentConfig(agent);
+  const agentCommand = command ?? config.command;
+  try {
+    await execa("bash", ["-lc", `command -v ${agentCommand}`]);
+  } catch {
+    const commandToRun = installCommand ?? config.installCommand;
+    await execa("bash", ["-lc", commandToRun], { stdio: "inherit" });
+  }
+}
+function getRequiredApiKey(agent) {
+  return getAgentConfig(agent).apiKeyEnv;
+}
+
+export {
+  buildEnv,
+  runClaude,
+  runCodex,
+  runCursor,
+  getAgentConfig,
+  ensureAgentInstalled,
+  getRequiredApiKey
+};