@vibeframe/cli 0.104.3 → 0.105.2

package/dist/pipeline/executor.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Pipeline executor — maps YAML actions to CLI execute functions.
+ */
+import type { PipelineManifest, PipelineAction, PipelineBudget, PipelineResult } from "./types.js";
+export interface PipelineActionMetadata {
+    id: PipelineAction;
+    title: string;
+    category: "generate" | "edit" | "audio" | "detect" | "analyze" | "scene" | "export";
+    command?: string;
+    outputs: readonly string[];
+    requiredKeys?: readonly string[];
+}
+export declare function getPipelineActionMetadata(action?: PipelineAction): PipelineActionMetadata[] | PipelineActionMetadata | undefined;
+export declare function loadPipeline(filePath: string): Promise<PipelineManifest>;
+export interface ExecutePipelineOptions {
+    /** Output directory for all step outputs */
+    outputDir?: string;
+    /** Only validate and show plan, don't execute */
+    dryRun?: boolean;
+    /** Resume from checkpoint (skip completed steps) */
+    resume?: boolean;
+    /** Stop on first failure */
+    failFast?: boolean;
+    /** Override manifest.budget (partial merge) */
+    budget?: PipelineBudget;
+}
+export declare function executePipeline(manifest: PipelineManifest, options?: ExecutePipelineOptions): Promise<PipelineResult>;

package/dist/pipeline/generate-actions.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/pipeline/index.d.ts

@@ -0,0 +1,3 @@
+export { executePipeline, loadPipeline } from "./executor.js";
+export type { PipelineManifest, PipelineAction, StepResult, PipelineResult } from "./types.js";
+export type { ExecutePipelineOptions } from "./executor.js";

package/dist/pipeline/renderers/__tests__/html-template.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/pipeline/renderers/__tests__/integration.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/pipeline/renderers/chrome.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @module pipeline/renderers/chrome
+ *
+ * Shared Chrome/Chromium discovery + preflight used by every Hyperframes-
+ * backed renderer (the FFmpeg-bridge backend in `hyperframes.ts` and the
+ * direct scene renderer in `commands/_shared/scene-render.ts`). Centralised
+ * so that adding a new candidate path or env var only touches one file.
+ */
+/**
+ * Walk the candidate list in priority order (env vars first, then puppeteer's
+ * cache, then well-known system locations). Returns the first existing path,
+ * or undefined when none are present.
+ */
+export declare function findChrome(): string | undefined;
+/**
+ * Returns `{ok: true}` when Chrome is available, otherwise a structured
+ * `{ok: false, reason}` with installation guidance. Used by both the
+ * `RenderBackend.preflight` interface and the standalone scene render path.
+ */
+export declare function preflightChrome(): Promise<{
+    ok: true;
+} | {
+    ok: false;
+    reason: string;
+}>;

package/dist/pipeline/renderers/html-clips.d.ts

@@ -0,0 +1,19 @@
+import type { TimelineState } from "@vibeframe/core";
+export declare function relAsset(url: string): string;
+export declare function buildClipElements(state: TimelineState): string;
+export interface HfMediaElement {
+    elementId: string;
+    src: string;
+    startTime: number;
+    endTime: number;
+    mediaOffset: number;
+    volume: number;
+    hasAudio: boolean;
+}
+export declare function buildMediaDeclarations(state: TimelineState): HfMediaElement[];
+export declare function buildClipRuntimeData(state: TimelineState): {
+    id: string;
+    startTime: number;
+    duration: number;
+    effects: import("@vibeframe/core").Effect[];
+}[];

