@vibeframe/cli 0.27.0 → 0.29.0

package/src/agent/tools/export.ts

@@ -1,184 +0,0 @@
-/**
- * Export Tools - Export projects to video, audio, or subtitles
- */
-
-import { resolve, basename } from "node:path";
-import type { ToolRegistry, ToolHandler } from "./index.js";
-import type { ToolDefinition, ToolResult } from "../types.js";
-import { runExport } from "../../commands/export.js";
-
-// Tool Definitions
-const exportVideoDef: ToolDefinition = {
-  name: "export_video",
-  description: "Export a project to a video file",
-  parameters: {
-    type: "object",
-    properties: {
-      project: {
-        type: "string",
-        description: "Project file path",
-      },
-      output: {
-        type: "string",
-        description: "Output video file path",
-      },
-      format: {
-        type: "string",
-        description: "Output format (mp4, webm, mov)",
-        enum: ["mp4", "webm", "mov"],
-      },
-      preset: {
-        type: "string",
-        description: "Quality preset (draft, standard, high, ultra)",
-        enum: ["draft", "standard", "high", "ultra"],
-      },
-      overwrite: {
-        type: "boolean",
-        description: "Overwrite existing file",
-      },
-    },
-    required: ["project"],
-  },
-};
-
-const exportAudioDef: ToolDefinition = {
-  name: "export_audio",
-  description: "Export audio track from a project",
-  parameters: {
-    type: "object",
-    properties: {
-      project: {
-        type: "string",
-        description: "Project file path",
-      },
-      output: {
-        type: "string",
-        description: "Output audio file path",
-      },
-      format: {
-        type: "string",
-        description: "Output format (mp3, wav, aac)",
-        enum: ["mp3", "wav", "aac"],
-      },
-    },
-    required: ["project"],
-  },
-};
-
-const exportSubtitlesDef: ToolDefinition = {
-  name: "export_subtitles",
-  description: "Export subtitles from transcription",
-  parameters: {
-    type: "object",
-    properties: {
-      project: {
-        type: "string",
-        description: "Project file path",
-      },
-      output: {
-        type: "string",
-        description: "Output subtitle file path",
-      },
-      format: {
-        type: "string",
-        description: "Subtitle format (srt, vtt)",
-        enum: ["srt", "vtt"],
-      },
-    },
-    required: ["project"],
-  },
-};
-
-// Tool Handlers
-const exportVideo: ToolHandler = async (args, context): Promise<ToolResult> => {
-  const projectPath = args.project as string;
-  const format = (args.format as string) || "mp4";
-  const preset = (args.preset as "draft" | "standard" | "high" | "ultra") || "standard";
-  const overwrite = (args.overwrite as boolean) || false;
-
-  // Determine output path
-  const output = (args.output as string) ||
-    `${basename(projectPath, ".vibe.json")}.${format}`;
-
-  const absProjectPath = resolve(context.workingDirectory, projectPath);
-  const absOutputPath = resolve(context.workingDirectory, output);
-
-  try {
-    const result = await runExport(absProjectPath, absOutputPath, {
-      format: format as "mp4" | "webm" | "mov",
-      preset,
-      overwrite,
-    });
-
-    if (!result.success) {
-      return {
-        toolCallId: "",
-        success: false,
-        output: "",
-        error: result.message,
-      };
-    }
-
-    return {
-      toolCallId: "",
-      success: true,
-      output: `Video exported: ${output}\nFormat: ${format}\nPreset: ${preset}`,
-    };
-  } catch (error) {
-    return {
-      toolCallId: "",
-      success: false,
-      output: "",
-      error: `Failed to export video: ${error instanceof Error ? error.message : String(error)}`,
-    };
-  }
-};
-
-const exportAudio: ToolHandler = async (_args, _context): Promise<ToolResult> => {
-
-  try {
-    // Audio export would be implemented similarly to video export
-    // For now, provide a helpful message
-    return {
-      toolCallId: "",
-      success: false,
-      output: "",
-      error: "Audio-only export not yet implemented. Use export_video and extract audio with FFmpeg: ffmpeg -i video.mp4 -vn -acodec mp3 audio.mp3",
-    };
-  } catch (error) {
-    return {
-      toolCallId: "",
-      success: false,
-      output: "",
-      error: `Failed to export audio: ${error instanceof Error ? error.message : String(error)}`,
-    };
-  }
-};
-
-const exportSubtitles: ToolHandler = async (_args, _context): Promise<ToolResult> => {
-
-  try {
-    // Subtitle export would extract transcription data from project
-    // For now, provide a helpful message
-    return {
-      toolCallId: "",
-      success: false,
-      output: "",
-      error: "Subtitle export not yet implemented. Use ai_transcribe to generate subtitles from audio: ai_transcribe audio.mp3 --output subtitles.srt",
-    };
-  } catch (error) {
-    return {
-      toolCallId: "",
-      success: false,
-      output: "",
-      error: `Failed to export subtitles: ${error instanceof Error ? error.message : String(error)}`,
-    };
-  }
-};
-
-// Registration function
-export function registerExportTools(registry: ToolRegistry): void {
-  registry.register(exportVideoDef, exportVideo);
-  registry.register(exportAudioDef, exportAudio);
-  registry.register(exportSubtitlesDef, exportSubtitles);
-}

