@vibeframe/cli 0.105.1 → 0.106.0

package/dist/tools/define-tool.d.ts

@@ -0,0 +1,82 @@
+/**
+ * @module define-tool
+ * @description Single source of truth DSL for VibeFrame tool definitions.
+ *
+ * Each tool is declared once via `defineTool({...})` with a Zod schema, an
+ * `execute` function, and metadata. The MCP server (`packages/mcp-server`)
+ * and the in-process Agent (`packages/cli/src/agent/tools`) both consume the
+ * manifest via thin adapters — no tool definition is ever duplicated across
+ * surfaces.
+ *
+ * The CLI Commander tree (`packages/cli/src/commands/*.ts`) is intentionally
+ * left hand-written. Its short flags, `--no-foo` negations, variadic args,
+ * and custom validators don't fit cleanly into a metadata sidecar. The
+ * Commander chains call the same `executeXxx` engine functions that the
+ * manifest entries call, so the CLI stays in sync via the existing
+ * `cli-sync.test.ts` invariant.
+ *
+ * See `/Users/kiyeonjeon/.claude/plans/logical-wibbling-sonnet.md` for the
+ * full v0.65 migration plan.
+ */
+import { z, type ZodTypeAny } from "zod";
+import { type ProductSurface } from "../commands/_shared/product-surface.js";
+export type CostTier = "free" | "low" | "medium" | "high" | "very-high";
+export type Surface = "mcp" | "agent";
+export interface ExecuteContext {
+    /** Resolves relative paths in tool args (`process.cwd()` for MCP/CLI; `AgentContext.workingDirectory` for Agent). */
+    workingDirectory: string;
+    /** The surface invoking the tool. Lets executes branch on JSON vs human output if needed. */
+    surface: "cli" | Surface;
+    /**
+     * Agent-only mutable state. Populated when invoked via the in-process agent
+     * REPL; `undefined` for MCP/CLI. Tools that read or set the "current
+     * project" pointer (e.g. project_open/project_save) declare
+     * `surfaces: ["agent"]` and access this via `ctx.agent?`.
+     */
+    agent?: {
+        projectPath: string | null;
+        setProjectPath(path: string): void;
+    };
+}
+export interface ToolExecuteResult {
+    success: boolean;
+    /** JSON-stringifiable payload. MCP returns `JSON.stringify(data)`; Agent uses humanLines first, falls back to data. */
+    data?: Record<string, unknown>;
+    /** Human-readable lines for Agent REPL output. Optional — adapter falls back to JSON if absent. */
+    humanLines?: readonly string[];
+    error?: string;
+}
+export interface ToolDefinition<S extends ZodTypeAny = ZodTypeAny> {
+    /** snake_case canonical name (used by MCP `tools/list` and Agent registry). */
+    name: string;
+    /** Group this tool belongs to ("scene" | "audio" | "edit" | …). Drives skill regen + sync-counts. */
+    category: string;
+    /** Cost tier from `.claude/rules/architecture.md` cost table. */
+    cost: CostTier;
+    /** Product-facing command classification. Transport surfaces use `surfaces`. */
+    productSurface?: ProductSurface;
+    /** Preferred replacement when `productSurface` is legacy. */
+    replacement?: string;
+    /** Short explanation for product-surface routing. */
+    note?: string;
+    /** Identical for MCP description and Agent description. One paragraph. */
+    description: string;
+    /** Single source of truth for argument shape. Must be a `z.object({...})`. */
+    schema: S;
+    /** Surfaces the tool lives on. Defaults to `["mcp", "agent"]` when omitted. */
+    surfaces?: readonly Surface[];
+    /** Engine fn. Receives Zod-validated args. */
+    execute: (args: z.infer<S>, ctx: ExecuteContext) => Promise<ToolExecuteResult>;
+}
+/**
+ * Type erasure helper for collecting tools into the manifest array.
+ *
+ * `ToolDefinition` is generic over the Zod schema type, so a heterogeneous
+ * array of tools each with different schemas can't directly satisfy
+ * `ToolDefinition<ZodTypeAny>[]` (Zod's generic is invariant). At the
+ * manifest aggregation boundary we cast individual tools to this erased
+ * shape — the adapters use `tool.schema.safeParse()` which doesn't need the
+ * narrow type.
+ */
+export type AnyTool = ToolDefinition<ZodTypeAny>;
+export declare function defineTool<S extends ZodTypeAny>(t: ToolDefinition<S>): ToolDefinition<S>;

