@vibeframe/cli 0.27.0

package/dist/agent/tools/integration.test.js

@@ -0,0 +1,659 @@
+/**
+ * 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
+ */
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { ToolRegistry } from "./index.js";
+import { registerProjectTools } from "./project.js";
+import { registerTimelineTools } from "./timeline.js";
+import { registerFilesystemTools } from "./filesystem.js";
+import { registerMediaTools } from "./media.js";
+import { registerAITools } from "./ai.js";
+import { registerExportTools } from "./export.js";
+import { registerBatchTools } from "./batch.js";
+// Mock the imported CLI functions to avoid actual API calls
+vi.mock("../../commands/ai-script-pipeline.js", () => ({
+    executeScriptToVideo: vi.fn().mockResolvedValue({
+        success: true,
+        outputDir: "/test/output",
+        scenes: 3,
+        storyboardPath: "/test/output/storyboard.json",
+        projectPath: "/test/output/project.vibe.json",
+        narrations: ["/test/output/narration-1.mp3"],
+        images: ["/test/output/scene-1.png"],
+        videos: ["/test/output/scene-1.mp4"],
+        totalDuration: 30,
+        failedScenes: [],
+    }),
+    executeRegenerateScene: vi.fn().mockResolvedValue({ success: true }),
+}));
+vi.mock("../../commands/ai-highlights.js", () => ({
+    executeHighlights: vi.fn().mockResolvedValue({
+        success: true,
+        highlights: [
+            {
+                index: 1,
+                startTime: 10,
+                endTime: 25,
+                duration: 15,
+                category: "emotional",
+                confidence: 0.95,
+                reason: "Test highlight",
+                transcript: "Test transcript",
+            },
+        ],
+        totalDuration: 120,
+        totalHighlightDuration: 15,
+    }),
+    executeAutoShorts: vi.fn().mockResolvedValue({
+        success: true,
+        shorts: [
+            {
+                index: 1,
+                startTime: 30,
+                endTime: 60,
+                duration: 30,
+                confidence: 0.9,
+                reason: "Viral moment",
+                outputPath: "/test/short-1.mp4",
+            },
+        ],
+    }),
+}));
+vi.mock("../../commands/ai-animated-caption.js", () => ({
+    executeAnimatedCaption: vi.fn().mockResolvedValue({
+        success: true,
+        outputPath: "/test/captioned.mp4",
+        wordCount: 42,
+        groupCount: 10,
+        style: "highlight",
+        tier: "remotion",
+    }),
+}));
+vi.mock("../../commands/ai-analyze.js", () => ({
+    executeGeminiVideo: vi.fn().mockResolvedValue({
+        success: true,
+        response: "This is a test video summary.",
+        model: "gemini-3-flash-preview",
+        totalTokens: 1000,
+    }),
+    executeAnalyze: vi.fn().mockResolvedValue({
+        success: true,
+        response: "Test analysis",
+    }),
+}));
+vi.mock("../../commands/ai-edit.js", () => ({
+    executeSilenceCut: vi.fn().mockResolvedValue({
+        success: true,
+        outputPath: "/test/video-cut.mp4",
+        totalDuration: 120,
+        silentPeriods: [
+            { start: 10, end: 15, duration: 5 },
+            { start: 60, end: 63, duration: 3 },
+        ],
+        silentDuration: 8,
+    }),
+    executeJumpCut: vi.fn().mockResolvedValue({
+        success: true,
+        outputPath: "/test/video-jumpcut.mp4",
+        totalDuration: 120,
+        fillerCount: 5,
+        fillerDuration: 3.2,
+        fillers: [
+            { word: "um", start: 5.1, end: 5.6 },
+            { word: "like", start: 12.3, end: 12.8 },
+        ],
+    }),
+    executeCaption: vi.fn().mockResolvedValue({
+        success: true,
+        outputPath: "/test/video-captioned.mp4",
+        srtPath: "/test/video-captioned.srt",
+        segmentCount: 12,
+    }),
+    executeNoiseReduce: vi.fn().mockResolvedValue({
+        success: true,
+        outputPath: "/test/audio-denoised.mp4",
+        inputDuration: 60,
+    }),
+    executeFade: vi.fn().mockResolvedValue({
+        success: true,
+        outputPath: "/test/video-faded.mp4",
+        totalDuration: 120,
+        fadeInApplied: true,
+        fadeOutApplied: true,
+    }),
+    executeTranslateSrt: vi.fn().mockResolvedValue({
+        success: true,
+        outputPath: "/test/subtitles-ko.srt",
+        segmentCount: 20,
+        sourceLanguage: "en",
+        targetLanguage: "ko",
+    }),
+    executeTextOverlay: vi.fn().mockResolvedValue({
+        success: true,
+        outputPath: "/test/video-overlay.mp4",
+    }),
+    DEFAULT_FILLER_WORDS: ["um", "uh", "like", "you know"],
+    detectFillerRanges: vi.fn(),
+}));
+vi.mock("../../commands/ai-review.js", () => ({
+    executeReview: vi.fn().mockResolvedValue({
+        success: true,
+        issues: [],
+    }),
+}));
+vi.mock("../../commands/ai-image.js", () => ({
+    executeThumbnailBestFrame: vi.fn().mockResolvedValue({
+        success: true,
+        outputPath: "/test/video-thumbnail.png",
+        timestamp: 15.5,
+        reason: "Best composed frame",
+    }),
+    executeGeminiEdit: vi.fn().mockResolvedValue({
+        success: true,
+        outputPath: "/test/edited.png",
+    }),
+}));
+describe("CLI ↔ Agent Tool Synchronization", () => {
+    let registry;
+    beforeEach(() => {
+        registry = new ToolRegistry();
+        registerProjectTools(registry);
+        registerTimelineTools(registry);
+        registerFilesystemTools(registry);
+        registerMediaTools(registry);
+        registerAITools(registry);
+        registerExportTools(registry);
+        registerBatchTools(registry);
+    });
+    describe("Tool Registration", () => {
+        it("should register all 57 tools", () => {
+            const tools = registry.getAll();
+            expect(tools.length).toBe(58);
+        });
+        it("should register all project tools (5)", () => {
+            const projectTools = [
+                "project_create",
+                "project_info",
+                "project_set",
+                "project_open",
+                "project_save",
+            ];
+            for (const name of projectTools) {
+                expect(registry.get(name)).toBeDefined();
+            }
+        });
+        it("should register all timeline tools (11)", () => {
+            const timelineTools = [
+                "timeline_add_source",
+                "timeline_add_clip",
+                "timeline_add_track",
+                "timeline_add_effect",
+                "timeline_trim",
+                "timeline_split",
+                "timeline_move",
+                "timeline_clear",
+                "timeline_delete",
+                "timeline_duplicate",
+                "timeline_list",
+            ];
+            for (const name of timelineTools) {
+                expect(registry.get(name)).toBeDefined();
+            }
+        });
+        it("should register all filesystem tools (4)", () => {
+            const fsTools = ["fs_list", "fs_read", "fs_write", "fs_exists"];
+            for (const name of fsTools) {
+                expect(registry.get(name)).toBeDefined();
+            }
+        });
+        it("should register all media tools (8)", () => {
+            const mediaTools = [
+                "media_info",
+                "detect_scenes",
+                "detect_silence",
+                "detect_beats",
+                "audio_transcribe",
+                "media_compress",
+                "media_convert",
+                "media_concat",
+            ];
+            for (const name of mediaTools) {
+                expect(registry.get(name)).toBeDefined();
+            }
+        });
+        it("should register all batch tools (3)", () => {
+            const batchTools = [
+                "batch_import",
+                "batch_concat",
+                "batch_apply_effect",
+            ];
+            for (const name of batchTools) {
+                expect(registry.get(name)).toBeDefined();
+            }
+        });
+        it("should register all AI tools (23)", () => {
+            const aiTools = [
+                // Generation tools (8)
+                "generate_image",
+                "generate_video",
+                "generate_speech",
+                "generate_sound_effect",
+                "generate_music",
+                "generate_storyboard",
+                "generate_motion",
+                "generate_thumbnail",
+                // Edit tools (8)
+                "edit_text_overlay",
+                "edit_silence_cut",
+                "edit_jump_cut",
+                "edit_caption",
+                "edit_noise_reduce",
+                "edit_fade",
+                "edit_translate_srt",
+                "edit_image",
+                // Analyze tools (3)
+                "analyze_review",
+                "analyze_video",
+                "analyze_media",
+                // Pipeline tools (4)
+                "pipeline_script_to_video",
+                "pipeline_highlights",
+                "pipeline_auto_shorts",
+                "pipeline_regenerate_scene",
+            ];
+            for (const name of aiTools) {
+                expect(registry.get(name)).toBeDefined();
+            }
+        });
+        it("should register all export tools (3)", () => {
+            const exportTools = ["export_video", "export_audio", "export_subtitles"];
+            for (const name of exportTools) {
+                expect(registry.get(name)).toBeDefined();
+            }
+        });
+    });
+    describe("Tool Definition Schema Validation", () => {
+        it("all tools should have valid definitions", () => {
+            const tools = registry.getAll();
+            for (const tool of tools) {
+                expect(tool.name).toBeTruthy();
+                expect(tool.description).toBeTruthy();
+                expect(tool.parameters).toBeDefined();
+                expect(tool.parameters.type).toBe("object");
+                expect(tool.parameters.properties).toBeDefined();
+            }
+        });
+        it("all tools should have required parameters listed", () => {
+            const tools = registry.getAll();
+            for (const tool of tools) {
+                if (tool.parameters.required && tool.parameters.required.length > 0) {
+                    for (const requiredParam of tool.parameters.required) {
+                        expect(tool.parameters.properties[requiredParam]).toBeDefined();
+                    }
+                }
+            }
+        });
+        it("all parameter properties should have type and description", () => {
+            const tools = registry.getAll();
+            for (const tool of tools) {
+                for (const paramDef of Object.values(tool.parameters.properties)) {
+                    const param = paramDef;
+                    expect(param.type).toBeTruthy();
+                    expect(param.description).toBeTruthy();
+                }
+            }
+        });
+    });
+    describe("AI Pipeline Tools - Parameter Mapping", () => {
+        describe("pipeline_script_to_video", () => {
+            it("should have all CLI options as parameters", () => {
+                const tool = registry.get("pipeline_script_to_video");
+                expect(tool).toBeDefined();
+                const params = tool.parameters.properties;
+                // Required
+                expect(params.script).toBeDefined();
+                // Optional (matching CLI options)
+                expect(params.outputDir).toBeDefined();
+                expect(params.duration).toBeDefined();
+                expect(params.voice).toBeDefined();
+                expect(params.generator).toBeDefined();
+                expect(params.imageProvider).toBeDefined();
+                expect(params.aspectRatio).toBeDefined();
+                expect(params.imagesOnly).toBeDefined();
+                expect(params.noVoiceover).toBeDefined();
+                expect(params.retries).toBeDefined();
+            });
+            it("should have correct enum values for generator", () => {
+                const tool = registry.get("pipeline_script_to_video");
+                const generator = tool.parameters.properties.generator;
+                expect(generator.enum).toContain("runway");
+                expect(generator.enum).toContain("kling");
+            });
+            it("should have correct enum values for imageProvider", () => {
+                const tool = registry.get("pipeline_script_to_video");
+                const imageProvider = tool.parameters.properties.imageProvider;
+                expect(imageProvider.enum).toContain("openai");
+                expect(imageProvider.enum).toContain("gemini");
+            });
+            it("should have correct enum values for aspectRatio", () => {
+                const tool = registry.get("pipeline_script_to_video");
+                const aspectRatio = tool.parameters.properties.aspectRatio;
+                expect(aspectRatio.enum).toContain("16:9");
+                expect(aspectRatio.enum).toContain("9:16");
+                expect(aspectRatio.enum).toContain("1:1");
+            });
+        });
+        describe("pipeline_highlights", () => {
+            it("should have all CLI options as parameters", () => {
+                const tool = registry.get("pipeline_highlights");
+                expect(tool).toBeDefined();
+                const params = tool.parameters.properties;
+                // Required
+                expect(params.media).toBeDefined();
+                // Optional (matching CLI options)
+                expect(params.output).toBeDefined();
+                expect(params.project).toBeDefined();
+                expect(params.duration).toBeDefined();
+                expect(params.count).toBeDefined();
+                expect(params.threshold).toBeDefined();
+                expect(params.criteria).toBeDefined();
+                expect(params.language).toBeDefined();
+                expect(params.useGemini).toBeDefined();
+                expect(params.lowRes).toBeDefined();
+            });
+            it("should have correct enum values for criteria", () => {
+                const tool = registry.get("pipeline_highlights");
+                const criteria = tool.parameters.properties.criteria;
+                expect(criteria.enum).toContain("emotional");
+                expect(criteria.enum).toContain("informative");
+                expect(criteria.enum).toContain("funny");
+                expect(criteria.enum).toContain("all");
+            });
+        });
+        describe("pipeline_auto_shorts", () => {
+            it("should have all CLI options as parameters", () => {
+                const tool = registry.get("pipeline_auto_shorts");
+                expect(tool).toBeDefined();
+                const params = tool.parameters.properties;
+                // Required
+                expect(params.video).toBeDefined();
+                // Optional (matching CLI options)
+                expect(params.outputDir).toBeDefined();
+                expect(params.duration).toBeDefined();
+                expect(params.count).toBeDefined();
+                expect(params.aspect).toBeDefined();
+                expect(params.addCaptions).toBeDefined();
+                expect(params.captionStyle).toBeDefined();
+                expect(params.analyzeOnly).toBeDefined();
+                expect(params.language).toBeDefined();
+                expect(params.useGemini).toBeDefined();
+                expect(params.lowRes).toBeDefined();
+            });
+            it("should have correct enum values for aspect", () => {
+                const tool = registry.get("pipeline_auto_shorts");
+                const aspect = tool.parameters.properties.aspect;
+                expect(aspect.enum).toContain("9:16");
+                expect(aspect.enum).toContain("1:1");
+            });
+            it("should have correct enum values for captionStyle", () => {
+                const tool = registry.get("pipeline_auto_shorts");
+                const captionStyle = tool.parameters.properties.captionStyle;
+                expect(captionStyle.enum).toContain("minimal");
+                expect(captionStyle.enum).toContain("bold");
+                expect(captionStyle.enum).toContain("animated");
+            });
+        });
+        describe("analyze_video", () => {
+            it("should have all CLI options as parameters", () => {
+                const tool = registry.get("analyze_video");
+                expect(tool).toBeDefined();
+                const params = tool.parameters.properties;
+                // Required
+                expect(params.source).toBeDefined();
+                expect(params.prompt).toBeDefined();
+                // Optional (matching CLI options)
+                expect(params.model).toBeDefined();
+                expect(params.fps).toBeDefined();
+                expect(params.start).toBeDefined();
+                expect(params.end).toBeDefined();
+                expect(params.lowRes).toBeDefined();
+            });
+            it("should have correct enum values for model", () => {
+                const tool = registry.get("analyze_video");
+                const model = tool.parameters.properties.model;
+                expect(model.enum).toContain("flash");
+                expect(model.enum).toContain("flash-2.5");
+                expect(model.enum).toContain("pro");
+            });
+        });
+    });
+    describe("Tool Handler Execution (Mocked)", () => {
+        const mockContext = {
+            workingDirectory: "/test/workdir",
+            projectPath: "/test/project.vibe.json",
+        };
+        describe("pipeline_script_to_video handler", () => {
+            it("should call executeScriptToVideo with correct parameters", async () => {
+                const { executeScriptToVideo } = await import("../../commands/ai-script-pipeline.js");
+                const handler = registry.getHandler("pipeline_script_to_video");
+                expect(handler).toBeDefined();
+                const result = await handler({
+                    script: "Test script. Scene two. Conclusion.",
+                    outputDir: "output",
+                    generator: "runway",
+                    imageProvider: "gemini",
+                    aspectRatio: "16:9",
+                }, mockContext);
+                expect(executeScriptToVideo).toHaveBeenCalledWith(expect.objectContaining({
+                    script: "Test script. Scene two. Conclusion.",
+                    generator: "runway",
+                    imageProvider: "gemini",
+                    aspectRatio: "16:9",
+                }));
+                expect(result.success).toBe(true);
+                expect(result.output).toContain("Script-to-Video complete");
+            });
+            it("should handle failure gracefully", async () => {
+                const { executeScriptToVideo } = await import("../../commands/ai-script-pipeline.js");
+                vi.mocked(executeScriptToVideo).mockResolvedValueOnce({
+                    success: false,
+                    outputDir: "/test/output",
+                    scenes: 0,
+                    error: "API key missing",
+                });
+                const handler = registry.getHandler("pipeline_script_to_video");
+                const result = await handler({ script: "Test" }, mockContext);
+                expect(result.success).toBe(false);
+                expect(result.error).toContain("API key missing");
+            });
+        });
+        describe("pipeline_highlights handler", () => {
+            it("should call executeHighlights with correct parameters", async () => {
+                const { executeHighlights } = await import("../../commands/ai-highlights.js");
+                const handler = registry.getHandler("pipeline_highlights");
+                expect(handler).toBeDefined();
+                const result = await handler({
+                    media: "video.mp4",
+                    duration: 60,
+                    criteria: "emotional",
+                    useGemini: true,
+                }, mockContext);
+                expect(executeHighlights).toHaveBeenCalledWith(expect.objectContaining({
+                    media: "/test/workdir/video.mp4",
+                    duration: 60,
+                    criteria: "emotional",
+                    useGemini: true,
+                }));
+                expect(result.success).toBe(true);
+                expect(result.output).toContain("Found 1 highlights");
+            });
+        });
+        describe("pipeline_auto_shorts handler", () => {
+            it("should call executeAutoShorts with correct parameters", async () => {
+                const { executeAutoShorts } = await import("../../commands/ai-highlights.js");
+                const handler = registry.getHandler("pipeline_auto_shorts");
+                expect(handler).toBeDefined();
+                const result = await handler({
+                    video: "long-video.mp4",
+                    count: 3,
+                    duration: 45,
+                    aspect: "9:16",
+                }, mockContext);
+                expect(executeAutoShorts).toHaveBeenCalledWith(expect.objectContaining({
+                    video: "/test/workdir/long-video.mp4",
+                    count: 3,
+                    duration: 45,
+                    aspect: "9:16",
+                }));
+                expect(result.success).toBe(true);
+                expect(result.output).toContain("Generated 1 short");
+            });
+            it("should handle analyzeOnly mode", async () => {
+                const handler = registry.getHandler("pipeline_auto_shorts");
+                const result = await handler({
+                    video: "video.mp4",
+                    analyzeOnly: true,
+                }, mockContext);
+                expect(result.success).toBe(true);
+            });
+        });
+        describe("analyze_video handler", () => {
+            it("should call executeGeminiVideo with correct parameters", async () => {
+                const { executeGeminiVideo } = await import("../../commands/ai-analyze.js");
+                const handler = registry.getHandler("analyze_video");
+                expect(handler).toBeDefined();
+                const result = await handler({
+                    source: "video.mp4",
+                    prompt: "Summarize this video",
+                    model: "flash",
+                }, mockContext);
+                expect(executeGeminiVideo).toHaveBeenCalledWith(expect.objectContaining({
+                    source: "/test/workdir/video.mp4",
+                    prompt: "Summarize this video",
+                    model: "flash",
+                }));
+                expect(result.success).toBe(true);
+                expect(result.output).toContain("test video summary");
+            });
+            it("should handle YouTube URLs without modification", async () => {
+                const { executeGeminiVideo } = await import("../../commands/ai-analyze.js");
+                const handler = registry.getHandler("analyze_video");
+                await handler({
+                    source: "https://youtube.com/watch?v=test",
+                    prompt: "Summarize",
+                }, mockContext);
+                expect(executeGeminiVideo).toHaveBeenCalledWith(expect.objectContaining({
+                    source: "https://youtube.com/watch?v=test",
+                }));
+            });
+        });
+    });
+    describe("Tool Categories Match CLAUDE.md Documentation", () => {
+        it("should have correct tool counts per category", () => {
+            const allTools = registry.getAll();
+            const projectTools = allTools.filter((t) => t.name.startsWith("project_"));
+            const timelineTools = allTools.filter((t) => t.name.startsWith("timeline_"));
+            const fsTools = allTools.filter((t) => t.name.startsWith("fs_"));
+            const mediaTools = allTools.filter((t) => t.name.startsWith("media_") ||
+                t.name.startsWith("detect_") ||
+                t.name.startsWith("audio_"));
+            const generateTools = allTools.filter((t) => t.name.startsWith("generate_"));
+            const editTools = allTools.filter((t) => t.name.startsWith("edit_"));
+            const analyzeTools = allTools.filter((t) => t.name.startsWith("analyze_"));
+            const pipelineTools = allTools.filter((t) => t.name.startsWith("pipeline_"));
+            const exportTools = allTools.filter((t) => t.name.startsWith("export_"));
+            const batchTools = allTools.filter((t) => t.name.startsWith("batch_"));
+            expect(projectTools.length).toBe(5);
+            expect(timelineTools.length).toBe(11); // Added timeline_clear
+            expect(fsTools.length).toBe(4);
+            expect(mediaTools.length).toBe(8); // Added media_compress, media_convert, media_concat
+            expect(generateTools.length).toBe(8); // image, video, speech, sound_effect, music, storyboard, motion, thumbnail
+            expect(editTools.length).toBe(8); // text_overlay, silence_cut, jump_cut, caption, noise_reduce, fade, translate_srt, image
+            expect(analyzeTools.length).toBe(3); // video, media, review
+            expect(pipelineTools.length).toBe(5); // script_to_video, highlights, auto_shorts, regenerate_scene, animated_caption
+            expect(exportTools.length).toBe(3);
+            expect(batchTools.length).toBe(3);
+            // Total: 5+11+4+8+8+8+3+4+3+3 = 57
+            const totalTools = projectTools.length +
+                timelineTools.length +
+                fsTools.length +
+                mediaTools.length +
+                generateTools.length +
+                editTools.length +
+                analyzeTools.length +
+                pipelineTools.length +
+                exportTools.length +
+                batchTools.length;
+            expect(totalTools).toBe(58);
+        });
+    });
+});
+describe("Exported CLI Functions", () => {
+    describe("Function signatures match Agent tool parameters", () => {
+        it("executeScriptToVideo accepts ScriptToVideoOptions", async () => {
+            // Type check - this will fail at compile time if signatures don't match
+            const { executeScriptToVideo } = await import("../../commands/ai-script-pipeline.js");
+            expect(typeof executeScriptToVideo).toBe("function");
+        });
+        it("executeHighlights accepts HighlightsOptions", async () => {
+            const { executeHighlights } = await import("../../commands/ai-highlights.js");
+            expect(typeof executeHighlights).toBe("function");
+        });
+        it("executeAutoShorts accepts AutoShortsOptions", async () => {
+            const { executeAutoShorts } = await import("../../commands/ai-highlights.js");
+            expect(typeof executeAutoShorts).toBe("function");
+        });
+        it("executeGeminiVideo accepts GeminiVideoOptions", async () => {
+            const { executeGeminiVideo } = await import("../../commands/ai-analyze.js");
+            expect(typeof executeGeminiVideo).toBe("function");
+        });
+    });
+});
+describe("Tool Name Consistency", () => {
+    let registry;
+    beforeEach(() => {
+        registry = new ToolRegistry();
+        registerProjectTools(registry);
+        registerTimelineTools(registry);
+        registerFilesystemTools(registry);
+        registerMediaTools(registry);
+        registerAITools(registry);
+        registerExportTools(registry);
+        registerBatchTools(registry);
+    });
+    it("all tool names should follow naming convention", () => {
+        const tools = registry.getAll();
+        const validPrefixes = [
+            "project_",
+            "timeline_",
+            "fs_",
+            "media_",
+            "detect_",
+            "audio_",
+            "generate_",
+            "edit_",
+            "analyze_",
+            "pipeline_",
+            "export_",
+            "batch_",
+        ];
+        for (const tool of tools) {
+            const hasValidPrefix = validPrefixes.some((prefix) => tool.name.startsWith(prefix));
+            expect(hasValidPrefix).toBe(true);
+        }
+    });
+    it("all tool names should be lowercase with underscores", () => {
+        const tools = registry.getAll();
+        const validNamePattern = /^[a-z_]+$/;
+        for (const tool of tools) {
+            expect(tool.name).toMatch(validNamePattern);
+        }
+    });
+});
+//# sourceMappingURL=integration.test.js.map