@vibeframe/cli 0.104.3 → 0.105.2

package/dist/agent/adapters/claude.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Claude LLM Adapter with tool_use
+ */
+import type { LLMAdapter } from "./index.js";
+import type { ToolDefinition, LLMResponse, AgentMessage, LLMProvider } from "../types.js";
+export declare class ClaudeAdapter implements LLMAdapter {
+    readonly provider: LLMProvider;
+    private client;
+    private model;
+    initialize(apiKey: string): Promise<void>;
+    isInitialized(): boolean;
+    setModel(model: string): void;
+    chat(messages: AgentMessage[], tools: ToolDefinition[]): Promise<LLMResponse>;
+}

package/dist/agent/adapters/gemini.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Gemini LLM Adapter with Function Calling
+ */
+import type { LLMAdapter } from "./index.js";
+import type { ToolDefinition, LLMResponse, AgentMessage, LLMProvider } from "../types.js";
+export declare class GeminiAdapter implements LLMAdapter {
+    readonly provider: LLMProvider;
+    private client;
+    private model;
+    initialize(apiKey: string): Promise<void>;
+    isInitialized(): boolean;
+    setModel(model: string): void;
+    chat(messages: AgentMessage[], tools: ToolDefinition[]): Promise<LLMResponse>;
+}

package/dist/agent/adapters/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 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 declare function createAdapter(provider: LLMProvider): Promise<LLMAdapter>;
+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";
+export { OpenRouterAdapter } from "./openrouter.js";

package/dist/agent/adapters/ollama.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 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, LLMProvider } from "../types.js";
+export declare class OllamaAdapter implements LLMAdapter {
+    readonly provider: LLMProvider;
+    private baseUrl;
+    private model;
+    private initialized;
+    initialize(apiKey: string): Promise<void>;
+    isInitialized(): boolean;
+    setModel(model: string): void;
+    setBaseUrl(url: string): void;
+    chat(messages: AgentMessage[], tools: ToolDefinition[]): Promise<LLMResponse>;
+    private parseToolCalls;
+    private extractTextBeforeJson;
+}

package/dist/agent/adapters/openai.d.ts

@@ -0,0 +1,14 @@
+/**
+ * OpenAI LLM Adapter with Function Calling
+ */
+import type { LLMAdapter } from "./index.js";
+import type { ToolDefinition, LLMResponse, AgentMessage, LLMProvider } from "../types.js";
+export declare class OpenAIAdapter implements LLMAdapter {
+    readonly provider: LLMProvider;
+    private client;
+    private model;
+    initialize(apiKey: string): Promise<void>;
+    isInitialized(): boolean;
+    setModel(model: string): void;
+    chat(messages: AgentMessage[], tools: ToolDefinition[]): Promise<LLMResponse>;
+}

package/dist/agent/adapters/openrouter.d.ts

@@ -0,0 +1,15 @@
+/**
+ * OpenRouter LLM Adapter (OpenAI-compatible)
+ * Routes to 300+ models via https://openrouter.ai/api/v1
+ */
+import type { LLMAdapter } from "./index.js";
+import type { ToolDefinition, LLMResponse, AgentMessage, LLMProvider } from "../types.js";
+export declare class OpenRouterAdapter implements LLMAdapter {
+    readonly provider: LLMProvider;
+    private client;
+    private model;
+    initialize(apiKey: string): Promise<void>;
+    isInitialized(): boolean;
+    setModel(model: string): void;
+    chat(messages: AgentMessage[], tools: ToolDefinition[]): Promise<LLMResponse>;
+}

package/dist/agent/adapters/openrouter.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * OpenRouter adapter unit tests (mock-based, no API calls)
+ */
+export {};

package/dist/agent/adapters/xai.d.ts

