@vibeframe/cli 0.27.0

package/src/agent/tools/export.ts

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

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

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