package/dist/pipeline/renderers/html-runtime.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Browser-side runtime script embedded into the generated HTML.
+ * Implements window.__hf.seek(t) and effect application.
+ * Kept as a string template so it can be embedded inline without a bundler.
+ */
+export declare const RUNTIME_SCRIPT = "\n(function () {\n  var CLIPS = /*CLIPS_JSON*/[];\n\n  function interpolate(kfs, t) {\n    if (!kfs || kfs.length === 0) return null;\n    if (kfs.length === 1) return kfs[0].values;\n    var prev = kfs[0], next = kfs[kfs.length - 1];\n    for (var i = 0; i < kfs.length - 1; i++) {\n      if (t >= kfs[i].time && t <= kfs[i + 1].time) { prev = kfs[i]; next = kfs[i + 1]; break; }\n    }\n    if (t <= prev.time) return prev.values;\n    if (t >= next.time) return next.values;\n    var raw = (t - prev.time) / (next.time - prev.time);\n    var e = prev.easing || 'linear';\n    var p = e === 'easeIn' ? raw * raw\n           : e === 'easeOut' ? raw * (2 - raw)\n           : e === 'easeInOut' ? (raw < 0.5 ? 2 * raw * raw : -1 + (4 - 2 * raw) * raw)\n           : raw;\n    var out = {};\n    for (var k in prev.values) {\n      var a = +prev.values[k], b = +next.values[k];\n      out[k] = isNaN(a) || isNaN(b) ? prev.values[k] : a + (b - a) * p;\n    }\n    return out;\n  }\n\n  function applyEffects(el, effects, clipTime) {\n    var opacity = 1;\n    var filters = [];\n    for (var i = 0; i < effects.length; i++) {\n      var fx = effects[i];\n      var t = clipTime - fx.startTime;\n      if (t < 0 || t > fx.duration) continue;\n      var vals = (fx.keyframes && fx.keyframes.length > 0)\n        ? interpolate(fx.keyframes, t)\n        : fx.params;\n      if (!vals) continue;\n      switch (fx.type) {\n        case 'fadeIn':\n          opacity = Math.min(opacity, t / fx.duration * (+(vals.intensity || 1))); break;\n        case 'fadeOut':\n          opacity = Math.min(opacity, (1 - t / fx.duration) * (+(vals.intensity || 1))); break;\n        case 'blur':\n          filters.push('blur(' + (+vals.radius || 0) + 'px)'); break;\n        case 'brightness':\n          filters.push('brightness(' + (+vals.value || 1) + ')'); break;\n        case 'contrast':\n          filters.push('contrast(' + (+vals.value || 1) + ')'); break;\n        case 'saturation':\n          filters.push('saturate(' + (+vals.value || 1) + ')'); break;\n      }\n    }\n    el.style.opacity = String(opacity);\n    if (filters.length > 0) el.style.filter = filters.join(' ');\n    else el.style.filter = '';\n  }\n\n  window.__hf = {\n    duration: /*DURATION*/0,\n    media: /*MEDIA_JSON*/[],\n    seek: function (t) {\n      for (var i = 0; i < CLIPS.length; i++) {\n        var c = CLIPS[i];\n        var el = document.getElementById(c.id);\n        if (!el) continue;\n        var active = t >= c.startTime && t < c.startTime + c.duration;\n        el.style.display = active ? 'block' : 'none';\n        if (active) applyEffects(el, c.effects, t - c.startTime);\n      }\n    }\n  };\n})();\n";

package/dist/pipeline/renderers/html-template.d.ts

@@ -0,0 +1,2 @@
+import type { TimelineState } from "@vibeframe/core";
+export declare function generateCompositionHtml(state: TimelineState): string;

package/dist/pipeline/renderers/hyperframes.d.ts

@@ -0,0 +1,7 @@
+import type { RenderBackend } from "./types.js";
+export declare function createHyperframesBackend(): RenderBackend;
+export declare function aspectToResolution(ratio: string): {
+    width: number;
+    height: number;
+};
+export declare function qualityToCrf(quality?: "draft" | "standard" | "high"): number;

package/dist/pipeline/renderers/project-builder.d.ts

@@ -0,0 +1,7 @@
+import type { TimelineState } from "@vibeframe/core";
+export interface TempProject {
+    dir: string;
+    cleanup: () => Promise<void>;
+}
+export declare function buildTempProject(state: TimelineState, projectFileDir?: string): Promise<TempProject>;
+export declare function resolveSourceUrl(url: string, baseDir?: string): string;

