@fastino-ai/pioneer-cli 0.1.0 → 0.2.0

package/src/agent/Agent.ts

@@ -0,0 +1,342 @@
+/**
+ * Agent - Main orchestrator that coordinates tools and LLM calls
+ */
+
+import type {
+  Message,
+  Tool,
+  ToolCall,
+  ToolResult,
+  AgentConfig,
+  ConversationContext,
+  LLMResponse,
+  Budget,
+} from "./types.js";
+import { LLMClient } from "./LLMClient.js";
+import { ToolRegistry } from "./ToolRegistry.js";
+import { BudgetManager } from "./BudgetManager.js";
+import { FileResolver, type FileReference } from "./FileResolver.js";
+
+const DEFAULT_SYSTEM_PROMPT = `You are an intelligent AI assistant with access to powerful tools for coding, file manipulation, and system operations.
+
+Available capabilities:
+- Execute bash commands to interact with the system
+- Read, write, and edit files
+- List and search directories
+- Execute code in isolated sandboxes (Python, JavaScript, TypeScript, Bash, Ruby, Go)
+
+Guidelines:
+1. Be concise but thorough in your responses
+2. When given a task, break it down into steps and execute them
+3. Use tools to verify your work when appropriate
+4. If something fails, analyze the error and try alternative approaches
+5. Ask clarifying questions only when truly necessary
+6. Report your progress and results clearly
+
+You are operating in the user's local environment. Be careful with destructive operations.`;
+
+export interface AgentEvents {
+  onMessage?: (message: Message) => void;
+  onToolCall?: (toolCall: ToolCall) => void;
+  onToolResult?: (result: ToolResult) => void;
+  onStream?: (chunk: string) => void;
+  onBudgetWarning?: (warnings: string[]) => void;
+  onFileReference?: (refs: FileReference[]) => void;
+  onError?: (error: Error) => void;
+}
+
+export class Agent {
+  private llm: LLMClient;
+  private tools: ToolRegistry;
+  private budget: BudgetManager;
+  private config: AgentConfig;
+  private context: ConversationContext;
+  private events: AgentEvents;
+  private fileResolver: FileResolver;
+  private abortController: AbortController | null = null;
+
+  constructor(config: AgentConfig, events: AgentEvents = {}) {
+    this.config = config;
+    this.events = events;
+
+    this.llm = new LLMClient({
+      provider: config.provider,
+      model: config.model,
+      apiKey: config.apiKey,
+      baseUrl: config.baseUrl,
+    });
+
+    this.tools = new ToolRegistry();
+    this.budget = new BudgetManager(
+      config.budget,
+      this.llm.getCostPerMillion()
+    );
+    this.fileResolver = new FileResolver(process.cwd());
+
+    this.context = {
+      messages: [],
+      budgetUsage: this.budget.getUsage(),
+      startTime: new Date(),
+      workingDirectory: process.cwd(),
+    };
+  }
+
+  registerTool(tool: Tool): void {
+    this.tools.register(tool);
+  }
+
+  registerTools(tools: Tool[]): void {
+    for (const tool of tools) {
+      this.tools.register(tool);
+    }
+  }
+
+  getTools(): Tool[] {
+    return this.tools.getAll();
+  }
+
+  async chat(userMessage: string, stream = true): Promise<string> {
+    // Create new abort controller for this chat session
+    this.abortController = new AbortController();
+
+    // Check budget before starting
+    const budgetCheck = this.budget.checkBudget();
+    if (!budgetCheck.withinBudget) {
+      const error = `Budget exhausted: ${budgetCheck.warnings.join(", ")}`;
+      this.events.onError?.(new Error(error));
+      return error;
+    }
+
+    if (budgetCheck.warnings.length > 0) {
+      this.events.onBudgetWarning?.(budgetCheck.warnings);
+    }
+
+    // Resolve @file references in the message
+    const resolved = this.fileResolver.resolve(userMessage);
+
+    // Notify about file references
+    if (resolved.references.length > 0) {
+      this.events.onFileReference?.(resolved.references);
+    }
+
+    // Build the actual message content with file context
+    let messageContent = userMessage;
+    if (resolved.contextBlock) {
+      messageContent = resolved.contextBlock + "\n" + userMessage;
+    }
+
+    // Add user message to context
+    const userMsg: Message = {
+      role: "user",
+      content: messageContent,
+      timestamp: new Date(),
+    };
+    this.context.messages.push(userMsg);
+    this.events.onMessage?.(userMsg);
+
+    // Run the agent loop
+    try {
+      return await this.runAgentLoop(stream);
+    } finally {
+      this.abortController = null;
+    }
+  }
+
+  // Stop the current generation/tool execution
+  stop(): void {
+    if (this.abortController) {
+      this.abortController.abort();
+    }
+  }
+
+  // Check if agent is currently processing
+  isProcessing(): boolean {
+    return this.abortController !== null;
+  }
+
+  private async runAgentLoop(stream: boolean): Promise<string> {
+    const maxToolCalls = this.config.maxToolCalls || 25;
+    let toolCallCount = 0;
+    let finalResponse = "";
+
+    while (toolCallCount < maxToolCalls) {
+      // Check if aborted
+      if (this.abortController?.signal.aborted) {
+        finalResponse += "\n\n[Stopped by user]";
+        break;
+      }
+
+      // Check budget
+      const budgetCheck = this.budget.checkBudget();
+      if (!budgetCheck.withinBudget) {
+        finalResponse += `\n\n[Budget exhausted: ${budgetCheck.warnings.join(", ")}]`;
+        break;
+      }
+
+      if (budgetCheck.warnings.length > 0) {
+        this.events.onBudgetWarning?.(budgetCheck.warnings);
+      }
+
+      // Get LLM response
+      const systemPrompt = this.config.systemPrompt || DEFAULT_SYSTEM_PROMPT;
+
+      let response: LLMResponse;
+      try {
+        response = await this.llm.chat(
+          this.context.messages,
+          this.tools.getAll(),
+          systemPrompt,
+          stream ? this.events.onStream : undefined,
+          this.abortController?.signal
+        );
+      } catch (error) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        // Don't report abort as an error
+        if (err.message === "Aborted") {
+          return finalResponse + "\n\n[Stopped by user]";
+        }
+        this.events.onError?.(err);
+        return `Error communicating with LLM: ${err.message}`;
+      }
+
+      // Record token usage
+      this.budget.recordUsage(response.usage);
+      this.budget.recordIteration();
+
+      // Add assistant message to context
+      const assistantMsg: Message = {
+        role: "assistant",
+        content: response.content,
+        toolCalls: response.toolCalls,
+        timestamp: new Date(),
+      };
+      this.context.messages.push(assistantMsg);
+      this.events.onMessage?.(assistantMsg);
+
+      // If no tool calls, we're done
+      if (!response.toolCalls || response.toolCalls.length === 0) {
+        finalResponse = response.content;
+        break;
+      }
+
+      // Execute tool calls
+      for (const toolCall of response.toolCalls) {
+        // Check if aborted before each tool call
+        if (this.abortController?.signal.aborted) {
+          return finalResponse + "\n\n[Stopped by user]";
+        }
+
+        this.events.onToolCall?.(toolCall);
+        toolCallCount++;
+
+        const result = await this.executeToolCall(toolCall);
+        this.events.onToolResult?.(result);
+
+        // Add tool result to context
+        const toolMsg: Message = {
+          role: "tool",
+          content: result.output || result.error || "(no output)",
+          toolCallId: toolCall.id,
+          timestamp: new Date(),
+        };
+        this.context.messages.push(toolMsg);
+      }
+
+      // If we hit max tool calls, break
+      if (toolCallCount >= maxToolCalls) {
+        finalResponse += `\n\n[Reached maximum tool call limit: ${maxToolCalls}]`;
+        break;
+      }
+    }
+
+    return finalResponse;
+  }
+
+  private async executeToolCall(toolCall: ToolCall): Promise<ToolResult> {
+    const result = await this.tools.execute(toolCall.name, toolCall.arguments);
+    result.toolCallId = toolCall.id;
+    return result;
+  }
+
+  // Get current conversation
+  getMessages(): Message[] {
+    return [...this.context.messages];
+  }
+
+  // Clear conversation history
+  clearHistory(): void {
+    this.context.messages = [];
+    this.budget.reset();
+    this.context.startTime = new Date();
+  }
+
+  // Get budget status
+  getBudgetStatus(): {
+    usage: ReturnType<BudgetManager["getUsage"]>;
+    check: ReturnType<BudgetManager["checkBudget"]>;
+    summary: string;
+  } {
+    return {
+      usage: this.budget.getUsage(),
+      check: this.budget.checkBudget(),
+      summary: this.budget.formatUsageSummary(),
+    };
+  }
+
+  // Update budget
+  updateBudget(budget: Partial<Budget>): void {
+    this.budget.updateBudget(budget);
+  }
+
+  // Update max tool calls
+  setMaxToolCalls(limit: number): void {
+    this.config.maxToolCalls = limit;
+  }
+
+  // Get max tool calls
+  getMaxToolCalls(): number {
+    return this.config.maxToolCalls || 50;
+  }
+
+  // Get current model info
+  getModelInfo(): { provider: string; model: string } {
+    return {
+      provider: this.config.provider,
+      model: this.llm.getModel(),
+    };
+  }
+
+  // Set model
+  setModel(model: string): void {
+    this.config.model = model;
+    this.llm.setModel(model);
+    // Update cost estimation for new model
+    this.budget.setCostPerMillion(this.llm.getCostPerMillion());
+  }
+
+  // Set working directory
+  setWorkingDirectory(dir: string): void {
+    this.context.workingDirectory = dir;
+    this.fileResolver.setBasePath(dir);
+  }
+
+  // Get working directory
+  getWorkingDirectory(): string {
+    return this.context.workingDirectory;
+  }
+
+  // Add a system message
+  addSystemMessage(content: string): void {
+    this.context.messages.push({
+      role: "system",
+      content,
+      timestamp: new Date(),
+    });
+  }
+
+  // Get file suggestions for autocomplete
+  getFileSuggestions(partial: string): string[] {
+    return this.fileResolver.getSuggestions(partial);
+  }
+}
+

