@vibeframe/cli 0.27.0

package/src/agent/adapters/ollama.ts

@@ -0,0 +1,231 @@
+/**
+ * Ollama LLM Adapter with JSON-based tool calling
+ * Uses prompt engineering to simulate tool calling for local models
+ */
+
+import type { LLMAdapter } from "./index.js";
+import type {
+  ToolDefinition,
+  LLMResponse,
+  AgentMessage,
+  ToolCall,
+  LLMProvider,
+} from "../types.js";
+
+interface OllamaResponse {
+  model: string;
+  created_at: string;
+  message: {
+    role: string;
+    content: string;
+  };
+  done: boolean;
+}
+
+export class OllamaAdapter implements LLMAdapter {
+  readonly provider: LLMProvider = "ollama";
+  private baseUrl: string = "http://localhost:11434";
+  private model: string = "llama3.2";
+  private initialized: boolean = false;
+
+  async initialize(apiKey: string): Promise<void> {
+    // apiKey is ignored for Ollama, but we use it to set custom URL if provided
+    if (apiKey && apiKey.startsWith("http")) {
+      this.baseUrl = apiKey;
+    }
+    this.initialized = true;
+  }
+
+  isInitialized(): boolean {
+    return this.initialized;
+  }
+
+  setModel(model: string): void {
+    this.model = model;
+  }
+
+  setBaseUrl(url: string): void {
+    this.baseUrl = url;
+  }
+
+  async chat(
+    messages: AgentMessage[],
+    tools: ToolDefinition[]
+  ): Promise<LLMResponse> {
+    if (!this.initialized) {
+      throw new Error("Ollama adapter not initialized");
+    }
+
+    // Build system prompt with tool definitions
+    const systemMessage = messages.find((m) => m.role === "system");
+    let systemPrompt = systemMessage?.content || "";
+
+    if (tools.length > 0) {
+      systemPrompt += "\n\n## IMPORTANT: Tool Usage Instructions\n";
+      systemPrompt += "You have access to tools that you MUST use to complete tasks. Do NOT describe how to do something - USE THE TOOLS.\n\n";
+      systemPrompt += "To call a tool, respond with ONLY a JSON object in this exact format:\n";
+      systemPrompt += '```json\n{"tool_calls": [{"name": "tool_name", "arguments": {"param": "value"}}]}\n```\n\n';
+      systemPrompt += "Example - If the user asks to list files:\n";
+      systemPrompt += '```json\n{"tool_calls": [{"name": "fs_list", "arguments": {"path": "."}}]}\n```\n\n';
+      systemPrompt += "Example - If the user asks to create a project:\n";
+      systemPrompt += '```json\n{"tool_calls": [{"name": "project_create", "arguments": {"name": "my-project"}}]}\n```\n\n';
+      systemPrompt += "RULES:\n";
+      systemPrompt += "1. When asked to DO something, ALWAYS use the appropriate tool\n";
+      systemPrompt += "2. Do NOT explain how to use terminal commands - use tools instead\n";
+      systemPrompt += "3. After tool results, summarize what was done\n\n";
+      systemPrompt += "## Available Tools:\n";
+
+      for (const tool of tools) {
+        systemPrompt += `\n### ${tool.name}\n`;
+        systemPrompt += `${tool.description}\n`;
+        const params = tool.parameters.properties;
+        const required = tool.parameters.required || [];
+        if (Object.keys(params).length > 0) {
+          systemPrompt += `Parameters:\n`;
+          for (const [name, param] of Object.entries(params)) {
+            const req = required.includes(name) ? "(required)" : "(optional)";
+            systemPrompt += `  - ${name} ${req}: ${(param as { description?: string }).description || ""}\n`;
+          }
+        }
+      }
+    }
+
+    // Convert messages to Ollama format
+    const ollamaMessages: { role: string; content: string }[] = [];
+
+    // Add system message first
+    ollamaMessages.push({
+      role: "system",
+      content: systemPrompt,
+    });
+
+    for (const msg of messages) {
+      if (msg.role === "system") continue;
+
+      if (msg.role === "user") {
+        ollamaMessages.push({
+          role: "user",
+          content: msg.content,
+        });
+      } else if (msg.role === "assistant") {
+        let content = msg.content;
+
+        // Include tool calls in content for context
+        if (msg.toolCalls) {
+          content += `\n\nTool calls made:\n${JSON.stringify({ tool_calls: msg.toolCalls }, null, 2)}`;
+        }
+
+        ollamaMessages.push({
+          role: "assistant",
+          content,
+        });
+      } else if (msg.role === "tool") {
+        // Include tool results as user messages for context
+        ollamaMessages.push({
+          role: "user",
+          content: `Tool result (${msg.toolCallId}):\n${msg.content}`,
+        });
+      }
+    }
+
+    // Make API call
+    const response = await fetch(`${this.baseUrl}/api/chat`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        model: this.model,
+        messages: ollamaMessages,
+        stream: false,
+      }),
+    });
+
+    if (!response.ok) {
+      throw new Error(`Ollama API error: ${response.status} ${response.statusText}`);
+    }
+
+    const data = (await response.json()) as OllamaResponse;
+    const content = data.message.content;
+
+    // Try to parse tool calls from response
+    const toolCalls = this.parseToolCalls(content);
+
+    if (toolCalls.length > 0) {
+      // Extract text content before the JSON
+      const textContent = this.extractTextBeforeJson(content);
+
+      return {
+        content: textContent,
+        toolCalls,
+        finishReason: "tool_calls",
+      };
+    }
+
+    return {
+      content,
+      finishReason: "stop",
+    };
+  }
+
+  private parseToolCalls(content: string): ToolCall[] {
+    const toolCalls: ToolCall[] = [];
+
+    // Try to find JSON block with tool_calls
+    const jsonMatch = content.match(/```json\s*(\{[\s\S]*?\})\s*```/);
+    if (jsonMatch) {
+      try {
+        const parsed = JSON.parse(jsonMatch[1]);
+        if (parsed.tool_calls && Array.isArray(parsed.tool_calls)) {
+          for (const tc of parsed.tool_calls) {
+            toolCalls.push({
+              id: `ollama-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+              name: tc.name,
+              arguments: tc.arguments || {},
+            });
+          }
+        }
+      } catch {
+        // Not valid JSON
+      }
+    }
+
+    // Also try to find raw JSON object
+    if (toolCalls.length === 0) {
+      const rawJsonMatch = content.match(/\{"tool_calls":\s*\[[\s\S]*?\]\}/);
+      if (rawJsonMatch) {
+        try {
+          const parsed = JSON.parse(rawJsonMatch[0]);
+          if (parsed.tool_calls && Array.isArray(parsed.tool_calls)) {
+            for (const tc of parsed.tool_calls) {
+              toolCalls.push({
+                id: `ollama-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+                name: tc.name,
+                arguments: tc.arguments || {},
+              });
+            }
+          }
+        } catch {
+          // Not valid JSON
+        }
+      }
+    }
+
+    return toolCalls;
+  }
+
+  private extractTextBeforeJson(content: string): string {
+    // Find the start of JSON block
+    const jsonStart = content.indexOf("```json");
+    if (jsonStart > 0) {
+      return content.substring(0, jsonStart).trim();
+    }
+
+    const rawJsonStart = content.indexOf('{"tool_calls"');
+    if (rawJsonStart > 0) {
+      return content.substring(0, rawJsonStart).trim();
+    }
+
+    return "";
+  }
+}