package/dist/pipeline/renderers/types.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Render backend abstraction for VibeFrame rendering.
+ *
+ * Backends implement RenderBackend so `vibe render` and YAML render steps can
+ * target FFmpeg, Hyperframes, or future renderers through one contract.
+ *
+ * Renderer details live with each backend implementation.
+ */
+import type { TimelineState } from "@vibeframe/core";
+export type BackendName = "ffmpeg" | "hyperframes";
+export interface RenderOptions {
+    projectState: TimelineState;
+    outputPath: string;
+    fps?: 24 | 30 | 60;
+    quality?: "draft" | "standard" | "high";
+    format?: "mp4" | "webm" | "mov";
+    /** Hyperframes capture worker count. Defaults to 1 (sequential) — auto-worker mode times out on small comps. */
+    workers?: number;
+    onProgress?: (pct: number, stage: string) => void;
+    signal?: AbortSignal;
+}
+export interface RenderResult {
+    success: boolean;
+    outputPath?: string;
+    durationMs?: number;
+    framesRendered?: number;
+    error?: string;
+}
+export interface RenderBackend {
+    name: BackendName;
+    /** Human-readable check before invocation (e.g. Chrome present, FFmpeg version). */
+    preflight?(): Promise<{
+        ok: true;
+    } | {
+        ok: false;
+        reason: string;
+    }>;
+    render(options: RenderOptions): Promise<RenderResult>;
+}

package/dist/pipeline/resolver.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Variable resolver for pipeline steps.
+ *
+ * Resolves:
+ * - $step_id.output  → output path from a previous step
+ * - $step_id.data.X  → arbitrary data from a previous step result
+ * - ${ENV_VAR}       → environment variable
+ */
+import type { StepResult } from "./types.js";
+/**
+ * Resolve all variable references in a step's parameters.
+ * Returns a new object with all $refs replaced by actual values.
+ */
+export declare function resolveStepParams(params: Record<string, unknown>, completedSteps: Map<string, StepResult>): Record<string, unknown>;
+/**
+ * Validate that all $refs in a step can be resolved.
+ * Returns list of unresolvable references.
+ */
+export declare function findUnresolvedRefs(params: Record<string, unknown>, availableStepIds: Set<string>): string[];

package/dist/pipeline/scene-actions.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/pipeline/types.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Video as Code — Pipeline type definitions
+ *
+ * A pipeline is a declarative YAML file that defines a sequence of steps.
+ * Each step maps to an existing execute function in the CLI.
+ */
+/** Supported pipeline actions (maps to execute functions) */
+export type PipelineAction = "generate-image" | "generate-video" | "generate-tts" | "generate-sfx" | "generate-music" | "generate-storyboard" | "generate-motion" | "edit-silence-cut" | "edit-jump-cut" | "edit-caption" | "edit-noise-reduce" | "edit-fade" | "edit-translate-srt" | "edit-text-overlay" | "edit-motion-overlay" | "edit-grade" | "edit-speed-ramp" | "edit-reframe" | "edit-interpolate" | "edit-upscale" | "edit-image" | "audio-transcribe" | "audio-isolate" | "audio-dub" | "audio-duck" | "detect-scenes" | "detect-silence" | "detect-beats" | "analyze-video" | "analyze-media" | "review-video" | "compose-scenes-with-skills" | "scene-build" | "scene-render" | "export";
+/** A single step in the pipeline */
+export interface PipelineStep {
+    /** Unique step identifier (used for variable references) */
+    id: string;
+    /** Action to execute */
+    action: PipelineAction;
+    /** Step parameters (action-specific, may contain $refs) */
+    [key: string]: unknown;
+}
+/** Effort level passed to LLM providers (maps to Anthropic Opus 4.7 effort) */
+export type EffortLevel = "low" | "medium" | "high" | "xhigh";
+/** Pipeline budget — aborts execution when any ceiling is hit */
+export interface PipelineBudget {
+    /** Max estimated USD (uses COST_ESTIMATES.max per action) */
+    costUsd?: number;
+    /** Max total token budget (tracked when provider returns usage) */
+    tokens?: number;
+    /** Max number of failed steps before aborting */
+    maxToolErrors?: number;
+}
+/** Pipeline manifest (parsed from YAML) */
+export interface PipelineManifest {
+    /** Pipeline name */
+    name: string;
+    /** Optional description */
+    description?: string;
+    /** Pipeline version */
+    version?: number;
+    /** Steps to execute */
+    steps: PipelineStep[];
+    /** Cost / error ceilings enforced by the executor */
+    budget?: PipelineBudget;
+    /** Default effort level for LLM-backed steps (Opus 4.7 Task Budgets) */
+    effort?: EffortLevel;
+}
+/** Result of a single step execution */
+export interface StepResult {
+    id: string;
+    action: PipelineAction;
+    success: boolean;
+    /** Primary output path */
+    output?: string;
+    /** All result data (action-specific) */
+    data?: Record<string, unknown>;
+    /** Error message if failed */
+    error?: string;
+    /** Execution time in ms */
+    duration?: number;
+}
+/** Running budget usage after execution */
+export interface BudgetUsage {
+    /** Upper-bound estimated USD used (sum of max cost per completed step) */
+    estimatedCostUsd: number;
+    /** Total tokens consumed (when providers report usage) */
+    tokensUsed: number;
+    /** Failed steps count */
+    toolErrors: number;
+    /** Set if execution aborted due to a budget ceiling */
+    abortedBy?: "costUsd" | "tokens" | "maxToolErrors";
+}
+/** Result of full pipeline execution */
+export interface PipelineResult {
+    success: boolean;
+    name: string;
+    steps: StepResult[];
+    completedSteps: number;
+    totalSteps: number;
+    totalDuration?: number;
+    outputDir?: string;
+    error?: string;
+    /** Budget usage when a budget was configured */
+    budget?: BudgetUsage;
+}