package/dist/tools/define-tool.js

@@ -0,0 +1,214 @@
+import { createRequire as __vfCreateRequire } from 'node:module';
+const require = __vfCreateRequire(import.meta.url);
+
+// src/commands/_shared/product-surface.ts
+var EXPLICIT_COMMAND_METADATA = {
+  setup: { surface: "public", note: "Initial configuration helper." },
+  init: { surface: "public", note: "Storyboard-to-video cold-start entrypoint." },
+  plan: { surface: "public", note: "Storyboard-to-video planning contract." },
+  build: { surface: "public", note: "Primary storyboard-to-video build engine." },
+  render: { surface: "public", note: "Project render entrypoint." },
+  doctor: { surface: "public", note: "System and provider health check." },
+  guide: { surface: "public", note: "Workflow chooser and first-run guidance." },
+  demo: { surface: "advanced", note: "Smoke-test/demo helper, not a core workflow." },
+  run: { surface: "agent", note: "Automation surface for YAML pipelines." },
+  context: { surface: "agent", note: "Host-agent integration contract." },
+  schema: { surface: "agent", note: "Machine-readable command discovery." },
+  completion: { surface: "advanced", note: "Shell ergonomics helper." },
+  agent: {
+    surface: "advanced",
+    note: "Optional fallback REPL; external coding agents are the primary workflow."
+  },
+  "generate.image": { surface: "public" },
+  "generate.video": { surface: "public" },
+  "generate.narration": { surface: "public", note: "Product-facing TTS command." },
+  "generate.speech": {
+    surface: "legacy",
+    replacement: "vibe generate narration",
+    note: "Compatibility alias for product-facing narration generation."
+  },
+  "generate.sound-effect": { surface: "public" },
+  "generate.music": { surface: "public" },
+  "generate.thumbnail": { surface: "public" },
+  "generate.music-status": {
+    surface: "legacy",
+    replacement: "vibe status job <job-id> --json",
+    note: "Provider-task polling primitive retained for compatibility."
+  },
+  "generate.video-status": {
+    surface: "legacy",
+    replacement: "vibe status job <job-id> --json",
+    note: "Provider-task polling primitive retained for compatibility."
+  },
+  "generate.storyboard": {
+    surface: "legacy",
+    replacement: "vibe init --from <brief> or vibe storyboard revise",
+    note: "Project-ready storyboard drafting belongs in init/revise."
+  },
+  "generate.background": {
+    surface: "legacy",
+    replacement: "vibe generate image or vibe build --stage assets",
+    note: "Backdrops are generated through image generation or the project build."
+  },
+  "generate.motion": {
+    surface: "advanced",
+    replacement: "vibe edit motion-overlay or vibe build --stage compose",
+    note: "Standalone motion generation is a power primitive."
+  },
+  "generate.video-cancel": { surface: "advanced", note: "Provider lifecycle control." },
+  "generate.video-extend": { surface: "advanced", note: "Provider lifecycle control." },
+  "edit.caption": { surface: "public" },
+  "edit.silence-cut": { surface: "public" },
+  "edit.jump-cut": { surface: "public" },
+  "edit.reframe": { surface: "public" },
+  "edit.upscale": { surface: "public" },
+  "edit.noise-reduce": { surface: "public" },
+  "edit.fade": { surface: "advanced" },
+  "edit.translate-srt": { surface: "advanced" },
+  "edit.fill-gaps": { surface: "advanced" },
+  "edit.motion-overlay": { surface: "advanced" },
+  "edit.grade": { surface: "advanced" },
+  "edit.text-overlay": { surface: "advanced" },
+  "edit.speed-ramp": { surface: "advanced" },
+  "edit.image": { surface: "advanced" },
+  "edit.interpolate": { surface: "advanced" },
+  "edit.animated-caption": {
+    surface: "legacy",
+    replacement: "vibe remix animated-caption",
+    note: "Use the remix command for animated caption workflows."
+  },
+  "inspect.project": { surface: "public" },
+  "inspect.render": { surface: "public" },
+  "inspect.media": { surface: "public" },
+  "inspect.video": {
+    surface: "legacy",
+    replacement: "vibe inspect media",
+    note: "Compatibility alias for media understanding."
+  },
+  "inspect.review": {
+    surface: "legacy",
+    replacement: "vibe inspect render --ai",
+    note: "Project render review now lives under inspect render."
+  },
+  "inspect.suggest": {
+    surface: "advanced",
+    note: "Suggestion primitive; reports should drive host-agent edits."
+  },
+  "audio.transcribe": { surface: "public" },
+  "audio.dub": { surface: "public" },
+  "audio.duck": { surface: "public" },
+  "audio.isolate": { surface: "advanced" },
+  "audio.clone-voice": {
+    surface: "advanced",
+    note: "Requires explicit user consent for voice cloning."
+  },
+  "audio.list-voices": { surface: "advanced", note: "Provider discovery helper." },
+  "remix.highlights": { surface: "public" },
+  "remix.auto-shorts": { surface: "public" },
+  "remix.animated-caption": { surface: "public" },
+  "remix.regenerate-scene": {
+    surface: "legacy",
+    replacement: "vibe build <project> --beat <id> --force --json",
+    note: "Scene regeneration belongs in the project build flow."
+  },
+  "storyboard.validate": { surface: "public" },
+  "storyboard.revise": { surface: "public" },
+  "storyboard.list": { surface: "agent" },
+  "storyboard.get": { surface: "agent" },
+  "storyboard.set": { surface: "agent" },
+  "storyboard.move": { surface: "agent" },
+  "status.job": { surface: "public" },
+  "status.project": { surface: "public" },
+  "scene.list-styles": { surface: "public" },
+  "scene.lint": { surface: "agent" },
+  "scene.repair": { surface: "agent" },
+  "scene.add": { surface: "advanced" },
+  "scene.install-skill": {
+    surface: "internal",
+    note: "Build/init installs the host-agent composition skill when needed."
+  },
+  "scene.compose-prompts": {
+    surface: "internal",
+    note: "Agent-mode build primitive; prefer vibe build --mode agent."
+  },
+  "project.create": {
+    surface: "legacy",
+    replacement: "vibe timeline create",
+    note: "Legacy timeline project alias."
+  },
+  "project.info": {
+    surface: "legacy",
+    replacement: "vibe timeline info",
+    note: "Legacy timeline project alias."
+  }
+};
+function productSurfaceForCommandPath(path) {
+  const explicit = EXPLICIT_COMMAND_METADATA[path];
+  if (explicit) return explicit;
+  if (path.startsWith("timeline.")) {
+    return { surface: "advanced", note: "Power tool for low-level timeline JSON edits." };
+  }
+  if (path.startsWith("batch.")) {
+    return { surface: "advanced", note: "Power tool for bulk timeline/media operations." };
+  }
+  if (path.startsWith("media.")) {
+    return { surface: "advanced", note: "Script utility for media metadata." };
+  }
+  if (path.startsWith("detect.")) return { surface: "public" };
+  if (path.startsWith("export.")) {
+    return { surface: "advanced", note: "Lower-level export helper." };
+  }
+  if (path.startsWith("fs.")) {
+    return { surface: "internal", note: "In-process agent filesystem helper." };
+  }
+  return { surface: "advanced" };
+}
+function commandPathFromToolName(name) {
+  if (["init", "plan", "build", "render", "guide"].includes(name)) return name;
+  if (name.startsWith("fs_")) return name.replace("_", ".");
+  const firstUnderscore = name.indexOf("_");
+  if (firstUnderscore === -1) return name;
+  const group = name.slice(0, firstUnderscore);
+  const leaf = name.slice(firstUnderscore + 1).replace(/_/g, "-");
+  return `${group}.${leaf}`;
+}
+function productSurfaceForToolName(name) {
+  return productSurfaceForCommandPath(commandPathFromToolName(name));
+}
+
+// src/tools/define-tool.ts
+var NAME_PATTERN = /^[a-z][a-z0-9]*(_[a-z0-9]+)*$/;
+function validateToolDefinition(t) {
+  if (!NAME_PATTERN.test(t.name)) {
+    throw new Error(
+      `Tool name "${t.name}" must be snake_case (matches /^[a-z][a-z0-9]*(_[a-z0-9]+)*$/)`
+    );
+  }
+  if (!t.category || !/^[a-z-]+$/.test(t.category)) {
+    throw new Error(
+      `Tool "${t.name}" has invalid category "${t.category}" (must be lowercase, dash-separated)`
+    );
+  }
+  const schemaTypeName = t.schema._def?.typeName;
+  if (schemaTypeName !== "ZodObject") {
+    throw new Error(`Tool "${t.name}" schema must be a z.object({...}); got ${schemaTypeName}`);
+  }
+  if (t.surfaces && t.surfaces.length === 0) {
+    throw new Error(
+      `Tool "${t.name}" has empty surfaces array; use [] only via explicit type override`
+    );
+  }
+}
+function defineTool(t) {
+  validateToolDefinition(t);
+  const surface = productSurfaceForToolName(t.name);
+  return {
+    ...t,
+    productSurface: t.productSurface ?? surface.surface,
+    replacement: t.replacement ?? surface.replacement,
+    note: t.note ?? surface.note
+  };
+}
+export {
+  defineTool
+};