@@ -0,0 +1,14 @@
+/**
+ * xAI Grok LLM Adapter (OpenAI-compatible)
+ */
+import type { LLMAdapter } from "./index.js";
+import type { ToolDefinition, LLMResponse, AgentMessage, LLMProvider } from "../types.js";
+export declare class XAIAdapter implements LLMAdapter {
+    readonly provider: LLMProvider;
+    private client;
+    private model;
+    initialize(apiKey: string): Promise<void>;
+    isInitialized(): boolean;
+    setModel(model: string): void;
+    chat(messages: AgentMessage[], tools: ToolDefinition[]): Promise<LLMResponse>;
+}

package/dist/agent/index.d.ts

@@ -0,0 +1,109 @@
+/**
+ * AgentExecutor - Main Agentic Loop
+ * Orchestrates LLM reasoning and tool execution
+ */
+import type { AgentMessage, AgentContext, ToolDefinition, LLMProvider } from "./types.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.
+     *
+     * The `cost` argument is the tool's declared cost tier (free / low /
+     * medium / high / very-high) so the prompt can warn about expensive
+     * calls. `undefined` for tools that didn't declare a tier.
+     */
+    confirmCallback?: (toolName: string, args: Record<string, unknown>, cost: ToolDefinition["cost"]) => Promise<boolean>;
+    /**
+     * When true, prompt before every tool call. When false (default), the
+     * cost gate in `executeTool` fires only for high/very-high tools.
+     * Set by `--confirm` CLI flag.
+     */
+    confirmAlways?: boolean;
+    /**
+     * Disable all confirm prompts, even for high/very-high cost tools.
+     * For automated agent sessions where every tool call must run
+     * unattended. Set by `--no-confirm` CLI flag.
+     */
+    noConfirm?: boolean;
+    /**
+     * Cumulative USD ceiling for the agent session. When set, each tool
+     * call's tier-derived estimate is added to a running total; if the
+     * next call would push the total over `budgetUsd`, the executor
+     * skips it and returns a "budget exceeded" tool result so the LLM
+     * can adapt or stop. Mirrors `vibe run --budget-usd`. `undefined`
+     * disables the cap.
+     */
+    budgetUsd?: number;
+}
+export interface ExecutionResult {
+    response: string;
+    toolsUsed: string[];
+    turns: number;
+}
+export declare class AgentExecutor {
+    private adapter;
+    private registry;
+    private memory;
+    private cumulativeUsd;
+    private context;
+    private config;
+    private initialized;
+    constructor(options: AgentExecutorOptions);
+    /**
+     * Initialize the agent
+     */
+    initialize(): Promise<void>;
+    /**
+     * Execute a user request
+     */
+    execute(userInput: string): Promise<ExecutionResult>;
+    /**
+     * Execute a single tool
+     *
+     * Confirm-prompt logic:
+     *   - `noConfirm: true`               → never prompt (automation / CI)
+     *   - `confirmAlways: true`           → prompt for every tool call
+     *   - default                         → prompt only when the tool's
+     *                                       cost is high/very-high (the
+     *                                       `costGate`)
+     *
+     * The two non-trivial cases require `confirmCallback` to be set; if
+     * it isn't, no prompt fires and the tool runs.
+     */
+    private executeTool;
+    /**
+     * Cumulative tier-estimated USD spent in this session. Updates after
+     * every successful tool call. Useful for status output / `tools` REPL.
+     */
+    getCumulativeUsd(): number;
+    /**
+     * Update context (e.g., when project changes)
+     */
+    updateContext(updates: Partial<AgentContext>): void;
+    /**
+     * Reset conversation memory
+     */
+    reset(): void;
+    /**
+     * Get current context
+     */
+    getContext(): AgentContext;
+    /**
+     * Get conversation history
+     */
+    getHistory(): AgentMessage[];
+    /**
+     * Get available tools
+     */
+    getTools(): string[];
+}
+export type { AgentConfig, AgentContext, AgentMessage, ToolCall, ToolResult } from "./types.js";
+export type { LLMAdapter } from "./adapters/index.js";
+export { ToolRegistry, registerAllTools } from "./tools/index.js";
+export { ConversationMemory } from "./memory/index.js";

