@vibeframe/cli 0.27.0 → 0.29.0

package/src/agent/adapters/claude.ts

@@ -1,143 +0,0 @@
-/**
- * Claude LLM Adapter with tool_use
- */
-
-import Anthropic from "@anthropic-ai/sdk";
-import type { LLMAdapter } from "./index.js";
-import type {
-  ToolDefinition,
-  LLMResponse,
-  AgentMessage,
-  ToolCall,
-  LLMProvider,
-} from "../types.js";
-
-export class ClaudeAdapter implements LLMAdapter {
-  readonly provider: LLMProvider = "claude";
-  private client: Anthropic | null = null;
-  private model: string = "claude-sonnet-4-6";
-
-  async initialize(apiKey: string): Promise<void> {
-    this.client = new Anthropic({ 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("Claude adapter not initialized");
-    }
-
-    // Extract system message
-    const systemMessage = messages.find((m) => m.role === "system");
-    const systemPrompt = systemMessage?.content || "";
-
-    // Convert messages to Claude format
-    const claudeMessages: Anthropic.MessageParam[] = [];
-
-    for (const msg of messages) {
-      if (msg.role === "system") continue;
-
-      if (msg.role === "user") {
-        claudeMessages.push({
-          role: "user",
-          content: msg.content,
-        });
-      } else if (msg.role === "assistant") {
-        const content: Anthropic.ContentBlockParam[] = [];
-
-        if (msg.content) {
-          content.push({ type: "text", text: msg.content });
-        }
-
-        if (msg.toolCalls) {
-          for (const tc of msg.toolCalls) {
-            content.push({
-              type: "tool_use",
-              id: tc.id,
-              name: tc.name,
-              input: tc.arguments,
-            });
-          }
-        }
-
-        if (content.length > 0) {
-          claudeMessages.push({
-            role: "assistant",
-            content,
-          });
-        }
-      } else if (msg.role === "tool") {
-        claudeMessages.push({
-          role: "user",
-          content: [
-            {
-              type: "tool_result",
-              tool_use_id: msg.toolCallId!,
-              content: msg.content,
-            },
-          ],
-        });
-      }
-    }
-
-    // Convert tools to Claude format
-    const claudeTools: Anthropic.Tool[] = tools.map((tool) => ({
-      name: tool.name,
-      description: tool.description,
-      input_schema: {
-        type: "object" as const,
-        properties: tool.parameters.properties as Record<string, unknown>,
-        required: tool.parameters.required,
-      },
-    }));
-
-    // Make API call
-    const response = await this.client.messages.create({
-      model: this.model,
-      max_tokens: 4096,
-      system: systemPrompt,
-      messages: claudeMessages,
-      tools: claudeTools.length > 0 ? claudeTools : undefined,
-    });
-
-    // Parse response
-    let textContent = "";
-    const toolCalls: ToolCall[] = [];
-
-    for (const block of response.content) {
-      if (block.type === "text") {
-        textContent += block.text;
-      } else if (block.type === "tool_use") {
-        toolCalls.push({
-          id: block.id,
-          name: block.name,
-          arguments: block.input as Record<string, unknown>,
-        });
-      }
-    }
-
-    // Map stop reason
-    let finishReason: LLMResponse["finishReason"] = "stop";
-    if (response.stop_reason === "tool_use") {
-      finishReason = "tool_calls";
-    } else if (response.stop_reason === "max_tokens") {
-      finishReason = "length";
-    }
-
-    return {
-      content: textContent,
-      toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
-      finishReason,
-    };
-  }
-}

package/src/agent/adapters/gemini.ts

@@ -1,159 +0,0 @@
-/**
- * Gemini LLM Adapter with Function Calling
- */
-
-import { GoogleGenerativeAI, SchemaType, type Content, type Part, type Tool as GeminiTool, type FunctionDeclarationSchemaProperty } from "@google/generative-ai";
-import type { LLMAdapter } from "./index.js";
-import type {
-  ToolDefinition,
-  LLMResponse,
-  AgentMessage,
-  ToolCall,
-  LLMProvider,
-} from "../types.js";
-
-export class GeminiAdapter implements LLMAdapter {
-  readonly provider: LLMProvider = "gemini";
-  private client: GoogleGenerativeAI | null = null;
-  private model: string = "gemini-2.5-flash";
-
-  async initialize(apiKey: string): Promise<void> {
-    this.client = new GoogleGenerativeAI(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("Gemini adapter not initialized");
-    }
-
-    // Extract system message
-    const systemMessage = messages.find((m) => m.role === "system");
-    const systemInstruction = systemMessage?.content;
-
-    // Convert tools to Gemini format
-    const geminiTools: GeminiTool[] = tools.length > 0 ? [{
-      functionDeclarations: tools.map((tool) => ({
-        name: tool.name,
-        description: tool.description,
-        parameters: {
-          type: SchemaType.OBJECT,
-          properties: tool.parameters.properties as Record<string, FunctionDeclarationSchemaProperty>,
-          required: tool.parameters.required,
-        },
-      })),
-    }] : [];
-
-    // Get model with tools
-    const model = this.client.getGenerativeModel({
-      model: this.model,
-      systemInstruction,
-      tools: geminiTools.length > 0 ? geminiTools : undefined,
-    });
-
-    // Convert messages to Gemini format
-    const geminiContents: Content[] = [];
-
-    for (const msg of messages) {
-      if (msg.role === "system") continue;
-
-      if (msg.role === "user") {
-        geminiContents.push({
-          role: "user",
-          parts: [{ text: msg.content }],
-        });
-      } else if (msg.role === "assistant") {
-        const parts: Part[] = [];
-
-        if (msg.content) {
-          parts.push({ text: msg.content });
-        }
-
-        if (msg.toolCalls) {
-          for (const tc of msg.toolCalls) {
-            parts.push({
-              functionCall: {
-                name: tc.name,
-                args: tc.arguments,
-              },
-            });
-          }
-        }
-
-        if (parts.length > 0) {
-          geminiContents.push({
-            role: "model",
-            parts,
-          });
-        }
-      } else if (msg.role === "tool") {
-        // Gemini expects function responses in user turn
-        geminiContents.push({
-          role: "user",
-          parts: [{
-            functionResponse: {
-              name: msg.toolCallId!.split(":::")[0] || "unknown", // Extract function name from id
-              response: { result: msg.content },
-            },
-          }],
-        });
-      }
-    }
-
-    // Make API call
-    const result = await model.generateContent({
-      contents: geminiContents,
-    });
-
-    const response = result.response;
-    const candidate = response.candidates?.[0];
-
-    if (!candidate) {
-      return {
-        content: "",
-        finishReason: "error",
-      };
-    }
-
-    // Parse response
-    let textContent = "";
-    const toolCalls: ToolCall[] = [];
-
-    for (const part of candidate.content.parts) {
-      if ("text" in part && part.text) {
-        textContent += part.text;
-      } else if ("functionCall" in part && part.functionCall) {
-        const fc = part.functionCall;
-        toolCalls.push({
-          id: `${fc.name}:::${Date.now()}`,
-          name: fc.name,
-          arguments: (fc.args || {}) as Record<string, unknown>,
-        });
-      }
-    }
-
-    // Map finish reason
-    let finishReason: LLMResponse["finishReason"] = "stop";
-    if (toolCalls.length > 0) {
-      finishReason = "tool_calls";
-    } else if (candidate.finishReason === "MAX_TOKENS") {
-      finishReason = "length";
-    }
-
-    return {
-      content: textContent,
-      toolCalls: toolCalls.length > 0 ? toolCalls : undefined,
-      finishReason,
-    };
-  }
-}

package/src/agent/adapters/index.ts

@@ -1,61 +0,0 @@
-/**
- * LLM Adapter Interface and Factory
- */
-
-import type { ToolDefinition, LLMResponse, AgentMessage, LLMProvider } from "../types.js";
-
-/**
- * Abstract interface for LLM providers
- */
-export interface LLMAdapter {
-  /** Provider name */
-  readonly provider: LLMProvider;
-
-  /** Initialize the adapter with API key */
-  initialize(apiKey: string): Promise<void>;
-
-  /** Check if adapter is initialized */
-  isInitialized(): boolean;
-
-  /** Send messages with tools and get response */
-  chat(
-    messages: AgentMessage[],
-    tools: ToolDefinition[]
-  ): Promise<LLMResponse>;
-}
-
-/**
- * Factory for creating LLM adapters
- */
-export async function createAdapter(provider: LLMProvider): Promise<LLMAdapter> {
-  switch (provider) {
-    case "openai": {
-      const { OpenAIAdapter } = await import("./openai.js");
-      return new OpenAIAdapter();
-    }
-    case "claude": {
-      const { ClaudeAdapter } = await import("./claude.js");
-      return new ClaudeAdapter();
-    }
-    case "gemini": {
-      const { GeminiAdapter } = await import("./gemini.js");
-      return new GeminiAdapter();
-    }
-    case "ollama": {
-      const { OllamaAdapter } = await import("./ollama.js");
-      return new OllamaAdapter();
-    }
-    case "xai": {
-      const { XAIAdapter } = await import("./xai.js");
-      return new XAIAdapter();
-    }
-    default:
-      throw new Error(`Unknown provider: ${provider}`);
-  }
-}
-
-export { OpenAIAdapter } from "./openai.js";
-export { ClaudeAdapter } from "./claude.js";
-export { GeminiAdapter } from "./gemini.js";
-export { OllamaAdapter } from "./ollama.js";
-export { XAIAdapter } from "./xai.js";

package/src/agent/adapters/ollama.ts

@@ -1,231 +0,0 @@
-/**
- * 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

@@ -1,116 +0,0 @@
-/**
- * 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,
-    };
-  }
-}