package/src/agent/adapters/openai.ts

@@ -0,0 +1,116 @@
+/**
+ * OpenAI LLM Adapter with Function Calling
+ */
+
+import OpenAI from "openai";
+import type { LLMAdapter } from "./index.js";
+import type {
+  ToolDefinition,
+  LLMResponse,
+  AgentMessage,
+  ToolCall,
+  LLMProvider,
+} from "../types.js";
+
+export class OpenAIAdapter implements LLMAdapter {
+  readonly provider: LLMProvider = "openai";
+  private client: OpenAI | null = null;
+  private model: string = "gpt-5-mini";
+
+  async initialize(apiKey: string): Promise<void> {
+    this.client = new OpenAI({ apiKey });
+  }
+
+  isInitialized(): boolean {
+    return this.client !== null;
+  }
+
+  setModel(model: string): void {
+    this.model = model;
+  }
+
+  async chat(
+    messages: AgentMessage[],
+    tools: ToolDefinition[]
+  ): Promise<LLMResponse> {
+    if (!this.client) {
+      throw new Error("OpenAI adapter not initialized");
+    }
+
+    // Convert messages to OpenAI format
+    const openaiMessages: OpenAI.Chat.ChatCompletionMessageParam[] = messages.map(
+      (msg) => {
+        if (msg.role === "tool") {
+          return {
+            role: "tool" as const,
+            tool_call_id: msg.toolCallId!,
+            content: msg.content,
+          };
+        }
+        if (msg.role === "assistant" && msg.toolCalls) {
+          return {
+            role: "assistant" as const,
+            content: msg.content || null,
+            tool_calls: msg.toolCalls.map((tc) => ({
+              id: tc.id,
+              type: "function" as const,
+              function: {
+                name: tc.name,
+                arguments: JSON.stringify(tc.arguments),
+              },
+            })),
+          };
+        }
+        return {
+          role: msg.role as "system" | "user" | "assistant",
+          content: msg.content,
+        };
+      }
+    );
+
+    // Convert tools to OpenAI format
+    const openaiTools: OpenAI.Chat.ChatCompletionTool[] = tools.map((tool) => ({
+      type: "function" as const,
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.parameters as unknown as Record<string, unknown>,
+      },
+    }));
+
+    // Make API call
+    const response = await this.client.chat.completions.create({
+      model: this.model,
+      messages: openaiMessages,
+      tools: openaiTools.length > 0 ? openaiTools : undefined,
+      tool_choice: openaiTools.length > 0 ? "auto" : undefined,
+    });
+
+    const choice = response.choices[0];
+    const message = choice.message;
+
+    // Parse tool calls
+    let toolCalls: ToolCall[] | undefined;
+    if (message.tool_calls && message.tool_calls.length > 0) {
+      toolCalls = message.tool_calls.map((tc) => ({
+        id: tc.id,
+        name: tc.function.name,
+        arguments: JSON.parse(tc.function.arguments),
+      }));
+    }
+
+    // Map finish reason
+    let finishReason: LLMResponse["finishReason"] = "stop";
+    if (choice.finish_reason === "tool_calls") {
+      finishReason = "tool_calls";
+    } else if (choice.finish_reason === "length") {
+      finishReason = "length";
+    }
+
+    return {
+      content: message.content || "",
+      toolCalls,
+      finishReason,
+    };
+  }
+}

