@fastino-ai/pioneer-cli 0.1.0 → 0.2.0

package/src/agent/LLMClient.ts

@@ -0,0 +1,435 @@
+/**
+ * LLM Client abstraction supporting multiple providers
+ */
+
+import Anthropic from "@anthropic-ai/sdk";
+import OpenAI from "openai";
+import type { Message, LLMResponse, ToolCall, Tool, AgentConfig, TokenUsage } from "./types.js";
+
+export interface LLMClientOptions {
+  provider: "anthropic" | "openai" | "local";
+  model: string;
+  apiKey?: string;
+  baseUrl?: string;
+}
+
+export class LLMClient {
+  private provider: "anthropic" | "openai" | "local";
+  private model: string;
+  private anthropic?: Anthropic;
+  private openai?: OpenAI;
+
+  constructor(options: LLMClientOptions) {
+    this.provider = options.provider;
+    this.model = options.model;
+
+    if (options.provider === "anthropic") {
+      this.anthropic = new Anthropic({
+        apiKey: options.apiKey || process.env.ANTHROPIC_API_KEY,
+      });
+    } else if (options.provider === "openai") {
+      this.openai = new OpenAI({
+        apiKey: options.apiKey || process.env.OPENAI_API_KEY,
+        baseURL: options.baseUrl,
+      });
+    }
+  }
+
+  getModel(): string {
+    return this.model;
+  }
+
+  setModel(model: string): void {
+    this.model = model;
+  }
+
+  getProvider(): string {
+    return this.provider;
+  }
+
+  async chat(
+    messages: Message[],
+    tools: Tool[],
+    systemPrompt?: string,
+    onStream?: (chunk: string) => void,
+    abortSignal?: AbortSignal
+  ): Promise<LLMResponse> {
+    if (this.provider === "anthropic") {
+      return this.chatAnthropic(messages, tools, systemPrompt, onStream, abortSignal);
+    } else if (this.provider === "openai") {
+      return this.chatOpenAI(messages, tools, systemPrompt, onStream, abortSignal);
+    }
+    throw new Error(`Unsupported provider: ${this.provider}`);
+  }
+
+  private async chatAnthropic(
+    messages: Message[],
+    tools: Tool[],
+    systemPrompt?: string,
+    onStream?: (chunk: string) => void,
+    abortSignal?: AbortSignal
+  ): Promise<LLMResponse> {
+    if (!this.anthropic) throw new Error("Anthropic client not initialized");
+
+    // Check if already aborted
+    if (abortSignal?.aborted) {
+      throw new Error("Aborted");
+    }
+
+    const anthropicMessages = messages
+      .filter((m) => m.role !== "system")
+      .map((m) => this.toAnthropicMessage(m));
+
+    const anthropicTools = tools.map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      input_schema: {
+        type: "object" as const,
+        properties: Object.fromEntries(
+          tool.parameters.map((p) => [
+            p.name,
+            { type: p.type, description: p.description },
+          ])
+        ),
+        required: tool.parameters.filter((p) => p.required).map((p) => p.name),
+      },
+    }));
+
+    if (onStream) {
+      // Streaming response
+      const stream = await this.anthropic.messages.stream({
+        model: this.model,
+        max_tokens: 8192,
+        system: systemPrompt || "You are a helpful AI assistant with access to tools for file system operations, bash execution, and code sandbox.",
+        messages: anthropicMessages,
+        tools: anthropicTools.length > 0 ? anthropicTools : undefined,
+      });
+
+      let content = "";
+      const toolCalls: ToolCall[] = [];
+
+      for await (const event of stream) {
+        // Check abort signal during streaming
+        if (abortSignal?.aborted) {
+          stream.controller.abort();
+          throw new Error("Aborted");
+        }
+
+        if (event.type === "content_block_delta") {
+          if (event.delta.type === "text_delta") {
+            content += event.delta.text;
+            onStream(event.delta.text);
+          } else if (event.delta.type === "input_json_delta") {
+            // Handle tool call streaming
+          }
+        }
+      }
+
+      const finalMessage = await stream.finalMessage();
+
+      // Extract tool calls from final message
+      for (const block of finalMessage.content) {
+        if (block.type === "tool_use") {
+          toolCalls.push({
+            id: block.id,
+            name: block.name,
+            arguments: block.input as Record<string, unknown>,
+          });
+        }
+      }
+
+      return {
+        content,
+        toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+        usage: {
+          inputTokens: finalMessage.usage.input_tokens,
+          outputTokens: finalMessage.usage.output_tokens,
+          totalTokens: finalMessage.usage.input_tokens + finalMessage.usage.output_tokens,
+        },
+        finishReason: finalMessage.stop_reason === "tool_use" ? "tool_calls" : "stop",
+      };
+    } else {
+      // Non-streaming response
+      const response = await this.anthropic.messages.create({
+        model: this.model,
+        max_tokens: 8192,
+        system: systemPrompt || "You are a helpful AI assistant with access to tools for file system operations, bash execution, and code sandbox.",
+        messages: anthropicMessages,
+        tools: anthropicTools.length > 0 ? anthropicTools : undefined,
+      });
+
+      let content = "";
+      const toolCalls: ToolCall[] = [];
+
+      for (const block of response.content) {
+        if (block.type === "text") {
+          content += block.text;
+        } else if (block.type === "tool_use") {
+          toolCalls.push({
+            id: block.id,
+            name: block.name,
+            arguments: block.input as Record<string, unknown>,
+          });
+        }
+      }
+
+      return {
+        content,
+        toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+        usage: {
+          inputTokens: response.usage.input_tokens,
+          outputTokens: response.usage.output_tokens,
+          totalTokens: response.usage.input_tokens + response.usage.output_tokens,
+        },
+        finishReason: response.stop_reason === "tool_use" ? "tool_calls" : "stop",
+      };
+    }
+  }
+
+  private async chatOpenAI(
+    messages: Message[],
+    tools: Tool[],
+    systemPrompt?: string,
+    onStream?: (chunk: string) => void,
+    abortSignal?: AbortSignal
+  ): Promise<LLMResponse> {
+    if (!this.openai) throw new Error("OpenAI client not initialized");
+
+    // Check if already aborted
+    if (abortSignal?.aborted) {
+      throw new Error("Aborted");
+    }
+
+    const openaiMessages: OpenAI.Chat.Completions.ChatCompletionMessageParam[] = [];
+
+    if (systemPrompt) {
+      openaiMessages.push({ role: "system", content: systemPrompt });
+    }
+
+    for (const m of messages) {
+      openaiMessages.push(this.toOpenAIMessage(m));
+    }
+
+    const openaiTools: OpenAI.Chat.Completions.ChatCompletionTool[] = tools.map((tool) => ({
+      type: "function",
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: {
+          type: "object",
+          properties: Object.fromEntries(
+            tool.parameters.map((p) => [
+              p.name,
+              { type: p.type, description: p.description },
+            ])
+          ),
+          required: tool.parameters.filter((p) => p.required).map((p) => p.name),
+        },
+      },
+    }));
+
+    if (onStream) {
+      const stream = await this.openai.chat.completions.create({
+        model: this.model,
+        messages: openaiMessages,
+        tools: openaiTools.length > 0 ? openaiTools : undefined,
+        stream: true,
+      });
+
+      let content = "";
+      const toolCalls: Map<number, { id: string; name: string; arguments: string }> = new Map();
+      let totalInputTokens = 0;
+      let totalOutputTokens = 0;
+
+      for await (const chunk of stream) {
+        // Check abort signal during streaming
+        if (abortSignal?.aborted) {
+          stream.controller.abort();
+          throw new Error("Aborted");
+        }
+
+        const delta = chunk.choices[0]?.delta;
+
+        if (delta?.content) {
+          content += delta.content;
+          onStream(delta.content);
+        }
+
+        if (delta?.tool_calls) {
+          for (const tc of delta.tool_calls) {
+            const existing = toolCalls.get(tc.index) || { id: "", name: "", arguments: "" };
+            if (tc.id) existing.id = tc.id;
+            if (tc.function?.name) existing.name = tc.function.name;
+            if (tc.function?.arguments) existing.arguments += tc.function.arguments;
+            toolCalls.set(tc.index, existing);
+          }
+        }
+
+        if (chunk.usage) {
+          totalInputTokens = chunk.usage.prompt_tokens;
+          totalOutputTokens = chunk.usage.completion_tokens;
+        }
+      }
+
+      const parsedToolCalls: ToolCall[] = [];
+      for (const [_, tc] of toolCalls) {
+        try {
+          parsedToolCalls.push({
+            id: tc.id,
+            name: tc.name,
+            arguments: JSON.parse(tc.arguments || "{}"),
+          });
+        } catch {
+          // Invalid JSON, skip
+        }
+      }
+
+      return {
+        content,
+        toolCalls: parsedToolCalls.length > 0 ? parsedToolCalls : undefined,
+        usage: {
+          inputTokens: totalInputTokens,
+          outputTokens: totalOutputTokens,
+          totalTokens: totalInputTokens + totalOutputTokens,
+        },
+        finishReason: parsedToolCalls.length > 0 ? "tool_calls" : "stop",
+      };
+    } else {
+      const response = await this.openai.chat.completions.create({
+        model: this.model,
+        messages: openaiMessages,
+        tools: openaiTools.length > 0 ? openaiTools : undefined,
+      });
+
+      const choice = response.choices[0];
+      const toolCalls: ToolCall[] = [];
+
+      if (choice.message.tool_calls) {
+        for (const tc of choice.message.tool_calls) {
+          try {
+            toolCalls.push({
+              id: tc.id,
+              name: tc.function.name,
+              arguments: JSON.parse(tc.function.arguments || "{}"),
+            });
+          } catch {
+            // Invalid JSON, skip
+          }
+        }
+      }
+
+      return {
+        content: choice.message.content || "",
+        toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
+        usage: {
+          inputTokens: response.usage?.prompt_tokens || 0,
+          outputTokens: response.usage?.completion_tokens || 0,
+          totalTokens: response.usage?.total_tokens || 0,
+        },
+        finishReason: choice.finish_reason === "tool_calls" ? "tool_calls" : "stop",
+      };
+    }
+  }
+
+  private toAnthropicMessage(message: Message): Anthropic.MessageParam {
+    if (message.role === "tool") {
+      return {
+        role: "user",
+        content: [
+          {
+            type: "tool_result",
+            tool_use_id: message.toolCallId!,
+            content: message.content,
+          },
+        ],
+      };
+    }
+
+    if (message.role === "assistant" && message.toolCalls?.length) {
+      const content: Anthropic.ContentBlockParam[] = [];
+      if (message.content) {
+        content.push({ type: "text", text: message.content });
+      }
+      for (const tc of message.toolCalls) {
+        content.push({
+          type: "tool_use",
+          id: tc.id,
+          name: tc.name,
+          input: tc.arguments,
+        });
+      }
+      return { role: "assistant", content };
+    }
+
+    return {
+      role: message.role as "user" | "assistant",
+      content: message.content,
+    };
+  }
+
+  private toOpenAIMessage(message: Message): OpenAI.Chat.Completions.ChatCompletionMessageParam {
+    if (message.role === "tool") {
+      return {
+        role: "tool",
+        tool_call_id: message.toolCallId!,
+        content: message.content,
+      };
+    }
+
+    if (message.role === "assistant" && message.toolCalls?.length) {
+      return {
+        role: "assistant",
+        content: message.content || null,
+        tool_calls: message.toolCalls.map((tc) => ({
+          id: tc.id,
+          type: "function" as const,
+          function: {
+            name: tc.name,
+            arguments: JSON.stringify(tc.arguments),
+          },
+        })),
+      };
+    }
+
+    return {
+      role: message.role as "user" | "assistant" | "system",
+      content: message.content,
+    };
+  }
+
+  // Cost estimation per 1M tokens (approximate)
+  getCostPerMillion(): { input: number; output: number } {
+    const costs: Record<string, { input: number; output: number }> = {
+      // Claude 4.5 series (newest)
+      "claude-opus-4-5-20251101": { input: 15, output: 75 },
+      "claude-sonnet-4-5-20250929": { input: 3, output: 15 },
+      "claude-haiku-4-5-20251001": { input: 0.8, output: 4 },
+      // Claude 4 series
+      "claude-opus-4-20250514": { input: 15, output: 75 },
+      "claude-sonnet-4-20250514": { input: 3, output: 15 },
+      // Claude 3.5 series
+      "claude-3-5-sonnet-20241022": { input: 3, output: 15 },
+      "claude-3-5-haiku-20241022": { input: 0.8, output: 4 },
+      // Claude 3 series
+      "claude-3-opus-20240229": { input: 15, output: 75 },
+      "claude-3-sonnet-20240229": { input: 3, output: 15 },
+      "claude-3-haiku-20240307": { input: 0.25, output: 1.25 },
+      // OpenAI
+      "gpt-4o": { input: 2.5, output: 10 },
+      "gpt-4o-mini": { input: 0.15, output: 0.6 },
+      "gpt-4-turbo": { input: 10, output: 30 },
+      "gpt-4.1": { input: 2, output: 8 },
+      "gpt-4.1-mini": { input: 0.4, output: 1.6 },
+      "o1": { input: 15, output: 60 },
+      "o1-mini": { input: 1.1, output: 4.4 },
+      "o3-mini": { input: 1.1, output: 4.4 },
+    };
+    return costs[this.model] || { input: 3, output: 15 }; // Default to mid-tier pricing
+  }
+
+  estimateCost(usage: TokenUsage): number {
+    const costs = this.getCostPerMillion();
+    return (usage.inputTokens * costs.input + usage.outputTokens * costs.output) / 1_000_000;
+  }
+}
+