package/dist/agent/memory/index.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Conversation Memory Management
+ */
+import type { AgentMessage, ToolCall, ToolResult } from "../types.js";
+/**
+ * ConversationMemory class
+ * Manages conversation history for the agent
+ */
+export declare class ConversationMemory {
+    private messages;
+    private maxMessages;
+    constructor(maxMessages?: number);
+    /**
+     * Add a system message
+     */
+    addSystem(content: string): void;
+    /**
+     * Add a user message
+     */
+    addUser(content: string): void;
+    /**
+     * Add an assistant message
+     */
+    addAssistant(content: string, toolCalls?: ToolCall[]): void;
+    /**
+     * Add a tool result message
+     */
+    addToolResult(toolCallId: string, result: ToolResult): void;
+    /**
+     * Get all messages
+     */
+    getMessages(): AgentMessage[];
+    /**
+     * Get messages for a specific role
+     */
+    getByRole(role: AgentMessage["role"]): AgentMessage[];
+    /**
+     * Get the last N messages
+     */
+    getLast(n: number): AgentMessage[];
+    /**
+     * Clear all messages except system
+     */
+    clear(): void;
+    /**
+     * Clear all messages including system
+     */
+    clearAll(): void;
+    /**
+     * Get message count
+     */
+    get length(): number;
+    /**
+     * Trim messages to max limit (keep system + most recent)
+     */
+    private trim;
+    /**
+     * Summarize conversation for context compression
+     */
+    summarize(): string;
+    /**
+     * Export conversation as JSON
+     */
+    toJSON(): AgentMessage[];
+    /**
+     * Import conversation from JSON
+     */
+    fromJSON(messages: AgentMessage[]): void;
+}

package/dist/agent/prompts/system.d.ts

@@ -0,0 +1,5 @@
+/**
+ * System Prompt for VibeFrame Agent
+ */
+import type { AgentContext } from "../types.js";
+export declare function getSystemPrompt(context: AgentContext): string;

package/dist/agent/tools/e2e.test.d.ts

@@ -0,0 +1,25 @@
+/**
+ * E2E Tests: AI Pipeline Tools with Real API Calls
+ *
+ * ⚠️  WARNING: These tests make REAL API calls and incur COSTS!
+ *
+ * To run these tests:
+ *   RUN_E2E=1 pnpm vitest run src/agent/tools/e2e.test.ts
+ *
+ * Required API keys (set in ~/.vibeframe/config.yaml or env):
+ *   - ANTHROPIC_API_KEY (Claude - storyboard)
+ *   - GOOGLE_API_KEY (Gemini - image, video analysis)
+ *   - OPENAI_API_KEY (Whisper - transcription)
+ *   - ELEVENLABS_API_KEY (TTS)
+ *
+ * Estimated costs per full run:
+ *   - ai_gemini_video: ~$0.01-0.05 (depending on video length)
+ *   - ai_storyboard: ~$0.01-0.02
+ *   - ai_image (gemini): Free tier available
+ *   - ai_tts: ~$0.01-0.05 (depending on text length)
+ *   - ai_script_to_video (images-only): ~$0.05-0.20
+ *   - ai_highlights (with Gemini): ~$0.05-0.20
+ *
+ * Total estimated cost: $0.10-0.50 per full run
+ */
+export {};

