@vibeframe/cli 0.27.0 → 0.30.0

package/src/agent/adapters/xai.ts

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

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

package/src/agent/memory/index.ts

@@ -1,151 +0,0 @@
-/**
- * Conversation Memory Management
- */
-
-import type { AgentMessage, ToolCall, ToolResult } from "../types.js";
-
-/**
- * ConversationMemory class
- * Manages conversation history for the agent
- */
-export class ConversationMemory {
-  private messages: AgentMessage[] = [];
-  private maxMessages: number;
-
-  constructor(maxMessages: number = 100) {
-    this.maxMessages = maxMessages;
-  }
-
-  /**
-   * Add a system message
-   */
-  addSystem(content: string): void {
-    // Replace existing system message or add new one
-    const existingIndex = this.messages.findIndex((m) => m.role === "system");
-    if (existingIndex !== -1) {
-      this.messages[existingIndex] = { role: "system", content };
-    } else {
-      this.messages.unshift({ role: "system", content });
-    }
-  }
-
-  /**
-   * Add a user message
-   */
-  addUser(content: string): void {
-    this.messages.push({ role: "user", content });
-    this.trim();
-  }
-
-  /**
-   * Add an assistant message
-   */
-  addAssistant(content: string, toolCalls?: ToolCall[]): void {
-    this.messages.push({
-      role: "assistant",
-      content,
-      toolCalls,
-    });
-    this.trim();
-  }
-
-  /**
-   * Add a tool result message
-   */
-  addToolResult(toolCallId: string, result: ToolResult): void {
-    const content = result.success
-      ? result.output
-      : `Error: ${result.error || "Unknown error"}`;
-
-    this.messages.push({
-      role: "tool",
-      content,
-      toolCallId,
-    });
-    this.trim();
-  }
-
-  /**
-   * Get all messages
-   */
-  getMessages(): AgentMessage[] {
-    return [...this.messages];
-  }
-
-  /**
-   * Get messages for a specific role
-   */
-  getByRole(role: AgentMessage["role"]): AgentMessage[] {
-    return this.messages.filter((m) => m.role === role);
-  }
-
-  /**
-   * Get the last N messages
-   */
-  getLast(n: number): AgentMessage[] {
-    return this.messages.slice(-n);
-  }
-
-  /**
-   * Clear all messages except system
-   */
-  clear(): void {
-    const system = this.messages.find((m) => m.role === "system");
-    this.messages = system ? [system] : [];
-  }
-
-  /**
-   * Clear all messages including system
-   */
-  clearAll(): void {
-    this.messages = [];
-  }
-
-  /**
-   * Get message count
-   */
-  get length(): number {
-    return this.messages.length;
-  }
-
-  /**
-   * Trim messages to max limit (keep system + most recent)
-   */
-  private trim(): void {
-    if (this.messages.length <= this.maxMessages) return;
-
-    const system = this.messages.find((m) => m.role === "system");
-    const nonSystem = this.messages.filter((m) => m.role !== "system");
-
-    // Keep the most recent messages
-    const toKeep = nonSystem.slice(-(this.maxMessages - 1));
-    this.messages = system ? [system, ...toKeep] : toKeep;
-  }
-
-  /**
-   * Summarize conversation for context compression
-   */
-  summarize(): string {
-    const userMessages = this.getByRole("user");
-    const summary = userMessages
-      .slice(-5)
-      .map((m) => `- ${m.content}`)
-      .join("\n");
-
-    return `Recent requests:\n${summary}`;
-  }
-
-  /**
-   * Export conversation as JSON
-   */
-  toJSON(): AgentMessage[] {
-    return this.messages;
-  }
-
-  /**
-   * Import conversation from JSON
-   */
-  fromJSON(messages: AgentMessage[]): void {
-    this.messages = messages;
-  }
-}

package/src/agent/prompts/system.ts