package/dist/tools/manifest/_project-io.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @module manifest/_project-io
+ * @description Shared load/save helpers for timeline JSON files. Used by
+ * timeline + project manifest entries to read/write the on-disk timeline
+ * state. Mirrors the helpers previously embedded in
+ * `packages/mcp-server/src/tools/project.ts`.
+ */
+import { Project } from "../../engine/index.js";
+export declare function loadProject(projectPath: string, cwd: string): Promise<{
+    project: Project;
+    absPath: string;
+}>;
+export declare function saveProject(absPath: string, project: Project): Promise<void>;

package/dist/tools/manifest/agent-only.d.ts

@@ -0,0 +1,236 @@
+/**
+ * @module manifest/agent-only
+ * @description Tools that only make sense inside the in-process agent REPL —
+ * filesystem access (`fs_*`), project-level batch operations (`batch_*`),
+ * and FFmpeg-driven media wrappers (`media_*`).
+ *
+ * These all use `surfaces: ["agent"]` so the MCP adapter filters them out.
+ * MCP clients have their own host-side filesystem affordances and would
+ * never call into our handler shell anyway.
+ *
+ * Dependencies are deliberately limited to Node `fs` + `@vibeframe/core`
+ * (Project class) + `execSafe`/`ffprobeDuration`. No AI provider SDKs —
+ * adding any would balloon the mcp-server esbuild bundle even though the
+ * entries never reach MCP at runtime.
+ */
+import { z } from "zod";
+import { type AnyTool } from "../define-tool.js";
+export declare const fsListTool: import("../define-tool.js").ToolDefinition<z.ZodObject<{
+    path: z.ZodOptional<z.ZodString>;
+    pattern: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    path?: string | undefined;
+    pattern?: string | undefined;
+}, {
+    path?: string | undefined;
+    pattern?: string | undefined;
+}>>;
+export declare const fsReadTool: import("../define-tool.js").ToolDefinition<z.ZodObject<{
+    path: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+}, {
+    path: string;
+}>>;
+export declare const fsWriteTool: import("../define-tool.js").ToolDefinition<z.ZodObject<{
+    path: z.ZodString;
+    content: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    content: string;
+}, {
+    path: string;
+    content: string;
+}>>;
+export declare const fsExistsTool: import("../define-tool.js").ToolDefinition<z.ZodObject<{
+    path: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+}, {
+    path: string;
+}>>;
+export declare const batchImportTool: import("../define-tool.js").ToolDefinition<z.ZodObject<{
+    project: z.ZodString;
+    directory: z.ZodString;
+    recursive: z.ZodOptional<z.ZodBoolean>;
+    filter: z.ZodOptional<z.ZodString>;
+    imageDuration: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    project: string;
+    directory: string;
+    filter?: string | undefined;
+    recursive?: boolean | undefined;
+    imageDuration?: number | undefined;
+}, {
+    project: string;
+    directory: string;
+    filter?: string | undefined;
+    recursive?: boolean | undefined;
+    imageDuration?: number | undefined;
+}>>;
+export declare const batchConcatTool: import("../define-tool.js").ToolDefinition<z.ZodObject<{
+    project: z.ZodString;
+    sourceIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    useAll: z.ZodOptional<z.ZodBoolean>;
+    trackId: z.ZodOptional<z.ZodString>;
+    startTime: z.ZodOptional<z.ZodNumber>;
+    gap: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    project: string;
+    trackId?: string | undefined;
+    startTime?: number | undefined;
+    gap?: number | undefined;
+    sourceIds?: string[] | undefined;
+    useAll?: boolean | undefined;
+}, {
+    project: string;
+    trackId?: string | undefined;
+    startTime?: number | undefined;
+    gap?: number | undefined;
+    sourceIds?: string[] | undefined;
+    useAll?: boolean | undefined;
+}>>;
+export declare const batchApplyEffectTool: import("../define-tool.js").ToolDefinition<z.ZodObject<{
+    project: z.ZodString;
+    clipIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    useAll: z.ZodOptional<z.ZodBoolean>;
+    effectType: z.ZodEnum<["fadeIn", "fadeOut", "blur", "brightness", "contrast", "saturation", "speed", "volume"]>;
+    duration: z.ZodOptional<z.ZodNumber>;
+    params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    project: string;
+    effectType: "fadeIn" | "fadeOut" | "blur" | "brightness" | "contrast" | "saturation" | "speed" | "volume";
+    duration?: number | undefined;
+    params?: Record<string, unknown> | undefined;
+    clipIds?: string[] | undefined;
+    useAll?: boolean | undefined;
+}, {
+    project: string;
+    effectType: "fadeIn" | "fadeOut" | "blur" | "brightness" | "contrast" | "saturation" | "speed" | "volume";
+    duration?: number | undefined;
+    params?: Record<string, unknown> | undefined;
+    clipIds?: string[] | undefined;
+    useAll?: boolean | undefined;
+}>>;
+export declare const timelineClearTool: import("../define-tool.js").ToolDefinition<z.ZodObject<{
+    project: z.ZodString;
+    what: z.ZodOptional<z.ZodEnum<["clips", "tracks", "sources", "all"]>>;
+    keepTracks: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    project: string;
+    what?: "tracks" | "clips" | "sources" | "all" | undefined;
+    keepTracks?: boolean | undefined;
+}, {
+    project: string;
+    what?: "tracks" | "clips" | "sources" | "all" | undefined;
+    keepTracks?: boolean | undefined;
+}>>;
+export declare const projectSetTool: import("../define-tool.js").ToolDefinition<z.ZodObject<{
+    projectPath: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    aspectRatio: z.ZodOptional<z.ZodEnum<["16:9", "9:16", "1:1", "4:5"]>>;
+    fps: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    projectPath: string;
+    name?: string | undefined;
+    aspectRatio?: "16:9" | "9:16" | "1:1" | "4:5" | undefined;
+    fps?: number | undefined;
+}, {
+    projectPath: string;
+    name?: string | undefined;
+    aspectRatio?: "16:9" | "9:16" | "1:1" | "4:5" | undefined;
+    fps?: number | undefined;
+}>>;
+export declare const projectOpenTool: import("../define-tool.js").ToolDefinition<z.ZodObject<{
+    projectPath: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    projectPath: string;
+}, {
+    projectPath: string;
+}>>;
+export declare const projectSaveTool: import("../define-tool.js").ToolDefinition<z.ZodObject<{
+    projectPath: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    projectPath?: string | undefined;
+}, {
+    projectPath?: string | undefined;
+}>>;
+export declare const exportAudioTool: import("../define-tool.js").ToolDefinition<z.ZodObject<{
+    project: z.ZodString;
+    output: z.ZodOptional<z.ZodString>;
+    format: z.ZodOptional<z.ZodEnum<["mp3", "wav", "aac"]>>;
+}, "strip", z.ZodTypeAny, {
+    project: string;
+    output?: string | undefined;
+    format?: "mp3" | "wav" | "aac" | undefined;
+}, {
+    project: string;
+    output?: string | undefined;
+    format?: "mp3" | "wav" | "aac" | undefined;
+}>>;
+export declare const exportSubtitlesTool: import("../define-tool.js").ToolDefinition<z.ZodObject<{
+    project: z.ZodString;
+    output: z.ZodOptional<z.ZodString>;
+    format: z.ZodOptional<z.ZodEnum<["srt", "vtt"]>>;
+}, "strip", z.ZodTypeAny, {
+    project: string;
+    output?: string | undefined;
+    format?: "srt" | "vtt" | undefined;
+}, {
+    project: string;
+    output?: string | undefined;
+    format?: "srt" | "vtt" | undefined;
+}>>;
+export declare const mediaInfoTool: import("../define-tool.js").ToolDefinition<z.ZodObject<{
+    path: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+}, {
+    path: string;
+}>>;
+export declare const mediaCompressTool: import("../define-tool.js").ToolDefinition<z.ZodObject<{
+    input: z.ZodString;
+    output: z.ZodOptional<z.ZodString>;
+    quality: z.ZodOptional<z.ZodEnum<["low", "medium", "high"]>>;
+    maxSize: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    input: string;
+    output?: string | undefined;
+    quality?: "high" | "low" | "medium" | undefined;
+    maxSize?: string | undefined;
+}, {
+    input: string;
+    output?: string | undefined;
+    quality?: "high" | "low" | "medium" | undefined;
+    maxSize?: string | undefined;
+}>>;
+export declare const mediaConvertTool: import("../define-tool.js").ToolDefinition<z.ZodObject<{
+    input: z.ZodString;
+    output: z.ZodString;
+    codec: z.ZodOptional<z.ZodString>;
+    audioCodec: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    output: string;
+    input: string;
+    audioCodec?: string | undefined;
+    codec?: string | undefined;
+}, {
+    output: string;
+    input: string;
+    audioCodec?: string | undefined;
+    codec?: string | undefined;
+}>>;
+export declare const mediaConcatTool: import("../define-tool.js").ToolDefinition<z.ZodObject<{
+    inputs: z.ZodArray<z.ZodString, "many">;
+    output: z.ZodString;
+    reencode: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    output: string;
+    inputs: string[];
+    reencode?: boolean | undefined;
+}, {
+    output: string;
+    inputs: string[];
+    reencode?: boolean | undefined;
+}>>;
+export declare const agentOnlyTools: readonly AnyTool[];

