@a-company/paradigm 5.10.0 → 5.21.0

package/dist/claude-FRRWJSTJ.js

@@ -1,362 +0,0 @@
-#!/usr/bin/env node
-import {
-  MODEL_PRICING
-} from "./chunk-5JGJACDU.js";
-import "./chunk-PDX44BCA.js";
-
-// src/core/providers/claude.ts
-var MODEL_IDS = {
-  opus: "claude-opus-4-5-20251101",
-  sonnet: "claude-sonnet-4-20250514",
-  haiku: "claude-haiku-4-20250514"
-};
-var ClaudeAgentProvider = class {
-  name = "claude";
-  apiKey = null;
-  baseUrl = "https://api.anthropic.com/v1";
-  constructor() {
-    this.apiKey = process.env.ANTHROPIC_API_KEY || null;
-  }
-  listModels() {
-    return ["opus", "sonnet", "haiku"];
-  }
-  supportsParallel() {
-    return true;
-  }
-  supportsMcp() {
-    return true;
-  }
-  getTokenCost(model) {
-    return MODEL_PRICING[model];
-  }
-  async isAvailable() {
-    return !!this.apiKey;
-  }
-  /**
-   * Spawn an agent and return streaming messages
-   */
-  async *spawn(agent, options) {
-    if (!this.apiKey) {
-      yield {
-        type: "error",
-        content: "ANTHROPIC_API_KEY not set",
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      };
-      return;
-    }
-    const model = options.model || "sonnet";
-    const modelId = MODEL_IDS[model];
-    const systemPrompt = this.buildSystemPrompt(agent, options);
-    const messages = [
-      { role: "user", content: options.task }
-    ];
-    let totalUsage = { input: 0, output: 0, total: 0 };
-    let continueLoop = true;
-    let loopCount = 0;
-    const maxLoops = 50;
-    while (continueLoop && loopCount < maxLoops) {
-      loopCount++;
-      try {
-        const response = await this.streamRequest(modelId, systemPrompt, messages, options);
-        let assistantContent = [];
-        let currentToolUse = null;
-        for await (const event of response) {
-          if (event.type === "content_block_start" && event.content_block) {
-            if (event.content_block.type === "tool_use") {
-              currentToolUse = {
-                id: event.content_block.id || "",
-                name: event.content_block.name || "",
-                input: ""
-              };
-            }
-          } else if (event.type === "content_block_delta" && event.delta) {
-            if (event.delta.type === "text_delta" && event.delta.text) {
-              yield {
-                type: "text",
-                content: event.delta.text,
-                timestamp: (/* @__PURE__ */ new Date()).toISOString()
-              };
-            } else if (event.delta.type === "input_json_delta" && currentToolUse) {
-              currentToolUse.input += event.delta.partial_json || "";
-            }
-          } else if (event.type === "content_block_stop") {
-            if (currentToolUse) {
-              const toolInput = JSON.parse(currentToolUse.input || "{}");
-              assistantContent.push({
-                type: "tool_use",
-                id: currentToolUse.id,
-                name: currentToolUse.name,
-                input: toolInput
-              });
-              yield {
-                type: "tool_use",
-                content: `Using tool: ${currentToolUse.name}`,
-                toolName: currentToolUse.name,
-                toolInput,
-                timestamp: (/* @__PURE__ */ new Date()).toISOString()
-              };
-              currentToolUse = null;
-            }
-          } else if (event.type === "message_delta" && event.usage) {
-            totalUsage.input += event.usage.input_tokens || 0;
-            totalUsage.output += event.usage.output_tokens || 0;
-            totalUsage.total = totalUsage.input + totalUsage.output;
-          } else if (event.type === "message_stop") {
-            const hasToolUse = assistantContent.some((c) => c.type === "tool_use");
-            if (hasToolUse) {
-              messages.push({
-                role: "assistant",
-                content: assistantContent
-              });
-              const toolResults = await this.executeTools(assistantContent, options);
-              messages.push({
-                role: "user",
-                content: toolResults
-              });
-              for (const result of toolResults) {
-                if (result.type === "tool_result") {
-                  yield {
-                    type: "tool_result",
-                    content: typeof result.content === "string" ? result.content : JSON.stringify(result.content),
-                    toolName: result.tool_use_id,
-                    toolResult: result.content,
-                    timestamp: (/* @__PURE__ */ new Date()).toISOString()
-                  };
-                }
-              }
-              assistantContent = [];
-            } else {
-              continueLoop = false;
-            }
-          }
-        }
-        if (options.budget?.maxTokens && totalUsage.total > options.budget.maxTokens) {
-          yield {
-            type: "error",
-            content: `Token budget exceeded: ${totalUsage.total} > ${options.budget.maxTokens}`,
-            usage: totalUsage,
-            timestamp: (/* @__PURE__ */ new Date()).toISOString()
-          };
-          continueLoop = false;
-        }
-      } catch (error) {
-        yield {
-          type: "error",
-          content: error instanceof Error ? error.message : String(error),
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
-        };
-        continueLoop = false;
-      }
-    }
-    yield {
-      type: "done",
-      content: "Agent completed",
-      usage: totalUsage,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    };
-  }
-  // ==========================================================================
-  // Private Methods
-  // ==========================================================================
-  buildSystemPrompt(agent, options) {
-    const parts = [];
-    parts.push(options.context.systemPrompt);
-    parts.push(`
-## Your Role: ${agent.name.toUpperCase()}
-`);
-    parts.push(agent.role);
-    if (agent.focus) {
-      parts.push("\n### Focus Areas\n");
-      if (agent.focus.reads.length > 0) {
-        parts.push(`**Read**: ${agent.focus.reads.join(", ")}`);
-      }
-      if (agent.focus.writes.length > 0) {
-        parts.push(`**Write**: ${agent.focus.writes.join(", ")}`);
-      }
-    }
-    if (options.context.handoffContext) {
-      parts.push("\n### Context from Previous Agent\n");
-      parts.push(options.context.handoffContext);
-    }
-    if (options.context.symbols.length > 0) {
-      parts.push("\n### Symbols in Scope\n");
-      parts.push(options.context.symbols.join(", "));
-    }
-    return parts.join("\n");
-  }
-  async *streamRequest(model, system, messages, options) {
-    const response = await fetch(`${this.baseUrl}/messages`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "x-api-key": this.apiKey,
-        "anthropic-version": "2023-06-01"
-      },
-      body: JSON.stringify({
-        model,
-        max_tokens: options.budget?.maxTokens || 4096,
-        system,
-        messages,
-        stream: true,
-        tools: this.getAvailableTools(options)
-      })
-    });
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`API error: ${response.status} - ${error}`);
-    }
-    if (!response.body) {
-      throw new Error("No response body");
-    }
-    const reader = response.body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = "";
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      buffer += decoder.decode(value, { stream: true });
-      const lines = buffer.split("\n");
-      buffer = lines.pop() || "";
-      for (const line of lines) {
-        if (line.startsWith("data: ")) {
-          const data = line.slice(6).trim();
-          if (data && data !== "[DONE]") {
-            try {
-              yield JSON.parse(data);
-            } catch {
-            }
-          }
-        }
-      }
-    }
-  }
-  getAvailableTools(options) {
-    const tools = [
-      {
-        name: "read_file",
-        description: "Read a file from the filesystem",
-        input_schema: {
-          type: "object",
-          properties: {
-            path: { type: "string", description: "Path to the file" }
-          },
-          required: ["path"]
-        }
-      },
-      {
-        name: "write_file",
-        description: "Write content to a file",
-        input_schema: {
-          type: "object",
-          properties: {
-            path: { type: "string", description: "Path to the file" },
-            content: { type: "string", description: "Content to write" }
-          },
-          required: ["path", "content"]
-        }
-      },
-      {
-        name: "search_files",
-        description: "Search for files matching a pattern",
-        input_schema: {
-          type: "object",
-          properties: {
-            pattern: { type: "string", description: "Glob pattern" },
-            path: { type: "string", description: "Directory to search in" }
-          },
-          required: ["pattern"]
-        }
-      },
-      {
-        name: "run_command",
-        description: "Run a shell command",
-        input_schema: {
-          type: "object",
-          properties: {
-            command: { type: "string", description: "Command to run" },
-            cwd: { type: "string", description: "Working directory" }
-          },
-          required: ["command"]
-        }
-      }
-    ];
-    if (options.mcpServerPath) {
-      tools.push({
-        name: "mcp_call",
-        description: "Call an MCP tool",
-        input_schema: {
-          type: "object",
-          properties: {
-            tool: { type: "string", description: "MCP tool name" },
-            args: { type: "object", description: "Tool arguments" }
-          },
-          required: ["tool"]
-        }
-      });
-    }
-    return tools;
-  }
-  async executeTools(content, options) {
-    const results = [];
-    for (const block of content) {
-      if (block.type === "tool_use" && block.id && block.name) {
-        let result;
-        try {
-          result = await this.executeTool(block.name, block.input || {}, options);
-        } catch (error) {
-          result = `Error: ${error instanceof Error ? error.message : String(error)}`;
-        }
-        results.push({
-          type: "tool_result",
-          tool_use_id: block.id,
-          content: result
-        });
-      }
-    }
-    return results;
-  }
-  async executeTool(name, input, options) {
-    const cwd = options.workingDirectory || process.cwd();
-    const { execSync } = await import("child_process");
-    const fs = await import("fs");
-    const path = await import("path");
-    const { glob } = await import("glob");
-    switch (name) {
-      case "read_file": {
-        const filePath = path.resolve(cwd, input.path);
-        return fs.readFileSync(filePath, "utf-8");
-      }
-      case "write_file": {
-        const filePath = path.resolve(cwd, input.path);
-        const dir = path.dirname(filePath);
-        if (!fs.existsSync(dir)) {
-          fs.mkdirSync(dir, { recursive: true });
-        }
-        fs.writeFileSync(filePath, input.content);
-        return `Written to ${filePath}`;
-      }
-      case "search_files": {
-        const searchPath = input.path ? path.resolve(cwd, input.path) : cwd;
-        const files = await glob(input.pattern, { cwd: searchPath });
-        return files.join("\n");
-      }
-      case "run_command": {
-        const cmdCwd = input.cwd ? path.resolve(cwd, input.cwd) : cwd;
-        const output = execSync(input.command, {
-          cwd: cmdCwd,
-          encoding: "utf-8",
-          timeout: options.timeout || 3e4
-        });
-        return output;
-      }
-      case "mcp_call": {
-        return `MCP tool ${input.tool} called with ${JSON.stringify(input.args)}`;
-      }
-      default:
-        return `Unknown tool: ${name}`;
-    }
-  }
-};
-export {
-  ClaudeAgentProvider
-};