package/dist/agent/tools/index.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Tool Registry - Central registry for all agent tools
+ */
+import type { ToolDefinition, ToolResult, AgentContext } from "../types.js";
+export type ToolHandler = (args: Record<string, unknown>, context: AgentContext) => Promise<ToolResult>;
+/**
+ * Tool Registry class
+ * Manages tool definitions and execution
+ */
+export declare class ToolRegistry {
+    private tools;
+    /**
+     * Register a tool
+     */
+    register(definition: ToolDefinition, handler: ToolHandler): void;
+    /**
+     * Get all tool definitions
+     */
+    getDefinitions(): ToolDefinition[];
+    /**
+     * Get a specific tool definition
+     */
+    getDefinition(name: string): ToolDefinition | undefined;
+    /**
+     * Get a specific tool definition (alias for getDefinition)
+     */
+    get(name: string): ToolDefinition | undefined;
+    /**
+     * Get all tool definitions (alias for getDefinitions)
+     */
+    getAll(): ToolDefinition[];
+    /**
+     * Get a tool handler by name
+     */
+    getHandler(name: string): ToolHandler | undefined;
+    /**
+     * Execute a tool
+     */
+    execute(name: string, args: Record<string, unknown>, context: AgentContext): Promise<ToolResult>;
+    /**
+     * Check if a tool exists
+     */
+    has(name: string): boolean;
+    /**
+     * Get tool count
+     */
+    get size(): number;
+    /**
+     * List all tool names
+     */
+    list(): string[];
+}
+export declare const toolRegistry: ToolRegistry;
+/**
+ * Register all tools. The manifest (`packages/cli/src/tools/manifest/`) is
+ * now the single source of truth for every Agent tool. v0.67 PR2 finished
+ * the migration — there are no legacy `register*Tools` left.
+ */
+export declare function registerAllTools(registry: ToolRegistry): Promise<void>;

package/dist/agent/tools/integration.test.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Integration Tests: CLI ↔ Agent Tool Synchronization
+ *
+ * These tests verify that:
+ * 1. All Agent tools are properly registered
+ * 2. Agent tools correctly wrap CLI functions
+ * 3. Parameter schemas match between CLI and Agent
+ * 4. Tool handlers produce expected output formats
+ */
+export {};

package/dist/agent/tools/scene.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/agent/types.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Core types for the VibeFrame Agentic System
+ */
+export interface ToolParameter {
+    type: "string" | "number" | "boolean" | "array" | "object";
+    description: string;
+    required?: boolean;
+    enum?: string[];
+    items?: ToolParameter;
+    properties?: Record<string, ToolParameter>;
+}
+export interface ToolDefinition {
+    name: string;
+    description: string;
+    /**
+     * Product-facing classification propagated from the manifest. This is
+     * separate from MCP/agent transport exposure and helps agents prefer the
+     * intended public workflow over legacy or internal primitives.
+     */
+    surface?: "public" | "agent" | "advanced" | "legacy" | "internal";
+    replacement?: string;
+    note?: string;
+    /**
+     * Cost tier propagated from the manifest's `defineTool` declaration.
+     * Five tiers (free / low / medium / high / very-high). Used by the
+     * agent executor to decide whether a confirm prompt is mandatory.
+     */
+    cost?: "free" | "low" | "medium" | "high" | "very-high";
+    parameters: {
+        type: "object";
+        properties: Record<string, ToolParameter>;
+        required: string[];
+    };
+}
+export interface ToolCall {
+    id: string;
+    name: string;
+    arguments: Record<string, unknown>;
+}
+export interface ToolResult {
+    toolCallId: string;
+    success: boolean;
+    output: string;
+    error?: string;
+}
+export interface AgentMessage {
+    role: "system" | "user" | "assistant" | "tool";
+    content: string;
+    toolCalls?: ToolCall[];
+    toolCallId?: string;
+}
+export interface AgentConfig {
+    provider: LLMProvider;
+    model?: string;
+    maxTurns?: number;
+    verbose?: boolean;
+}
+export type LLMProvider = "openai" | "claude" | "gemini" | "ollama" | "xai" | "openrouter";
+export interface LLMResponse {
+    content: string;
+    toolCalls?: ToolCall[];
+    finishReason: "stop" | "tool_calls" | "length" | "error";
+}
+export interface AgentContext {
+    projectPath: string | null;
+    workingDirectory: string;
+}
+export interface AgentTurn {
+    input: string;
+    response: string;
+    toolsUsed: string[];
+}

package/dist/commands/_shared/build-asset-metadata.d.ts