package/src/agent/ToolRegistry.ts

@@ -0,0 +1,97 @@
+/**
+ * Tool Registry - Manages available tools for the agent
+ */
+
+import type { Tool, ToolResult } from "./types.js";
+
+export class ToolRegistry {
+  private tools: Map<string, Tool> = new Map();
+
+  register(tool: Tool): void {
+    this.tools.set(tool.name, tool);
+  }
+
+  unregister(name: string): boolean {
+    return this.tools.delete(name);
+  }
+
+  get(name: string): Tool | undefined {
+    return this.tools.get(name);
+  }
+
+  getAll(): Tool[] {
+    return Array.from(this.tools.values());
+  }
+
+  has(name: string): boolean {
+    return this.tools.has(name);
+  }
+
+  async execute(name: string, args: Record<string, unknown>): Promise<ToolResult> {
+    const tool = this.tools.get(name);
+    if (!tool) {
+      return {
+        toolCallId: "",
+        output: `Unknown tool: ${name}`,
+        success: false,
+        error: `Tool '${name}' not found in registry`,
+      };
+    }
+
+    try {
+      return await tool.execute(args);
+    } catch (error) {
+      return {
+        toolCallId: "",
+        output: "",
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+      };
+    }
+  }
+
+  // Get tool definitions for LLM
+  getToolDefinitions(): Array<{
+    name: string;
+    description: string;
+    parameters: {
+      type: "object";
+      properties: Record<string, { type: string; description: string }>;
+      required: string[];
+    };
+  }> {
+    return this.getAll().map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      parameters: {
+        type: "object" as const,
+        properties: Object.fromEntries(
+          tool.parameters.map((p) => [
+            p.name,
+            { type: p.type, description: p.description },
+          ])
+        ),
+        required: tool.parameters.filter((p) => p.required).map((p) => p.name),
+      },
+    }));
+  }
+
+  listTools(): string {
+    if (this.tools.size === 0) {
+      return "No tools registered.";
+    }
+
+    let output = "Available tools:\n";
+    for (const tool of this.tools.values()) {
+      output += `\n  ${tool.name}: ${tool.description}\n`;
+      if (tool.parameters.length > 0) {
+        for (const param of tool.parameters) {
+          const required = param.required ? " (required)" : "";
+          output += `    - ${param.name}: ${param.type}${required} - ${param.description}\n`;
+        }
+      }
+    }
+    return output;
+  }
+}
+