package/src/agent/BudgetManager.ts

@@ -0,0 +1,167 @@
+/**
+ * Budget Manager - Track and enforce token/time/cost budgets
+ */
+
+import type { Budget, BudgetUsage, TokenUsage } from "./types.js";
+
+export interface BudgetCheckResult {
+  withinBudget: boolean;
+  warnings: string[];
+  tokensRemaining?: number;
+  costRemaining?: number;
+  timeRemaining?: number;
+  iterationsRemaining?: number;
+}
+
+export class BudgetManager {
+  private budget: Budget;
+  private usage: BudgetUsage;
+  private startTime: number;
+  private costPerMillion: { input: number; output: number };
+
+  constructor(budget: Budget = {}, costPerMillion = { input: 3, output: 15 }) {
+    this.budget = budget;
+    this.costPerMillion = costPerMillion;
+    this.usage = {
+      tokensUsed: 0,
+      costUsed: 0,
+      timeUsed: 0,
+      iterationsUsed: 0,
+    };
+    this.startTime = Date.now();
+  }
+
+  recordUsage(tokenUsage: TokenUsage): void {
+    this.usage.tokensUsed += tokenUsage.totalTokens;
+    this.usage.costUsed +=
+      (tokenUsage.inputTokens * this.costPerMillion.input +
+        tokenUsage.outputTokens * this.costPerMillion.output) /
+      1_000_000;
+    this.usage.timeUsed = (Date.now() - this.startTime) / 1000;
+  }
+
+  recordIteration(): void {
+    this.usage.iterationsUsed += 1;
+  }
+
+  checkBudget(): BudgetCheckResult {
+    const warnings: string[] = [];
+    let withinBudget = true;
+
+    // Update time
+    this.usage.timeUsed = (Date.now() - this.startTime) / 1000;
+
+    // Check tokens
+    if (this.budget.maxTokens !== undefined) {
+      const tokensRemaining = this.budget.maxTokens - this.usage.tokensUsed;
+      if (tokensRemaining <= 0) {
+        withinBudget = false;
+        warnings.push(`Token budget exhausted (${this.usage.tokensUsed}/${this.budget.maxTokens})`);
+      } else if (tokensRemaining < this.budget.maxTokens * 0.1) {
+        warnings.push(`Low token budget: ${tokensRemaining} remaining`);
+      }
+    }
+
+    // Check cost
+    if (this.budget.maxCost !== undefined) {
+      const costRemaining = this.budget.maxCost - this.usage.costUsed;
+      if (costRemaining <= 0) {
+        withinBudget = false;
+        warnings.push(`Cost budget exhausted ($${this.usage.costUsed.toFixed(4)}/$${this.budget.maxCost})`);
+      } else if (costRemaining < this.budget.maxCost * 0.1) {
+        warnings.push(`Low cost budget: $${costRemaining.toFixed(4)} remaining`);
+      }
+    }
+
+    // Check time
+    if (this.budget.maxTime !== undefined) {
+      const timeRemaining = this.budget.maxTime - this.usage.timeUsed;
+      if (timeRemaining <= 0) {
+        withinBudget = false;
+        warnings.push(`Time budget exhausted (${this.usage.timeUsed.toFixed(0)}s/${this.budget.maxTime}s)`);
+      } else if (timeRemaining < this.budget.maxTime * 0.1) {
+        warnings.push(`Low time budget: ${timeRemaining.toFixed(0)}s remaining`);
+      }
+    }
+
+    // Check iterations
+    if (this.budget.maxIterations !== undefined) {
+      const iterationsRemaining = this.budget.maxIterations - this.usage.iterationsUsed;
+      if (iterationsRemaining <= 0) {
+        withinBudget = false;
+        warnings.push(`Iteration limit reached (${this.usage.iterationsUsed}/${this.budget.maxIterations})`);
+      }
+    }
+
+    return {
+      withinBudget,
+      warnings,
+      tokensRemaining: this.budget.maxTokens
+        ? Math.max(0, this.budget.maxTokens - this.usage.tokensUsed)
+        : undefined,
+      costRemaining: this.budget.maxCost
+        ? Math.max(0, this.budget.maxCost - this.usage.costUsed)
+        : undefined,
+      timeRemaining: this.budget.maxTime
+        ? Math.max(0, this.budget.maxTime - this.usage.timeUsed)
+        : undefined,
+      iterationsRemaining: this.budget.maxIterations
+        ? Math.max(0, this.budget.maxIterations - this.usage.iterationsUsed)
+        : undefined,
+    };
+  }
+
+  getUsage(): BudgetUsage {
+    this.usage.timeUsed = (Date.now() - this.startTime) / 1000;
+    return { ...this.usage };
+  }
+
+  getBudget(): Budget {
+    return { ...this.budget };
+  }
+
+  formatUsageSummary(): string {
+    const usage = this.getUsage();
+    const parts: string[] = [];
+
+    parts.push(`Tokens: ${usage.tokensUsed.toLocaleString()}`);
+    if (this.budget.maxTokens) {
+      parts[parts.length - 1] += `/${this.budget.maxTokens.toLocaleString()}`;
+    }
+
+    parts.push(`Cost: $${usage.costUsed.toFixed(4)}`);
+    if (this.budget.maxCost) {
+      parts[parts.length - 1] += `/$${this.budget.maxCost.toFixed(2)}`;
+    }
+
+    parts.push(`Time: ${usage.timeUsed.toFixed(1)}s`);
+    if (this.budget.maxTime) {
+      parts[parts.length - 1] += `/${this.budget.maxTime}s`;
+    }
+
+    if (this.budget.maxIterations) {
+      parts.push(`Iterations: ${usage.iterationsUsed}/${this.budget.maxIterations}`);
+    }
+
+    return parts.join(" | ");
+  }
+
+  reset(): void {
+    this.usage = {
+      tokensUsed: 0,
+      costUsed: 0,
+      timeUsed: 0,
+      iterationsUsed: 0,
+    };
+    this.startTime = Date.now();
+  }
+
+  updateBudget(budget: Partial<Budget>): void {
+    this.budget = { ...this.budget, ...budget };
+  }
+
+  setCostPerMillion(costs: { input: number; output: number }): void {
+    this.costPerMillion = costs;
+  }
+}
+