package/dist/tools/manifest/audio.d.ts

@@ -0,0 +1,93 @@
+/**
+ * @module manifest/audio
+ * @description Audio post-processing tools.
+ *   audio_transcribe (Whisper), audio_isolate (ElevenLabs vocals isolation),
+ *   audio_clone_voice (ElevenLabs IVC), audio_dub (Whisper+Claude+ElevenLabs),
+ *   audio_duck (FFmpeg sidechain).
+ */
+import { z } from "zod";
+import { type AnyTool } from "../define-tool.js";
+export declare const audioTranscribeTool: import("../define-tool.js").ToolDefinition<z.ZodObject<{
+    audioPath: z.ZodString;
+    language: z.ZodOptional<z.ZodString>;
+    output: z.ZodOptional<z.ZodString>;
+    format: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    audioPath: string;
+    output?: string | undefined;
+    format?: string | undefined;
+    language?: string | undefined;
+}, {
+    audioPath: string;
+    output?: string | undefined;
+    format?: string | undefined;
+    language?: string | undefined;
+}>>;
+export declare const audioIsolateTool: import("../define-tool.js").ToolDefinition<z.ZodObject<{
+    audioPath: z.ZodString;
+    output: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    audioPath: string;
+    output?: string | undefined;
+}, {
+    audioPath: string;
+    output?: string | undefined;
+}>>;
+export declare const audioVoiceCloneTool: import("../define-tool.js").ToolDefinition<z.ZodObject<{
+    samplePaths: z.ZodArray<z.ZodString, "many">;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    removeNoise: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    samplePaths: string[];
+    description?: string | undefined;
+    removeNoise?: boolean | undefined;
+}, {
+    name: string;
+    samplePaths: string[];
+    description?: string | undefined;
+    removeNoise?: boolean | undefined;
+}>>;
+export declare const audioDubTool: import("../define-tool.js").ToolDefinition<z.ZodObject<{
+    mediaPath: z.ZodString;
+    language: z.ZodString;
+    source: z.ZodOptional<z.ZodString>;
+    voice: z.ZodOptional<z.ZodString>;
+    analyzeOnly: z.ZodOptional<z.ZodBoolean>;
+    output: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    language: string;
+    mediaPath: string;
+    output?: string | undefined;
+    source?: string | undefined;
+    voice?: string | undefined;
+    analyzeOnly?: boolean | undefined;
+}, {
+    language: string;
+    mediaPath: string;
+    output?: string | undefined;
+    source?: string | undefined;
+    voice?: string | undefined;
+    analyzeOnly?: boolean | undefined;
+}>>;
+export declare const audioDuckTool: import("../define-tool.js").ToolDefinition<z.ZodObject<{
+    musicPath: z.ZodString;
+    voicePath: z.ZodString;
+    output: z.ZodOptional<z.ZodString>;
+    threshold: z.ZodOptional<z.ZodString>;
+    ratio: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    musicPath: string;
+    voicePath: string;
+    output?: string | undefined;
+    ratio?: string | undefined;
+    threshold?: string | undefined;
+}, {
+    musicPath: string;
+    voicePath: string;
+    output?: string | undefined;
+    ratio?: string | undefined;
+    threshold?: string | undefined;
+}>>;
+export declare const audioTools: readonly AnyTool[];