package/dist/claude-cli-XJLK2X4L.js

@@ -1,276 +0,0 @@
-#!/usr/bin/env node
-import {
-  MODEL_PRICING
-} from "./chunk-5JGJACDU.js";
-import "./chunk-PDX44BCA.js";
-
-// src/core/providers/claude-cli.ts
-import * as fs from "fs";
-import * as path from "path";
-import { spawn } from "child_process";
-import { EventEmitter } from "events";
-var ClaudeCliProvider = class {
-  name = "claude-cli";
-  claudePath = null;
-  constructor() {
-  }
-  listModels() {
-    return ["opus", "sonnet", "haiku"];
-  }
-  supportsParallel() {
-    return true;
-  }
-  supportsMcp() {
-    return true;
-  }
-  getTokenCost(model) {
-    return MODEL_PRICING[model];
-  }
-  async isAvailable() {
-    try {
-      const { execSync } = await import("child_process");
-      const result = execSync("which claude", { encoding: "utf-8" }).trim();
-      if (result) {
-        this.claudePath = result;
-        return true;
-      }
-    } catch {
-      const paths = [
-        "/usr/local/bin/claude",
-        path.join(process.env.HOME || "", ".local/bin/claude"),
-        path.join(process.env.HOME || "", ".claude/bin/claude")
-      ];
-      for (const p of paths) {
-        if (fs.existsSync(p)) {
-          this.claudePath = p;
-          return true;
-        }
-      }
-    }
-    return false;
-  }
-  /**
-   * Spawn an agent by invoking claude CLI with streaming output
-   */
-  async *spawn(agent, options) {
-    if (!this.claudePath) {
-      yield {
-        type: "error",
-        content: "Claude CLI not found",
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      };
-      return;
-    }
-    const prompt = this.buildPrompt(agent, options);
-    yield {
-      type: "text",
-      content: `Starting ${agent.name} agent via CLI (streaming)...
-`,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    const args = [
-      "--print",
-      // Non-interactive mode
-      "--permission-mode",
-      "acceptEdits",
-      // Auto-accept to avoid prompts
-      "--output-format",
-      "stream-json",
-      // Streaming JSON for real-time output
-      "--no-session-persistence"
-      // Don't persist session (faster startup)
-    ];
-    if (options.model) {
-      args.push("--model", options.model);
-    }
-    if (options.workingDirectory) {
-      args.push("--add-dir", options.workingDirectory);
-    }
-    args.push("-p", prompt.slice(0, 8e3));
-    const messageEmitter = new EventEmitter();
-    let totalUsage = { input: 0, output: 0, total: 0 };
-    let lastError = null;
-    let completed = false;
-    const proc = spawn(this.claudePath, args, {
-      cwd: options.workingDirectory || process.cwd(),
-      env: { ...process.env },
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    let buffer = "";
-    proc.stdout?.on("data", (data) => {
-      buffer += data.toString();
-      const lines = buffer.split("\n");
-      buffer = lines.pop() || "";
-      for (const line of lines) {
-        if (!line.trim()) continue;
-        try {
-          const msg = JSON.parse(line);
-          messageEmitter.emit("message", msg);
-        } catch {
-          messageEmitter.emit("text", line);
-        }
-      }
-    });
-    proc.stderr?.on("data", (data) => {
-      const text = data.toString();
-      if (!text.includes("Error")) {
-        messageEmitter.emit("progress", text);
-      } else {
-        lastError = text;
-      }
-    });
-    proc.on("close", (code) => {
-      completed = true;
-      messageEmitter.emit("done", code);
-    });
-    proc.on("error", (err) => {
-      lastError = err.message;
-      messageEmitter.emit("error", err);
-    });
-    const timeoutMs = options.timeout || 3 * 60 * 1e3;
-    const timeoutHandle = setTimeout(() => {
-      proc.kill();
-      lastError = `Claude CLI timed out after ${timeoutMs / 1e3}s`;
-      messageEmitter.emit("timeout");
-    }, timeoutMs);
-    const messageQueue = [];
-    let resolveNext = null;
-    const pushMessage = (msg) => {
-      if (resolveNext) {
-        resolveNext(msg);
-        resolveNext = null;
-      } else {
-        messageQueue.push(msg);
-      }
-    };
-    messageEmitter.on("message", (msg) => {
-      if (msg.type === "assistant" && msg.message?.content) {
-        for (const content of msg.message.content) {
-          if (content.type === "text" && content.text) {
-            pushMessage({
-              type: "text",
-              content: content.text,
-              timestamp: (/* @__PURE__ */ new Date()).toISOString()
-            });
-          } else if (content.type === "tool_use" && content.name) {
-            pushMessage({
-              type: "tool_use",
-              content: `Using tool: ${content.name}`,
-              toolName: content.name,
-              toolInput: content.input,
-              timestamp: (/* @__PURE__ */ new Date()).toISOString()
-            });
-          }
-        }
-      } else if (msg.type === "result") {
-        if (msg.usage) {
-          totalUsage = {
-            input: msg.usage.input_tokens || 0,
-            output: msg.usage.output_tokens || 0,
-            total: (msg.usage.input_tokens || 0) + (msg.usage.output_tokens || 0)
-          };
-        }
-      }
-    });
-    messageEmitter.on("text", (text) => {
-      pushMessage({
-        type: "text",
-        content: text + "\n",
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      });
-    });
-    messageEmitter.on("progress", (_text) => {
-      pushMessage({
-        type: "text",
-        content: ".",
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      });
-    });
-    messageEmitter.on("done", () => {
-      clearTimeout(timeoutHandle);
-      pushMessage({
-        type: "done",
-        content: "Agent completed",
-        usage: totalUsage,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      });
-    });
-    messageEmitter.on("timeout", () => {
-      pushMessage({
-        type: "error",
-        content: lastError || "Timeout",
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      });
-    });
-    messageEmitter.on("error", (err) => {
-      clearTimeout(timeoutHandle);
-      pushMessage({
-        type: "error",
-        content: err.message,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      });
-    });
-    while (!completed || messageQueue.length > 0) {
-      if (messageQueue.length > 0) {
-        const msg = messageQueue.shift();
-        yield msg;
-        if (msg.type === "done" || msg.type === "error") {
-          break;
-        }
-      } else {
-        const msg = await new Promise((resolve) => {
-          resolveNext = resolve;
-          setTimeout(() => resolve(null), 100);
-        });
-        if (msg) {
-          yield msg;
-          if (msg.type === "done" || msg.type === "error") {
-            break;
-          }
-        }
-      }
-    }
-    if (lastError && !completed) {
-      yield {
-        type: "error",
-        content: lastError,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      };
-    }
-  }
-  // ==========================================================================
-  // Private Methods
-  // ==========================================================================
-  buildPrompt(agent, options) {
-    const parts = [];
-    parts.push(`# ${agent.name.toUpperCase()} Agent`);
-    parts.push("");
-    parts.push("## Role");
-    parts.push(agent.role);
-    parts.push("");
-    parts.push("## Task");
-    parts.push(options.task);
-    parts.push("");
-    if (options.context.systemPrompt) {
-      parts.push("## Context");
-      parts.push(options.context.systemPrompt.slice(0, 3e3));
-      parts.push("");
-    }
-    if (options.context.symbols.length > 0) {
-      parts.push("## Symbols");
-      parts.push(options.context.symbols.join(", "));
-      parts.push("");
-    }
-    if (options.context.handoffContext) {
-      parts.push("## From Previous Agent");
-      parts.push(options.context.handoffContext);
-      parts.push("");
-    }
-    parts.push("## Instructions");
-    parts.push("Complete the task above. Be concise and focused. Keep response under 500 words.");
-    return parts.join("\n");
-  }
-};
-export {
-  ClaudeCliProvider
-};