@vibeframe/cli 0.54.0 → 0.55.1

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

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