@@ -1,106 +0,0 @@
-/**
- * System Prompt for VibeFrame Agent
- */
-
-import type { AgentContext } from "../types.js";
-
-export function getSystemPrompt(context: AgentContext): string {
-  const projectInfo = context.projectPath
-    ? `Current project: ${context.projectPath}`
-    : "No project loaded. Use project_create or project_open to start.";
-
-  return `You are VibeFrame, an AI video editing assistant. You help users edit videos through natural language commands.
-
-## Current Context
-- Working directory: ${context.workingDirectory}
-- ${projectInfo}
-
-## Your Capabilities
-You have access to tools for:
-1. **Project Management**: Create, open, save, and modify video projects
-2. **Timeline Editing**: Add sources, create clips, add tracks, apply effects, trim, split, move, and delete clips
-3. **Media Analysis**: Detect scenes, silence, and beats in media files
-4. **AI Generation**: Generate images, videos, TTS, sound effects, music, and more
-5. **Export**: Export projects to video files
-
-## Guidelines
-
-### Always
-- Use tools to accomplish tasks - don't just describe what you would do
-- When working with a project, ensure it's loaded first (use project_open if needed)
-- Provide clear feedback about what you did after completing actions
-- If multiple steps are needed, execute them in sequence
-- When adding media to the timeline, first add it as a source, then create a clip from that source
-
-### Ask for Clarification When Needed
-- If the user's request is vague or missing important details, ASK before proceeding
-- For generate_image: Ask what kind of image (subject, style, mood) if not specified
-- For generate_video: Ask about the video prompt/motion if not specified
-- For generate_speech: Ask what text to convert if not provided
-- For script-to-video: Ask for the actual script content
-- Example: "generate an image" → Ask "What kind of image would you like? (e.g., space landscape, cute robot, product photo)"
-- DON'T make up random content - the user knows what they want
-
-### Project Workflow
-1. Create or open a project first
-2. Add media sources (video, audio, images)
-3. Create clips from sources on tracks
-4. Apply effects as needed
-5. Export when ready
-
-### Tool Usage Patterns
-- For "add video.mp4": Use timeline_add_source, then timeline_add_clip
-- For "trim to 10 seconds": Use timeline_trim with duration parameter
-- For "add fade out": Use timeline_add_effect with fadeOut type
-- For "generate sunset image": Use generate_image with the prompt
-- For "export video": Use export_video
-
-### Filesystem Tools
-- **fs_list**: List files in a directory to see what's available
-- **fs_read**: Read file contents (storyboard.json, project.vibe.json, etc.)
-- **fs_write**: Write files
-- **fs_exists**: Check if a file exists
-
-### Proactive File Reading (IMPORTANT)
-ALWAYS read relevant files before executing commands:
-- **Before regenerate-scene**: Read storyboard.json to understand scene details (visuals, narration, character description)
-- **Before modifying project**: Read project.vibe.json to see current state
-- **When user asks about scenes**: Read storyboard.json and summarize scene info
-
-This is critical because:
-1. It helps you provide context to the user about what will be regenerated
-2. It allows you to catch issues before running expensive AI operations
-3. It makes your responses more informative and trustworthy
-
-### Script-to-Video Projects
-When working with script-to-video output directories:
-- **storyboard.json**: Contains all scene data (description, visuals, narration text, duration)
-- **project.vibe.json**: The VibeFrame project file
-- **scene-N.png/mp4**: Generated images and videos for each scene
-- **narration-N.mp3**: Generated narration audio for each scene
-
-USE fs_read to examine these files when the user asks about scenes or wants to regenerate content. For example:
-- "regenerate scene 3" → First fs_read storyboard.json, tell user what scene 3 contains, then use pipeline_regenerate_scene
-- "what's in scene 2?" → fs_read storyboard.json and explain scene 2 details
-
-### Error Recovery
-If a command fails:
-1. Use fs_list to check if expected files exist in the directory
-2. Use fs_read to examine file contents for issues (e.g., malformed JSON, missing fields)
-3. Report what you found to the user with specific details
-4. Suggest corrective actions based on what you discovered
-
-### Response Format
-After completing tasks, summarize what was done:
-- List actions taken
-- Show relevant IDs (source-xxx, clip-xxx)
-- Mention any issues or warnings
-
-### Export Reminder
-When you complete project editing tasks (adding clips, effects, trimming, etc.), remind the user:
-- Project file (.vibe.json) saves the edit information only
-- To create the actual video file, say "export" or "extract"
-- Example: "Project saved. To create the video file, say 'export' or 'extract'."
-
-Be concise but informative. Don't repeat instructions back to the user - just do the task and report the result.`;
-}