package/src/agent/tools/filesystem.ts

@@ -1,237 +0,0 @@
-/**
- * Filesystem Tools - List, read, write, and check files
- */
-
-import { readFile, writeFile, readdir, stat, access } from "node:fs/promises";
-import { resolve, join } from "node:path";
-import type { ToolRegistry, ToolHandler } from "./index.js";
-import type { ToolDefinition, ToolResult } from "../types.js";
-
-// Tool Definitions
-const listDef: ToolDefinition = {
-  name: "fs_list",
-  description: "List files and directories in a path",
-  parameters: {
-    type: "object",
-    properties: {
-      path: {
-        type: "string",
-        description: "Directory path (default: current directory)",
-      },
-      pattern: {
-        type: "string",
-        description: "Filter pattern (e.g., *.mp4, *.json)",
-      },
-    },
-    required: [],
-  },
-};
-
-const readDef: ToolDefinition = {
-  name: "fs_read",
-  description: "Read contents of a text file",
-  parameters: {
-    type: "object",
-    properties: {
-      path: {
-        type: "string",
-        description: "File path to read",
-      },
-    },
-    required: ["path"],
-  },
-};
-
-const writeDef: ToolDefinition = {
-  name: "fs_write",
-  description: "Write content to a file",
-  parameters: {
-    type: "object",
-    properties: {
-      path: {
-        type: "string",
-        description: "File path to write",
-      },
-      content: {
-        type: "string",
-        description: "Content to write",
-      },
-    },
-    required: ["path", "content"],
-  },
-};
-
-const existsDef: ToolDefinition = {
-  name: "fs_exists",
-  description: "Check if a file or directory exists",
-  parameters: {
-    type: "object",
-    properties: {
-      path: {
-        type: "string",
-        description: "Path to check",
-      },
-    },
-    required: ["path"],
-  },
-};
-
-// Helper to match glob pattern
-function matchPattern(filename: string, pattern: string): boolean {
-  // Simple glob matching (* = any characters)
-  const regex = new RegExp(
-    "^" +
-      pattern
-        .replace(/\./g, "\\.")
-        .replace(/\*/g, ".*")
-        .replace(/\?/g, ".") +
-      "$",
-    "i"
-  );
-  return regex.test(filename);
-}
-
-// Format file size
-function formatSize(bytes: number): string {
-  const units = ["B", "KB", "MB", "GB"];
-  let size = bytes;
-  let unit = 0;
-  while (size >= 1024 && unit < units.length - 1) {
-    size /= 1024;
-    unit++;
-  }
-  return `${size.toFixed(1)}${units[unit]}`;
-}
-
-// Tool Handlers
-const list: ToolHandler = async (args, context): Promise<ToolResult> => {
-  const dirPath = (args.path as string) || ".";
-  const pattern = args.pattern as string | undefined;
-
-  try {
-    const absPath = resolve(context.workingDirectory, dirPath);
-    const entries = await readdir(absPath, { withFileTypes: true });
-
-    const results: string[] = [];
-    for (const entry of entries) {
-      // Filter by pattern if provided
-      if (pattern && !matchPattern(entry.name, pattern)) {
-        continue;
-      }
-
-      const fullPath = join(absPath, entry.name);
-      const stats = await stat(fullPath);
-
-      if (entry.isDirectory()) {
-        results.push(`[DIR]  ${entry.name}/`);
-      } else {
-        results.push(`[FILE] ${entry.name} (${formatSize(stats.size)})`);
-      }
-    }
-
-    if (results.length === 0) {
-      return {
-        toolCallId: "",
-        success: true,
-        output: pattern ? `No files matching "${pattern}" in ${dirPath}` : `Directory is empty: ${dirPath}`,
-      };
-    }
-
-    return {
-      toolCallId: "",
-      success: true,
-      output: `Contents of ${dirPath}:\n${results.join("\n")}`,
-    };
-  } catch (error) {
-    return {
-      toolCallId: "",
-      success: false,
-      output: "",
-      error: `Failed to list directory: ${error instanceof Error ? error.message : String(error)}`,
-    };
-  }
-};
-
-const read: ToolHandler = async (args, context): Promise<ToolResult> => {
-  const filePath = args.path as string;
-
-  try {
-    const absPath = resolve(context.workingDirectory, filePath);
-    const content = await readFile(absPath, "utf-8");
-
-    // Truncate if too long
-    const maxLength = 4000;
-    const truncated = content.length > maxLength;
-    const output = truncated
-      ? content.substring(0, maxLength) + "\n... (truncated)"
-      : content;
-
-    return {
-      toolCallId: "",
-      success: true,
-      output: `Contents of ${filePath}:\n${output}`,
-    };
-  } catch (error) {
-    return {
-      toolCallId: "",
-      success: false,
-      output: "",
-      error: `Failed to read file: ${error instanceof Error ? error.message : String(error)}`,
-    };
-  }
-};
-
-const write: ToolHandler = async (args, context): Promise<ToolResult> => {
-  const filePath = args.path as string;
-  const content = args.content as string;
-
-  try {
-    const absPath = resolve(context.workingDirectory, filePath);
-    await writeFile(absPath, content, "utf-8");
-
-    return {
-      toolCallId: "",
-      success: true,
-      output: `File written: ${filePath} (${formatSize(content.length)})`,
-    };
-  } catch (error) {
-    return {
-      toolCallId: "",
-      success: false,
-      output: "",
-      error: `Failed to write file: ${error instanceof Error ? error.message : String(error)}`,
-    };
-  }
-};
-
-const exists: ToolHandler = async (args, context): Promise<ToolResult> => {
-  const filePath = args.path as string;
-
-  try {
-    const absPath = resolve(context.workingDirectory, filePath);
-    await access(absPath);
-
-    const stats = await stat(absPath);
-    const type = stats.isDirectory() ? "directory" : "file";
-
-    return {
-      toolCallId: "",
-      success: true,
-      output: `${type} exists: ${filePath}`,
-    };
-  } catch {
-    return {
-      toolCallId: "",
-      success: true,
-      output: `Does not exist: ${filePath}`,
-    };
-  }
-};
-
-// Registration function
-export function registerFilesystemTools(registry: ToolRegistry): void {
-  registry.register(listDef, list);
-  registry.register(readDef, read);
-  registry.register(writeDef, write);
-  registry.register(existsDef, exists);
-}

