@vibeframe/cli 0.115.9 → 0.116.0

package/dist/agent/types.d.ts

@@ -1,80 +0,0 @@
-/**
- * Core types for the VibeFrame Agentic System
- */
-export interface ToolParameter {
-    type: "string" | "number" | "boolean" | "array" | "object";
-    description: string;
-    required?: boolean;
-    enum?: string[];
-    items?: ToolParameter;
-    properties?: Record<string, ToolParameter>;
-}
-export interface ToolDefinition {
-    name: string;
-    description: string;
-    /**
-     * Product-facing classification propagated from the manifest. This is
-     * separate from MCP/agent transport exposure and helps agents prefer the
-     * intended public workflow over legacy or internal primitives.
-     */
-    surface?: "public" | "agent" | "advanced" | "legacy" | "internal";
-    replacement?: string;
-    note?: string;
-    /**
-     * Cost tier propagated from the manifest's `defineTool` declaration.
-     * Five tiers (free / low / medium / high / very-high). Used by the
-     * agent executor to decide whether a confirm prompt is mandatory.
-     */
-    cost?: "free" | "low" | "medium" | "high" | "very-high";
-    parameters: {
-        type: "object";
-        properties: Record<string, ToolParameter>;
-        required: string[];
-    };
-}
-export interface ToolCall {
-    id: string;
-    name: string;
-    arguments: Record<string, unknown>;
-}
-export interface ToolResult {
-    toolCallId: string;
-    success: boolean;
-    output: string;
-    error?: string;
-}
-export interface AgentMessage {
-    role: "system" | "user" | "assistant" | "tool";
-    content: string;
-    toolCalls?: ToolCall[];
-    toolCallId?: string;
-    /**
-     * The provider's own assistant content (Claude content blocks, Gemini
-     * parts), replayed verbatim on the next turn. Newer models require their
-     * thinking blocks and thought signatures back unmodified during tool use.
-     */
-    providerContent?: unknown;
-}
-export interface AgentConfig {
-    provider: LLMProvider;
-    model?: string;
-    maxTurns?: number;
-    verbose?: boolean;
-}
-export type LLMProvider = "openai" | "claude" | "gemini" | "ollama" | "xai" | "openrouter" | "evolink";
-export interface LLMResponse {
-    content: string;
-    toolCalls?: ToolCall[];
-    finishReason: "stop" | "tool_calls" | "length" | "error";
-    /** See {@link AgentMessage.providerContent}. */
-    providerContent?: unknown;
-}
-export interface AgentContext {
-    projectPath: string | null;
-    workingDirectory: string;
-}
-export interface AgentTurn {
-    input: string;
-    response: string;
-    toolsUsed: string[];
-}

package/dist/commands/agent.d.ts

@@ -1,30 +0,0 @@
-/**
- * Agent Command - Interactive AI agent REPL
- * Provides natural language interface with tool calling
- */
-import { Command } from "commander";
-export interface StartAgentOptions {
-    provider?: string;
-    model?: string;
-    project?: string;
-    verbose?: boolean;
-    maxTurns?: string;
-    input?: string;
-    confirm?: boolean;
-    /** When true, suppress *all* confirm prompts including the cost gate. */
-    noConfirm?: boolean;
-    /** Cumulative USD ceiling — agent rejects further tool calls past this. */
-    budgetUsd?: number | string;
-}
-/**
- * `vibe agent` is deprecated: the host's agent loop (Claude Code, Codex,
- * Cursor, or an MCP app host) is the outer loop, and a second built-in loop
- * competes with it. Printed to stderr so `--input` stdout stays clean.
- */
-export declare const AGENT_DEPRECATION_NOTICE: string;
-/**
- * Start the AI agent
- * @param options - Agent options
- */
-export declare function startAgent(options?: StartAgentOptions): Promise<void>;
-export declare const agentCommand: Command;

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

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

@@ -1,188 +0,0 @@
-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/manifest/agent-only.d.ts

@@ -1,236 +0,0 @@
-/**
- * @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;
-    codec?: string | undefined;
-    audioCodec?: string | undefined;
-}, {
-    output: string;
-    input: string;
-    codec?: string | undefined;
-    audioCodec?: 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[];