@@ -0,0 +1,43 @@
+import type { BuildAssetKind } from "./build-cache.js";
+export type AssetFreshness = "fresh" | "stale" | "unknown" | "referenced";
+export interface BuildAssetMetadata {
+    schemaVersion: "1";
+    kind: BuildAssetKind;
+    beatId: string;
+    cue: string;
+    provider: string;
+    options?: Record<string, unknown>;
+    cacheKey: string;
+    canonicalPath: string;
+    cachePath?: string;
+    updatedAt: string;
+}
+export declare function assetMetadataPath(kind: BuildAssetKind, beatId: string): string;
+export declare function readAssetMetadata(projectDir: string, kind: BuildAssetKind, beatId: string): BuildAssetMetadata | null;
+export declare function assetFreshnessFromMetadata(opts: {
+    projectDir: string;
+    kind: BuildAssetKind;
+    beatId: string;
+    expectedCacheKey?: string;
+    canonicalExists: boolean;
+}): AssetFreshness | undefined;
+export declare function isFreshCanonicalAsset(opts: {
+    projectDir: string;
+    kind: BuildAssetKind;
+    beatId: string;
+    cue: string;
+    provider?: string;
+    options?: Record<string, unknown>;
+    cacheKey?: string;
+}): boolean;
+export declare function writeAssetMetadata(opts: {
+    projectDir: string;
+    kind: BuildAssetKind;
+    beatId: string;
+    cue: string;
+    provider: string;
+    options?: Record<string, unknown>;
+    cacheKey: string;
+    canonicalPath: string;
+    cachePath?: string;
+}): Promise<void>;

package/dist/commands/_shared/build-asset-reference.d.ts

@@ -0,0 +1,18 @@
+import type { BuildAssetKind } from "./build-cache.js";
+export interface AssetReferenceCandidate {
+    kind: BuildAssetKind;
+    raw: string;
+    relPath?: string;
+    absPath?: string;
+    ext: string;
+    exists: boolean;
+    withinProject: boolean;
+    source: "typed" | "asset";
+    error?: string;
+}
+export declare function resolveTypedAssetReference(projectDir: string, kind: BuildAssetKind, value: unknown): AssetReferenceCandidate | null;
+export declare function resolveGenericAssetReference(projectDir: string, value: unknown): AssetReferenceCandidate | null;
+export declare function isReadyAssetReference(reference: AssetReferenceCandidate | null | undefined): reference is AssetReferenceCandidate & {
+    relPath: string;
+    absPath: string;
+};

package/dist/commands/_shared/build-backdrop-prompt.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Convert a storyboard `backdrop` cue into a safer image-generation prompt.
+ *
+ * Backdrops are normally background plates; scene HTML owns the exact text,
+ * logos, charts, and UI. Keeping that contract explicit reduces unrelated
+ * product-photo drift and avoids generated typography competing with overlays.
+ */
+export declare function augmentBackdropPrompt(cue: string): string;

package/dist/commands/_shared/build-backdrop-prompt.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/_shared/build-cache.d.ts

@@ -0,0 +1,37 @@
+export type BuildAssetKind = "narration" | "backdrop" | "video" | "music";
+export interface CacheAssetDescriptor {
+    key: string;
+    path: string;
+    ext: string;
+}
+export declare function cacheAssetDescriptor(kind: BuildAssetKind, parts: Record<string, unknown>): CacheAssetDescriptor;
+export declare function narrationCacheDescriptor(opts: {
+    beatId: string;
+    cue: string;
+    provider: string;
+    voice?: unknown;
+    ext: "mp3" | "wav";
+}): CacheAssetDescriptor;
+export declare function backdropCacheDescriptor(opts: {
+    beatId: string;
+    cue: string;
+    provider: string;
+    quality: "standard" | "hd";
+    size: string;
+    ratio?: string;
+}): CacheAssetDescriptor;
+export declare function imageRatioForSize(size: string | undefined): string;
+export declare function videoCacheDescriptor(opts: {
+    beatId: string;
+    cue: string;
+    provider: string;
+    duration: number | undefined;
+}): CacheAssetDescriptor;
+export declare function musicCacheDescriptor(opts: {
+    beatId: string;
+    cue: string;
+    provider: string;
+    duration: number | undefined;
+}): CacheAssetDescriptor;
+export declare function normalizeVideoDuration(duration: number | undefined): number;
+export declare function normalizeMusicDuration(duration: number | undefined): number;