package/src/agent/tools/index.ts

@@ -1,150 +0,0 @@
-/**
- * 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>;
-
-interface RegisteredTool {
-  definition: ToolDefinition;
-  handler: ToolHandler;
-}
-
-/**
- * Tool Registry class
- * Manages tool definitions and execution
- */
-export class ToolRegistry {
-  private tools: Map<string, RegisteredTool> = new Map();
-
-  /**
-   * Register a tool
-   */
-  register(definition: ToolDefinition, handler: ToolHandler): void {
-    this.tools.set(definition.name, { definition, handler });
-  }
-
-  /**
-   * Get all tool definitions
-   */
-  getDefinitions(): ToolDefinition[] {
-    return Array.from(this.tools.values()).map((t) => t.definition);
-  }
-
-  /**
-   * Get a specific tool definition
-   */
-  getDefinition(name: string): ToolDefinition | undefined {
-    return this.tools.get(name)?.definition;
-  }
-
-  /**
-   * Get a specific tool definition (alias for getDefinition)
-   */
-  get(name: string): ToolDefinition | undefined {
-    return this.getDefinition(name);
-  }
-
-  /**
-   * Get all tool definitions (alias for getDefinitions)
-   */
-  getAll(): ToolDefinition[] {
-    return this.getDefinitions();
-  }
-
-  /**
-   * Get a tool handler by name
-   */
-  getHandler(name: string): ToolHandler | undefined {
-    return this.tools.get(name)?.handler;
-  }
-
-  /**
-   * Execute a tool
-   */
-  async execute(
-    name: string,
-    args: Record<string, unknown>,
-    context: AgentContext
-  ): Promise<ToolResult> {
-    const tool = this.tools.get(name);
-    if (!tool) {
-      return {
-        toolCallId: "",
-        success: false,
-        output: "",
-        error: `Unknown tool: ${name}`,
-      };
-    }
-
-    try {
-      return await tool.handler(args, context);
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      return {
-        toolCallId: "",
-        success: false,
-        output: "",
-        error: errorMessage,
-      };
-    }
-  }
-
-  /**
-   * Check if a tool exists
-   */
-  has(name: string): boolean {
-    return this.tools.has(name);
-  }
-
-  /**
-   * Get tool count
-   */
-  get size(): number {
-    return this.tools.size;
-  }
-
-  /**
-   * List all tool names
-   */
-  list(): string[] {
-    return Array.from(this.tools.keys());
-  }
-}
-
-// Global registry instance
-export const toolRegistry = new ToolRegistry();
-
-// Re-export tool modules
-export { registerProjectTools } from "./project.js";
-export { registerTimelineTools } from "./timeline.js";
-export { registerFilesystemTools } from "./filesystem.js";
-export { registerMediaTools } from "./media.js";
-export { registerAITools } from "./ai.js";
-export { registerExportTools } from "./export.js";
-export { registerBatchTools } from "./batch.js";
-
-/**
- * Register all tools
- */
-export async function registerAllTools(registry: ToolRegistry): Promise<void> {
-  const { registerProjectTools } = await import("./project.js");
-  const { registerTimelineTools } = await import("./timeline.js");
-  const { registerFilesystemTools } = await import("./filesystem.js");
-  const { registerMediaTools } = await import("./media.js");
-  const { registerAITools } = await import("./ai.js");
-  const { registerExportTools } = await import("./export.js");
-  const { registerBatchTools } = await import("./batch.js");
-
-  registerProjectTools(registry);
-  registerTimelineTools(registry);
-  registerFilesystemTools(registry);
-  registerMediaTools(registry);
-  registerAITools(registry);
-  registerExportTools(registry);
-  registerBatchTools(registry);
-}