package/dist/tools/adapters/agent.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @module adapters/agent
+ * @description Adapter from manifest entries to in-process Agent
+ * `ToolRegistry`. Consumed by `packages/cli/src/agent/tools/index.ts`.
+ */
+import type { ToolDefinition } from "../define-tool.js";
+import type { ToolRegistry } from "../../agent/tools/index.js";
+/** Register every manifest entry tagged `agent` (or surfaces undefined) into a ToolRegistry. */
+export declare function registerManifestIntoAgent(registry: ToolRegistry, manifest: readonly ToolDefinition[]): void;

package/dist/tools/adapters/agent.js

@@ -0,0 +1,188 @@
+import { createRequire as __vfCreateRequire } from 'node:module';
+const require = __vfCreateRequire(import.meta.url);
+
+// src/tools/zod-to-json-schema.ts
+function getDef(z) {
+  return z._def;
+}
+function getDescription(z) {
+  let current = z;
+  while (current) {
+    const def = getDef(current);
+    if (def.description) return def.description;
+    current = def.innerType;
+  }
+  return void 0;
+}
+function unwrapOptional(z) {
+  const def = getDef(z);
+  if (def.typeName === "ZodOptional" && def.innerType) {
+    return { inner: def.innerType, optional: true };
+  }
+  return { inner: z, optional: false };
+}
+function unwrapDefault(z) {
+  const def = getDef(z);
+  if (def.typeName === "ZodDefault" && def.innerType && def.defaultValue) {
+    return { inner: def.innerType, defaultValue: def.defaultValue() };
+  }
+  return { inner: z };
+}
+function convertLeaf(z, description) {
+  const { inner: afterDefault, defaultValue } = unwrapDefault(z);
+  const def = getDef(afterDefault);
+  const desc = description ?? getDescription(z);
+  const base = {};
+  if (desc) base.description = desc;
+  if (defaultValue !== void 0) base.default = defaultValue;
+  switch (def.typeName) {
+    case "ZodString":
+      return { type: "string", ...base };
+    case "ZodNumber":
+      return { type: "number", ...base };
+    case "ZodBoolean":
+      return { type: "boolean", ...base };
+    case "ZodEnum":
+      if (!def.values) throw new Error(`zod-to-json-schema: ZodEnum without values`);
+      return { type: "string", enum: def.values, ...base };
+    case "ZodLiteral": {
+      const value = def.value;
+      if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean") {
+        throw new Error(`zod-to-json-schema: ZodLiteral with unsupported value type`);
+      }
+      const type = typeof value === "boolean" ? "boolean" : typeof value;
+      const out = { type, ...base };
+      if (typeof value === "string" || typeof value === "number") out.enum = [value];
+      return out;
+    }
+    case "ZodArray": {
+      if (!def.type) throw new Error(`zod-to-json-schema: ZodArray without item type`);
+      return { type: "array", items: convertLeaf(def.type), ...base };
+    }
+    case "ZodRecord": {
+      const valueType = def.valueType;
+      if (!valueType) {
+        return { type: "object", additionalProperties: true, ...base };
+      }
+      const valueDef = getDef(valueType);
+      if (valueDef.typeName === "ZodUnknown" || valueDef.typeName === "ZodAny") {
+        return { type: "object", additionalProperties: true, ...base };
+      }
+      return { type: "object", additionalProperties: convertLeaf(valueType), ...base };
+    }
+    case "ZodObject":
+      return convertObject(afterDefault, desc);
+    default:
+      throw new Error(
+        `zod-to-json-schema: unsupported Zod type "${def.typeName}". Add support in packages/cli/src/tools/zod-to-json-schema.ts or use a supported variant (string, number, boolean, enum, literal, optional, default, array, object).`
+      );
+  }
+}
+function convertObject(z, description) {
+  const def = getDef(z);
+  if (def.typeName !== "ZodObject" || !def.shape) {
+    throw new Error(`zod-to-json-schema: convertObject called on non-ZodObject (${def.typeName})`);
+  }
+  const shape = def.shape();
+  const properties = {};
+  const required = [];
+  for (const [key, value] of Object.entries(shape)) {
+    const { inner, optional } = unwrapOptional(value);
+    const fieldDesc = getDescription(value);
+    properties[key] = convertLeaf(inner, fieldDesc);
+    if (!optional) required.push(key);
+  }
+  const out = {
+    type: "object",
+    properties,
+    required
+  };
+  if (description) out.description = description;
+  return out;
+}
+function zodToJsonSchema(schema) {
+  const def = getDef(schema);
+  if (def.typeName !== "ZodObject") {
+    throw new Error(`zodToJsonSchema: top-level schema must be ZodObject; got ${def.typeName}`);
+  }
+  return convertObject(schema);
+}
+var zodToAgentParameters = zodToJsonSchema;
+
+// src/tools/adapters/agent.ts
+function formatZodError(err) {
+  return err.issues.map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`).join("; ");
+}
+function toAgentDefinition(t) {
+  const json = zodToAgentParameters(t.schema);
+  const properties = {};
+  for (const [k, v] of Object.entries(json.properties ?? {})) {
+    properties[k] = v;
+  }
+  return {
+    name: t.name,
+    description: t.description,
+    surface: t.productSurface,
+    replacement: t.replacement,
+    note: t.note,
+    // Propagate the manifest's cost tier so the agent's executor can
+    // mandate a confirm prompt for high-spend tools without needing a
+    // parallel SSOT.
+    cost: t.cost,
+    parameters: {
+      type: "object",
+      properties,
+      required: json.required ?? []
+    }
+  };
+}
+function registerManifestIntoAgent(registry, manifest) {
+  for (const tool of manifest) {
+    if (tool.surfaces && !tool.surfaces.includes("agent")) continue;
+    const definition = toAgentDefinition(tool);
+    const handler = async (args, context) => {
+      const parsed = tool.schema.safeParse(args);
+      if (!parsed.success) {
+        return {
+          toolCallId: "",
+          success: false,
+          output: "",
+          error: formatZodError(parsed.error)
+        };
+      }
+      try {
+        const result = await tool.execute(parsed.data, {
+          workingDirectory: context.workingDirectory,
+          surface: "agent",
+          agent: {
+            projectPath: context.projectPath,
+            setProjectPath(path) {
+              context.projectPath = path;
+            }
+          }
+        });
+        if (!result.success) {
+          return {
+            toolCallId: "",
+            success: false,
+            output: "",
+            error: result.error ?? "tool execution failed"
+          };
+        }
+        const output = result.humanLines && result.humanLines.length > 0 ? result.humanLines.join("\n") : result.data ? JSON.stringify(result.data) : "";
+        return { toolCallId: "", success: true, output };
+      } catch (error) {
+        return {
+          toolCallId: "",
+          success: false,
+          output: "",
+          error: error instanceof Error ? error.message : String(error)
+        };
+      }
+    };
+    registry.register(definition, handler);
+  }
+}
+export {
+  registerManifestIntoAgent
+};

package/dist/tools/adapters/mcp.d.ts

@@ -0,0 +1,34 @@
+/**
+ * @module adapters/mcp
+ * @description Adapter from manifest entries to MCP server tool array +
+ * dispatcher. Consumed by `packages/mcp-server/src/tools/index.ts`.
+ */
+import { type JsonSchema } from "../zod-to-json-schema.js";
+import type { ToolDefinition } from "../define-tool.js";
+/**
+ * Top-level MCP tool inputSchema. We always emit `{ type:"object", properties,
+ * required }` at the root, so unlike the generic `JsonSchema` (which has
+ * optional `properties`/`required` for leaf nodes), the top-level shape's
+ * `properties` is required.
+ */
+export interface McpInputSchema {
+    type: "object";
+    properties: Record<string, JsonSchema>;
+    required: string[];
+    description?: string;
+}
+export interface McpTool {
+    name: string;
+    description: string;
+    inputSchema: McpInputSchema;
+}
+export type McpDispatcher = (name: string, args: Record<string, unknown>) => Promise<{
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+}>;
+/** Filter manifest by `surfaces.mcp` (default: included) and project to MCP tool shape. */
+export declare function manifestToMcpTools(manifest: readonly ToolDefinition[]): McpTool[];
+/** Build the dispatcher used by `handleToolCall` in the MCP server. */
+export declare function buildMcpDispatcher(manifest: readonly ToolDefinition[]): McpDispatcher;

package/dist/tools/adapters/mcp.js

@@ -0,0 +1,173 @@
+import { createRequire as __vfCreateRequire } from 'node:module';
+const require = __vfCreateRequire(import.meta.url);
+
+// src/tools/zod-to-json-schema.ts
+function getDef(z) {
+  return z._def;
+}
+function getDescription(z) {
+  let current = z;
+  while (current) {
+    const def = getDef(current);
+    if (def.description) return def.description;
+    current = def.innerType;
+  }
+  return void 0;
+}
+function unwrapOptional(z) {
+  const def = getDef(z);
+  if (def.typeName === "ZodOptional" && def.innerType) {
+    return { inner: def.innerType, optional: true };
+  }
+  return { inner: z, optional: false };
+}
+function unwrapDefault(z) {
+  const def = getDef(z);
+  if (def.typeName === "ZodDefault" && def.innerType && def.defaultValue) {
+    return { inner: def.innerType, defaultValue: def.defaultValue() };
+  }
+  return { inner: z };
+}
+function convertLeaf(z, description) {
+  const { inner: afterDefault, defaultValue } = unwrapDefault(z);
+  const def = getDef(afterDefault);
+  const desc = description ?? getDescription(z);
+  const base = {};
+  if (desc) base.description = desc;
+  if (defaultValue !== void 0) base.default = defaultValue;
+  switch (def.typeName) {
+    case "ZodString":
+      return { type: "string", ...base };
+    case "ZodNumber":
+      return { type: "number", ...base };
+    case "ZodBoolean":
+      return { type: "boolean", ...base };
+    case "ZodEnum":
+      if (!def.values) throw new Error(`zod-to-json-schema: ZodEnum without values`);
+      return { type: "string", enum: def.values, ...base };
+    case "ZodLiteral": {
+      const value = def.value;
+      if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean") {
+        throw new Error(`zod-to-json-schema: ZodLiteral with unsupported value type`);
+      }
+      const type = typeof value === "boolean" ? "boolean" : typeof value;
+      const out = { type, ...base };
+      if (typeof value === "string" || typeof value === "number") out.enum = [value];
+      return out;
+    }
+    case "ZodArray": {
+      if (!def.type) throw new Error(`zod-to-json-schema: ZodArray without item type`);
+      return { type: "array", items: convertLeaf(def.type), ...base };
+    }
+    case "ZodRecord": {
+      const valueType = def.valueType;
+      if (!valueType) {
+        return { type: "object", additionalProperties: true, ...base };
+      }
+      const valueDef = getDef(valueType);
+      if (valueDef.typeName === "ZodUnknown" || valueDef.typeName === "ZodAny") {
+        return { type: "object", additionalProperties: true, ...base };
+      }
+      return { type: "object", additionalProperties: convertLeaf(valueType), ...base };
+    }
+    case "ZodObject":
+      return convertObject(afterDefault, desc);
+    default:
+      throw new Error(
+        `zod-to-json-schema: unsupported Zod type "${def.typeName}". Add support in packages/cli/src/tools/zod-to-json-schema.ts or use a supported variant (string, number, boolean, enum, literal, optional, default, array, object).`
+      );
+  }
+}
+function convertObject(z, description) {
+  const def = getDef(z);
+  if (def.typeName !== "ZodObject" || !def.shape) {
+    throw new Error(`zod-to-json-schema: convertObject called on non-ZodObject (${def.typeName})`);
+  }
+  const shape = def.shape();
+  const properties = {};
+  const required = [];
+  for (const [key, value] of Object.entries(shape)) {
+    const { inner, optional } = unwrapOptional(value);
+    const fieldDesc = getDescription(value);
+    properties[key] = convertLeaf(inner, fieldDesc);
+    if (!optional) required.push(key);
+  }
+  const out = {
+    type: "object",
+    properties,
+    required
+  };
+  if (description) out.description = description;
+  return out;
+}
+function zodToJsonSchema(schema) {
+  const def = getDef(schema);
+  if (def.typeName !== "ZodObject") {
+    throw new Error(`zodToJsonSchema: top-level schema must be ZodObject; got ${def.typeName}`);
+  }
+  return convertObject(schema);
+}
+
+// src/tools/adapters/mcp.ts
+function formatZodError(err) {
+  const missing = err.issues.filter((i) => {
+    if (i.code !== "invalid_type") return false;
+    const received = i.received;
+    return received === "undefined" || received === "null";
+  }).map((i) => i.path.join(".")).filter(Boolean);
+  if (missing.length > 0) {
+    const plural = missing.length > 1 ? "s" : "";
+    return `missing required argument${plural}: ${missing.join(", ")}`;
+  }
+  return err.issues.map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`).join("; ");
+}
+function manifestToMcpTools(manifest) {
+  return manifest.filter((t) => !t.surfaces || t.surfaces.includes("mcp")).map((t) => {
+    const inputSchema = zodToJsonSchema(t.schema);
+    return {
+      name: t.name,
+      description: t.description,
+      inputSchema: {
+        type: "object",
+        properties: inputSchema.properties ?? {},
+        required: inputSchema.required ?? [],
+        ...inputSchema.description ? { description: inputSchema.description } : {}
+      }
+    };
+  });
+}
+function buildMcpDispatcher(manifest) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const t of manifest) {
+    if (!t.surfaces || t.surfaces.includes("mcp")) {
+      byName.set(t.name, t);
+    }
+  }
+  return async (name, args) => {
+    const tool = byName.get(name);
+    if (!tool) {
+      return { content: [{ type: "text", text: `Unknown tool: ${name}` }] };
+    }
+    const parsed = tool.schema.safeParse(args);
+    if (!parsed.success) {
+      return {
+        content: [{ type: "text", text: `${name} failed: ${formatZodError(parsed.error)}` }]
+      };
+    }
+    try {
+      const result = await tool.execute(parsed.data, {
+        workingDirectory: process.cwd(),
+        surface: "mcp"
+      });
+      const text = result.success ? JSON.stringify({ success: true, ...result.data }) : `${name} failed: ${result.error ?? "unknown error"}`;
+      return { content: [{ type: "text", text }] };
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      return { content: [{ type: "text", text: `${name} threw: ${msg}` }] };
+    }
+  };
+}
+export {
+  buildMcpDispatcher,
+  manifestToMcpTools
+};