@vibeframe/cli 0.27.0

package/src/agent/tools/integration.test.ts

@@ -0,0 +1,775 @@
+/**
+ * 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: ToolRegistry;
+
+  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 as { type?: string; description?: string };
+          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 as {
+          enum?: string[];
+        };
+        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 as {
+          enum?: string[];
+        };
+        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 as {
+          enum?: string[];
+        };
+        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 as {
+          enum?: string[];
+        };
+        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 as { enum?: string[] };
+        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 as {
+          enum?: string[];
+        };
+        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 as { enum?: string[] };
+        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: ToolRegistry;
+
+  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);
+    }
+  });
+});