package/src/agent/index.ts

@@ -0,0 +1,15 @@
+/**
+ * Agent module exports
+ */
+
+export { Agent } from "./Agent.js";
+export type { AgentEvents } from "./Agent.js";
+export { LLMClient } from "./LLMClient.js";
+export type { LLMClientOptions } from "./LLMClient.js";
+export { ToolRegistry } from "./ToolRegistry.js";
+export { BudgetManager } from "./BudgetManager.js";
+export type { BudgetCheckResult } from "./BudgetManager.js";
+export { FileResolver, getFileResolver } from "./FileResolver.js";
+export type { FileReference, ResolvedMessage } from "./FileResolver.js";
+export * from "./types.js";
+

package/src/agent/types.ts

@@ -0,0 +1,84 @@
+/**
+ * Core types for the agent system
+ */
+
+export interface Message {
+  role: "user" | "assistant" | "system" | "tool";
+  content: string;
+  toolCallId?: string;
+  toolCalls?: ToolCall[];
+  timestamp: Date;
+}
+
+export interface ToolCall {
+  id: string;
+  name: string;
+  arguments: Record<string, unknown>;
+}
+
+export interface ToolResult {
+  toolCallId: string;
+  output: string;
+  success: boolean;
+  error?: string;
+}
+
+export interface Tool {
+  name: string;
+  description: string;
+  parameters: ToolParameter[];
+  execute: (args: Record<string, unknown>) => Promise<ToolResult>;
+}
+
+export interface ToolParameter {
+  name: string;
+  type: "string" | "number" | "boolean" | "array" | "object";
+  description: string;
+  required: boolean;
+  default?: unknown;
+}
+
+export interface LLMResponse {
+  content: string;
+  toolCalls?: ToolCall[];
+  usage: TokenUsage;
+  finishReason: "stop" | "tool_calls" | "length" | "error";
+}
+
+export interface TokenUsage {
+  inputTokens: number;
+  outputTokens: number;
+  totalTokens: number;
+}
+
+export interface Budget {
+  maxTokens?: number;
+  maxCost?: number; // in USD
+  maxTime?: number; // in seconds
+  maxIterations?: number;
+}
+
+export interface BudgetUsage {
+  tokensUsed: number;
+  costUsed: number;
+  timeUsed: number;
+  iterationsUsed: number;
+}
+
+export interface AgentConfig {
+  provider: "anthropic" | "openai" | "local";
+  model: string;
+  apiKey?: string;
+  baseUrl?: string;
+  budget?: Budget;
+  systemPrompt?: string;
+  maxToolCalls?: number;
+}
+
+export interface ConversationContext {
+  messages: Message[];
+  budgetUsage: BudgetUsage;
+  startTime: Date;
+  workingDirectory: string;
+}
+