package/src/agent/adapters/xai.ts

@@ -0,0 +1,119 @@
+/**
+ * xAI Grok LLM Adapter (OpenAI-compatible)
+ */
+
+import OpenAI from "openai";
+import type { LLMAdapter } from "./index.js";
+import type {
+  ToolDefinition,
+  LLMResponse,
+  AgentMessage,
+  ToolCall,
+  LLMProvider,
+} from "../types.js";
+
+export class XAIAdapter implements LLMAdapter {
+  readonly provider: LLMProvider = "xai";
+  private client: OpenAI | null = null;
+  private model: string = "grok-4-1-fast-reasoning";
+
+  async initialize(apiKey: string): Promise<void> {
+    this.client = new OpenAI({
+      apiKey,
+      baseURL: "https://api.x.ai/v1",
+    });
+  }
+
+  isInitialized(): boolean {
+    return this.client !== null;
+  }
+
+  setModel(model: string): void {
+    this.model = model;
+  }
+
+  async chat(
+    messages: AgentMessage[],
+    tools: ToolDefinition[]
+  ): Promise<LLMResponse> {
+    if (!this.client) {
+      throw new Error("xAI adapter not initialized");
+    }
+
+    // Convert messages to OpenAI format
+    const openaiMessages: OpenAI.Chat.ChatCompletionMessageParam[] = messages.map(
+      (msg) => {
+        if (msg.role === "tool") {
+          return {
+            role: "tool" as const,
+            tool_call_id: msg.toolCallId!,
+            content: msg.content,
+          };
+        }
+        if (msg.role === "assistant" && msg.toolCalls) {
+          return {
+            role: "assistant" as const,
+            content: msg.content || null,
+            tool_calls: msg.toolCalls.map((tc) => ({
+              id: tc.id,
+              type: "function" as const,
+              function: {
+                name: tc.name,
+                arguments: JSON.stringify(tc.arguments),
+              },
+            })),
+          };
+        }
+        return {
+          role: msg.role as "system" | "user" | "assistant",
+          content: msg.content,
+        };
+      }
+    );
+
+    // Convert tools to OpenAI format
+    const openaiTools: OpenAI.Chat.ChatCompletionTool[] = tools.map((tool) => ({
+      type: "function" as const,
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.parameters as unknown as Record<string, unknown>,
+      },
+    }));
+
+    // Make API call
+    const response = await this.client.chat.completions.create({
+      model: this.model,
+      messages: openaiMessages,
+      tools: openaiTools.length > 0 ? openaiTools : undefined,
+      tool_choice: openaiTools.length > 0 ? "auto" : undefined,
+    });
+
+    const choice = response.choices[0];
+    const message = choice.message;
+
+    // Parse tool calls
+    let toolCalls: ToolCall[] | undefined;
+    if (message.tool_calls && message.tool_calls.length > 0) {
+      toolCalls = message.tool_calls.map((tc) => ({
+        id: tc.id,
+        name: tc.function.name,
+        arguments: JSON.parse(tc.function.arguments),
+      }));
+    }
+
+    // Map finish reason
+    let finishReason: LLMResponse["finishReason"] = "stop";
+    if (choice.finish_reason === "tool_calls") {
+      finishReason = "tool_calls";
+    } else if (choice.finish_reason === "length") {
+      finishReason = "length";
+    }
+
+    return {
+      content: message.content || "",
+      toolCalls,
+      finishReason,
+    };
+  }
+}