package/dist/tools/manifest/detect.d.ts

@@ -0,0 +1,47 @@
+/**
+ * @module manifest/detect
+ * @description FFmpeg-based detection (scenes, silence, beats). Free, no
+ * API keys.
+ */
+import { z } from "zod";
+import { type AnyTool } from "../define-tool.js";
+export declare const detectScenesTool: import("../define-tool.js").ToolDefinition<z.ZodObject<{
+    videoPath: z.ZodString;
+    threshold: z.ZodOptional<z.ZodNumber>;
+    outputPath: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    videoPath: string;
+    outputPath?: string | undefined;
+    threshold?: number | undefined;
+}, {
+    videoPath: string;
+    outputPath?: string | undefined;
+    threshold?: number | undefined;
+}>>;
+export declare const detectSilenceTool: import("../define-tool.js").ToolDefinition<z.ZodObject<{
+    mediaPath: z.ZodString;
+    noise: z.ZodOptional<z.ZodString>;
+    duration: z.ZodOptional<z.ZodString>;
+    outputPath: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    mediaPath: string;
+    duration?: string | undefined;
+    outputPath?: string | undefined;
+    noise?: string | undefined;
+}, {
+    mediaPath: string;
+    duration?: string | undefined;
+    outputPath?: string | undefined;
+    noise?: string | undefined;
+}>>;
+export declare const detectBeatsTool: import("../define-tool.js").ToolDefinition<z.ZodObject<{
+    audioPath: z.ZodString;
+    outputPath: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    audioPath: string;
+    outputPath?: string | undefined;
+}, {
+    audioPath: string;
+    outputPath?: string | undefined;
+}>>;
+export declare const detectTools: readonly AnyTool[];