package/src/agent/index.ts

@@ -0,0 +1,251 @@
+/**
+ * AgentExecutor - Main Agentic Loop
+ * Orchestrates LLM reasoning and tool execution
+ */
+
+import type {
+  AgentMessage,
+  AgentContext,
+  ToolCall,
+  ToolResult,
+  LLMProvider,
+} from "./types.js";
+import type { LLMAdapter } from "./adapters/index.js";
+import { createAdapter } from "./adapters/index.js";
+import { ToolRegistry, registerAllTools } from "./tools/index.js";
+import { getSystemPrompt } from "./prompts/system.js";
+import { ConversationMemory } from "./memory/index.js";
+
+export interface AgentExecutorOptions {
+  provider: LLMProvider;
+  apiKey: string;
+  model?: string;
+  maxTurns?: number;
+  verbose?: boolean;
+  projectPath?: string;
+  /**
+   * Callback to confirm before executing each tool.
+   * Return true to execute, false to skip.
+   */
+  confirmCallback?: (toolName: string, args: Record<string, unknown>) => Promise<boolean>;
+}
+
+export interface ExecutionResult {
+  response: string;
+  toolsUsed: string[];
+  turns: number;
+}
+
+/**
+ * AgentExecutor class
+ * Handles the agentic loop: reason → tool call → result → reason → ...
+ */
+/** Mask sensitive values in tool arguments for verbose logging */
+function maskSensitiveArgs(args: Record<string, unknown>): Record<string, unknown> {
+  const sensitiveKeys = ["apiKey", "api_key", "token", "secret", "password", "key"];
+  const masked: Record<string, unknown> = {};
+  for (const [k, v] of Object.entries(args)) {
+    if (sensitiveKeys.some((sk) => k.toLowerCase().includes(sk.toLowerCase())) && typeof v === "string") {
+      masked[k] = v.slice(0, 4) + "****";
+    } else {
+      masked[k] = v;
+    }
+  }
+  return masked;
+}
+
+export class AgentExecutor {
+  private adapter: LLMAdapter | null = null;
+  private registry: ToolRegistry;
+  private memory: ConversationMemory;
+  private context: AgentContext;
+  private config: AgentExecutorOptions;
+  private initialized = false;
+
+  constructor(options: AgentExecutorOptions) {
+    this.config = {
+      maxTurns: 10,
+      verbose: false,
+      ...options,
+    };
+    this.registry = new ToolRegistry();
+    this.memory = new ConversationMemory();
+    this.context = {
+      projectPath: options.projectPath || null,
+      workingDirectory: process.cwd(),
+    };
+  }
+
+  /**
+   * Initialize the agent
+   */
+  async initialize(): Promise<void> {
+    if (this.initialized) return;
+
+    // Create and initialize LLM adapter
+    this.adapter = await createAdapter(this.config.provider);
+    await this.adapter.initialize(this.config.apiKey);
+
+    // Register all tools
+    await registerAllTools(this.registry);
+
+    // Add system message
+    const systemPrompt = getSystemPrompt(this.context);
+    this.memory.addSystem(systemPrompt);
+
+    this.initialized = true;
+
+    if (this.config.verbose) {
+      console.log(`[Agent] Initialized with ${this.registry.size} tools`);
+      console.log(`[Agent] Provider: ${this.config.provider}`);
+    }
+  }
+
+  /**
+   * Execute a user request
+   */
+  async execute(userInput: string): Promise<ExecutionResult> {
+    if (!this.initialized || !this.adapter) {
+      throw new Error("Agent not initialized. Call initialize() first.");
+    }
+
+    // Add user message
+    this.memory.addUser(userInput);
+
+    const toolsUsed: string[] = [];
+    let turns = 0;
+
+    // Agentic loop
+    while (turns < this.config.maxTurns!) {
+      turns++;
+
+      if (this.config.verbose) {
+        console.log(`[Agent] Turn ${turns}`);
+      }
+
+      // Get LLM response
+      const response = await this.adapter.chat(
+        this.memory.getMessages(),
+        this.registry.getDefinitions()
+      );
+
+      // Handle tool calls
+      if (response.finishReason === "tool_calls" && response.toolCalls) {
+        // Add assistant message with tool calls
+        this.memory.addAssistant(response.content, response.toolCalls);
+
+        // Execute each tool
+        for (const toolCall of response.toolCalls) {
+          if (this.config.verbose) {
+            console.log(`[Agent] Calling tool: ${toolCall.name}`);
+            const maskedArgs = maskSensitiveArgs(toolCall.arguments);
+            console.log(`[Agent] Args: ${JSON.stringify(maskedArgs)}`);
+          }
+
+          const result = await this.executeTool(toolCall);
+          toolsUsed.push(toolCall.name);
+
+          // Add tool result
+          this.memory.addToolResult(toolCall.id, result);
+
+          if (this.config.verbose) {
+            console.log(`[Agent] Result: ${result.success ? "success" : "error"}`);
+            if (result.output) {
+              console.log(`[Agent] Output: ${result.output.substring(0, 200)}...`);
+            }
+          }
+        }
+
+        // Continue loop to get next response
+        continue;
+      }
+
+      // No more tool calls - we're done
+      this.memory.addAssistant(response.content);
+
+      return {
+        response: response.content,
+        toolsUsed: [...new Set(toolsUsed)], // Deduplicate
+        turns,
+      };
+    }
+
+    // Max turns reached
+    return {
+      response: "Maximum turns reached. Please try breaking down your request.",
+      toolsUsed: [...new Set(toolsUsed)],
+      turns,
+    };
+  }
+
+  /**
+   * Execute a single tool
+   */
+  private async executeTool(toolCall: ToolCall): Promise<ToolResult> {
+    // Check confirmCallback if set
+    if (this.config.confirmCallback) {
+      const confirmed = await this.config.confirmCallback(
+        toolCall.name,
+        toolCall.arguments
+      );
+      if (!confirmed) {
+        return {
+          toolCallId: toolCall.id,
+          success: false,
+          output: "Tool execution skipped by user",
+        };
+      }
+    }
+
+    const result = await this.registry.execute(
+      toolCall.name,
+      toolCall.arguments,
+      this.context
+    );
+    result.toolCallId = toolCall.id;
+    return result;
+  }
+
+  /**
+   * Update context (e.g., when project changes)
+   */
+  updateContext(updates: Partial<AgentContext>): void {
+    this.context = { ...this.context, ...updates };
+  }
+
+  /**
+   * Reset conversation memory
+   */
+  reset(): void {
+    this.memory.clear();
+    const systemPrompt = getSystemPrompt(this.context);
+    this.memory.addSystem(systemPrompt);
+  }
+
+  /**
+   * Get current context
+   */
+  getContext(): AgentContext {
+    return { ...this.context };
+  }
+
+  /**
+   * Get conversation history
+   */
+  getHistory(): AgentMessage[] {
+    return this.memory.getMessages();
+  }
+
+  /**
+   * Get available tools
+   */
+  getTools(): string[] {
+    return this.registry.list();
+  }
+}
+
+// Re-export types
+export type { AgentConfig, AgentContext, AgentMessage, ToolCall, ToolResult } from "./types.js";
+export type { LLMAdapter } from "./adapters/index.js";
+export { ToolRegistry } from "./tools/index.js";
+export { ConversationMemory } from "./memory/index.js";