@vibeframe/mcp-server 0.13.5

package/dist/index.js

@@ -0,0 +1,1313 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  ListResourcesRequestSchema,
+  ReadResourceRequestSchema,
+  ListPromptsRequestSchema,
+  GetPromptRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+
+// src/tools/index.ts
+import { readFile, writeFile } from "node:fs/promises";
+import { resolve } from "node:path";
+
+// ../cli/src/engine/project.ts
+var generateId = () => {
+  return `${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
+};
+function createDefaultState(name = "Untitled Project") {
+  return {
+    project: {
+      id: generateId(),
+      name,
+      createdAt: /* @__PURE__ */ new Date(),
+      updatedAt: /* @__PURE__ */ new Date(),
+      aspectRatio: "16:9",
+      frameRate: 30,
+      duration: 0
+    },
+    tracks: [
+      {
+        id: "video-track-1",
+        name: "Video 1",
+        type: "video",
+        order: 1,
+        isMuted: false,
+        isLocked: false,
+        isVisible: true
+      },
+      {
+        id: "audio-track-1",
+        name: "Audio 1",
+        type: "audio",
+        order: 0,
+        isMuted: false,
+        isLocked: false,
+        isVisible: true
+      }
+    ],
+    clips: [],
+    sources: [],
+    transitions: [],
+    currentTime: 0,
+    isPlaying: false,
+    zoom: 50,
+    scrollX: 0,
+    selectedClipIds: [],
+    selectedTrackId: null
+  };
+}
+var Project = class _Project {
+  state;
+  filePath = null;
+  constructor(name) {
+    this.state = createDefaultState(name);
+  }
+  /** Get current state (immutable copy) */
+  getState() {
+    return structuredClone(this.state);
+  }
+  /** Get project metadata */
+  getMeta() {
+    return { ...this.state.project };
+  }
+  /** Get file path */
+  getFilePath() {
+    return this.filePath;
+  }
+  // ============ Project Operations ============
+  setName(name) {
+    this.state.project.name = name;
+    this.state.project.updatedAt = /* @__PURE__ */ new Date();
+  }
+  setAspectRatio(ratio) {
+    this.state.project.aspectRatio = ratio;
+    this.state.project.updatedAt = /* @__PURE__ */ new Date();
+  }
+  setFrameRate(fps) {
+    this.state.project.frameRate = fps;
+    this.state.project.updatedAt = /* @__PURE__ */ new Date();
+  }
+  // ============ Media Source Operations ============
+  addSource(source) {
+    const newSource = { ...source, id: generateId() };
+    this.state.sources.push(newSource);
+    return newSource;
+  }
+  removeSource(id) {
+    const index = this.state.sources.findIndex((s) => s.id === id);
+    if (index === -1) return false;
+    this.state.sources.splice(index, 1);
+    this.state.clips = this.state.clips.filter((c) => c.sourceId !== id);
+    this.calculateDuration();
+    return true;
+  }
+  getSource(id) {
+    return this.state.sources.find((s) => s.id === id);
+  }
+  getSources() {
+    return [...this.state.sources];
+  }
+  // ============ Track Operations ============
+  addTrack(track) {
+    const newTrack = { ...track, id: generateId() };
+    this.state.tracks.push(newTrack);
+    return newTrack;
+  }
+  removeTrack(id) {
+    const index = this.state.tracks.findIndex((t) => t.id === id);
+    if (index === -1) return false;
+    this.state.tracks.splice(index, 1);
+    this.state.clips = this.state.clips.filter((c) => c.trackId !== id);
+    this.calculateDuration();
+    return true;
+  }
+  updateTrack(id, updates) {
+    const track = this.state.tracks.find((t) => t.id === id);
+    if (!track) return false;
+    Object.assign(track, updates);
+    return true;
+  }
+  getTrack(id) {
+    return this.state.tracks.find((t) => t.id === id);
+  }
+  getTracks() {
+    return [...this.state.tracks];
+  }
+  getTracksByType(type) {
+    return this.state.tracks.filter((t) => t.type === type);
+  }
+  // ============ Clip Operations ============
+  addClip(clip) {
+    const newClip = {
+      ...clip,
+      id: generateId(),
+      effects: []
+    };
+    this.state.clips.push(newClip);
+    this.calculateDuration();
+    return newClip;
+  }
+  removeClip(id) {
+    const index = this.state.clips.findIndex((c) => c.id === id);
+    if (index === -1) return false;
+    this.state.clips.splice(index, 1);
+    this.state.selectedClipIds = this.state.selectedClipIds.filter((cid) => cid !== id);
+    this.calculateDuration();
+    return true;
+  }
+  updateClip(id, updates) {
+    const clip = this.state.clips.find((c) => c.id === id);
+    if (!clip) return false;
+    Object.assign(clip, updates);
+    this.calculateDuration();
+    return true;
+  }
+  moveClip(id, trackId, startTime) {
+    const clip = this.state.clips.find((c) => c.id === id);
+    if (!clip) return false;
+    clip.trackId = trackId;
+    clip.startTime = Math.max(0, startTime);
+    this.calculateDuration();
+    return true;
+  }
+  trimClipStart(id, newStartTime) {
+    const clip = this.state.clips.find((c) => c.id === id);
+    if (!clip) return false;
+    const delta = newStartTime - clip.startTime;
+    clip.startTime = newStartTime;
+    clip.sourceStartOffset += delta;
+    clip.duration -= delta;
+    this.calculateDuration();
+    return true;
+  }
+  trimClipEnd(id, newDuration) {
+    const clip = this.state.clips.find((c) => c.id === id);
+    if (!clip) return false;
+    clip.duration = Math.max(0.1, newDuration);
+    clip.sourceEndOffset = clip.sourceStartOffset + clip.duration;
+    this.calculateDuration();
+    return true;
+  }
+  getClip(id) {
+    return this.state.clips.find((c) => c.id === id);
+  }
+  getClips() {
+    return [...this.state.clips];
+  }
+  getClipsByTrack(trackId) {
+    return this.state.clips.filter((c) => c.trackId === trackId);
+  }
+  /**
+   * Split a clip at a specific time, creating two clips
+   * @param id Clip ID to split
+   * @param splitTime Time relative to clip start (not timeline time)
+   * @returns [firstClip, secondClip] or null if failed
+   */
+  splitClip(id, splitTime) {
+    const clip = this.state.clips.find((c) => c.id === id);
+    if (!clip) return null;
+    if (splitTime <= 0 || splitTime >= clip.duration) {
+      return null;
+    }
+    const secondClip = {
+      id: generateId(),
+      sourceId: clip.sourceId,
+      trackId: clip.trackId,
+      startTime: clip.startTime + splitTime,
+      duration: clip.duration - splitTime,
+      sourceStartOffset: clip.sourceStartOffset + splitTime,
+      sourceEndOffset: clip.sourceEndOffset,
+      effects: []
+      // Effects don't transfer to split clips
+    };
+    clip.duration = splitTime;
+    clip.sourceEndOffset = clip.sourceStartOffset + splitTime;
+    this.state.clips.push(secondClip);
+    this.calculateDuration();
+    return [clip, secondClip];
+  }
+  /**
+   * Duplicate a clip
+   * @param id Clip ID to duplicate
+   * @param offsetTime Optional time offset for the duplicate (default: place after original)
+   * @returns The duplicated clip or null if failed
+   */
+  duplicateClip(id, offsetTime) {
+    const clip = this.state.clips.find((c) => c.id === id);
+    if (!clip) return null;
+    const newStartTime = offsetTime ?? clip.startTime + clip.duration;
+    const duplicatedClip = {
+      id: generateId(),
+      sourceId: clip.sourceId,
+      trackId: clip.trackId,
+      startTime: newStartTime,
+      duration: clip.duration,
+      sourceStartOffset: clip.sourceStartOffset,
+      sourceEndOffset: clip.sourceEndOffset,
+      effects: clip.effects.map((e) => ({
+        ...e,
+        id: generateId()
+      }))
+    };
+    this.state.clips.push(duplicatedClip);
+    this.calculateDuration();
+    return duplicatedClip;
+  }
+  // ============ Effect Operations ============
+  addEffect(clipId, effect) {
+    const clip = this.state.clips.find((c) => c.id === clipId);
+    if (!clip) return null;
+    const newEffect = { ...effect, id: generateId() };
+    clip.effects.push(newEffect);
+    return newEffect;
+  }
+  removeEffect(clipId, effectId) {
+    const clip = this.state.clips.find((c) => c.id === clipId);
+    if (!clip) return false;
+    const index = clip.effects.findIndex((e) => e.id === effectId);
+    if (index === -1) return false;
+    clip.effects.splice(index, 1);
+    return true;
+  }
+  updateEffect(clipId, effectId, updates) {
+    const clip = this.state.clips.find((c) => c.id === clipId);
+    if (!clip) return false;
+    const effect = clip.effects.find((e) => e.id === effectId);
+    if (!effect) return false;
+    Object.assign(effect, updates);
+    return true;
+  }
+  // ============ Transition Operations ============
+  addTransition(transition) {
+    const newTransition = { ...transition, id: generateId() };
+    this.state.transitions.push(newTransition);
+    return newTransition;
+  }
+  removeTransition(id) {
+    const index = this.state.transitions.findIndex((t) => t.id === id);
+    if (index === -1) return false;
+    this.state.transitions.splice(index, 1);
+    return true;
+  }
+  getTransitions() {
+    return [...this.state.transitions];
+  }
+  // ============ Duration Calculation ============
+  calculateDuration() {
+    const maxEndTime = this.state.clips.reduce((max, clip) => {
+      const endTime = clip.startTime + clip.duration;
+      return Math.max(max, endTime);
+    }, 0);
+    this.state.project.duration = maxEndTime;
+  }
+  getDuration() {
+    return this.state.project.duration;
+  }
+  // ============ Serialization ============
+  toJSON() {
+    return {
+      version: "1.0.0",
+      state: this.getState()
+    };
+  }
+  static fromJSON(data) {
+    const project = new _Project();
+    data.state.project.createdAt = new Date(data.state.project.createdAt);
+    data.state.project.updatedAt = new Date(data.state.project.updatedAt);
+    project.state = data.state;
+    return project;
+  }
+  setFilePath(path) {
+    this.filePath = path;
+  }
+  // ============ Summary ============
+  getSummary() {
+    return {
+      name: this.state.project.name,
+      duration: this.state.project.duration,
+      aspectRatio: this.state.project.aspectRatio,
+      frameRate: this.state.project.frameRate,
+      trackCount: this.state.tracks.length,
+      clipCount: this.state.clips.length,
+      sourceCount: this.state.sources.length
+    };
+  }
+};
+
+// src/tools/index.ts
+var tools = [
+  // Project Management
+  {
+    name: "project_create",
+    description: "Create a new VibeFrame project file",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: {
+          type: "string",
+          description: "Project name"
+        },
+        outputPath: {
+          type: "string",
+          description: "Output file path (defaults to {name}.vibe.json)"
+        },
+        width: {
+          type: "number",
+          description: "Video width in pixels (default: 1920)"
+        },
+        height: {
+          type: "number",
+          description: "Video height in pixels (default: 1080)"
+        },
+        fps: {
+          type: "number",
+          description: "Frames per second (default: 30)"
+        }
+      },
+      required: ["name"]
+    }
+  },
+  {
+    name: "project_info",
+    description: "Get information about a VibeFrame project",
+    inputSchema: {
+      type: "object",
+      properties: {
+        projectPath: {
+          type: "string",
+          description: "Path to the .vibe.json project file"
+        }
+      },
+      required: ["projectPath"]
+    }
+  },
+  // Timeline Operations
+  {
+    name: "timeline_add_source",
+    description: "Add a media source (video, audio, image) to the project",
+    inputSchema: {
+      type: "object",
+      properties: {
+        projectPath: {
+          type: "string",
+          description: "Path to the project file"
+        },
+        mediaPath: {
+          type: "string",
+          description: "Path to the media file"
+        },
+        name: {
+          type: "string",
+          description: "Optional name for the source"
+        },
+        duration: {
+          type: "number",
+          description: "Duration of the media in seconds (default: 10)"
+        }
+      },
+      required: ["projectPath", "mediaPath"]
+    }
+  },
+  {
+    name: "timeline_add_clip",
+    description: "Add a clip to the timeline from an existing source",
+    inputSchema: {
+      type: "object",
+      properties: {
+        projectPath: {
+          type: "string",
+          description: "Path to the project file"
+        },
+        sourceId: {
+          type: "string",
+          description: "ID of the media source"
+        },
+        trackId: {
+          type: "string",
+          description: "ID of the track to add clip to (optional, uses first video track)"
+        },
+        startTime: {
+          type: "number",
+          description: "Start time on timeline in seconds (default: 0)"
+        },
+        duration: {
+          type: "number",
+          description: "Clip duration in seconds (optional, uses source duration)"
+        }
+      },
+      required: ["projectPath", "sourceId"]
+    }
+  },
+  {
+    name: "timeline_split_clip",
+    description: "Split a clip at a specific time",
+    inputSchema: {
+      type: "object",
+      properties: {
+        projectPath: {
+          type: "string",
+          description: "Path to the project file"
+        },
+        clipId: {
+          type: "string",
+          description: "ID of the clip to split"
+        },
+        splitTime: {
+          type: "number",
+          description: "Time to split at (relative to clip start) in seconds"
+        }
+      },
+      required: ["projectPath", "clipId", "splitTime"]
+    }
+  },
+  {
+    name: "timeline_trim_clip",
+    description: "Trim a clip by adjusting its start or end",
+    inputSchema: {
+      type: "object",
+      properties: {
+        projectPath: {
+          type: "string",
+          description: "Path to the project file"
+        },
+        clipId: {
+          type: "string",
+          description: "ID of the clip to trim"
+        },
+        trimStart: {
+          type: "number",
+          description: "New source start offset in seconds"
+        },
+        trimEnd: {
+          type: "number",
+          description: "New duration in seconds"
+        }
+      },
+      required: ["projectPath", "clipId"]
+    }
+  },
+  {
+    name: "timeline_move_clip",
+    description: "Move a clip to a new position or track",
+    inputSchema: {
+      type: "object",
+      properties: {
+        projectPath: {
+          type: "string",
+          description: "Path to the project file"
+        },
+        clipId: {
+          type: "string",
+          description: "ID of the clip to move"
+        },
+        newStartTime: {
+          type: "number",
+          description: "New start time on timeline in seconds"
+        },
+        newTrackId: {
+          type: "string",
+          description: "ID of the target track (optional)"
+        }
+      },
+      required: ["projectPath", "clipId"]
+    }
+  },
+  {
+    name: "timeline_delete_clip",
+    description: "Delete a clip from the timeline",
+    inputSchema: {
+      type: "object",
+      properties: {
+        projectPath: {
+          type: "string",
+          description: "Path to the project file"
+        },
+        clipId: {
+          type: "string",
+          description: "ID of the clip to delete"
+        }
+      },
+      required: ["projectPath", "clipId"]
+    }
+  },
+  {
+    name: "timeline_duplicate_clip",
+    description: "Duplicate a clip",
+    inputSchema: {
+      type: "object",
+      properties: {
+        projectPath: {
+          type: "string",
+          description: "Path to the project file"
+        },
+        clipId: {
+          type: "string",
+          description: "ID of the clip to duplicate"
+        },
+        newStartTime: {
+          type: "number",
+          description: "Start time for the duplicated clip (optional, places after original)"
+        }
+      },
+      required: ["projectPath", "clipId"]
+    }
+  },
+  // Effects
+  {
+    name: "timeline_add_effect",
+    description: "Add an effect to a clip",
+    inputSchema: {
+      type: "object",
+      properties: {
+        projectPath: {
+          type: "string",
+          description: "Path to the project file"
+        },
+        clipId: {
+          type: "string",
+          description: "ID of the clip"
+        },
+        effectType: {
+          type: "string",
+          description: "Effect type: fadeIn, fadeOut, blur, brightness, contrast, saturation, grayscale, sepia, invert"
+        },
+        startTime: {
+          type: "number",
+          description: "Effect start time relative to clip (default: 0)"
+        },
+        duration: {
+          type: "number",
+          description: "Effect duration in seconds (default: 1)"
+        },
+        intensity: {
+          type: "number",
+          description: "Effect intensity 0-1 (default: 1)"
+        }
+      },
+      required: ["projectPath", "clipId", "effectType"]
+    }
+  },
+  // Tracks
+  {
+    name: "timeline_add_track",
+    description: "Add a new track to the timeline",
+    inputSchema: {
+      type: "object",
+      properties: {
+        projectPath: {
+          type: "string",
+          description: "Path to the project file"
+        },
+        trackType: {
+          type: "string",
+          description: "Track type: video or audio"
+        },
+        name: {
+          type: "string",
+          description: "Track name (optional)"
+        }
+      },
+      required: ["projectPath", "trackType"]
+    }
+  },
+  // List contents
+  {
+    name: "timeline_list",
+    description: "List all sources, tracks, and clips in a project",
+    inputSchema: {
+      type: "object",
+      properties: {
+        projectPath: {
+          type: "string",
+          description: "Path to the project file"
+        }
+      },
+      required: ["projectPath"]
+    }
+  }
+];
+async function loadProject(projectPath) {
+  const absPath = resolve(process.cwd(), projectPath);
+  const content = await readFile(absPath, "utf-8");
+  const data = JSON.parse(content);
+  return Project.fromJSON(data);
+}
+async function saveProject(projectPath, project) {
+  const absPath = resolve(process.cwd(), projectPath);
+  await writeFile(absPath, JSON.stringify(project.toJSON(), null, 2), "utf-8");
+}
+async function handleToolCall(name, args) {
+  try {
+    let result;
+    switch (name) {
+      case "project_create": {
+        const projectName = args.name;
+        const outputPath = args.outputPath || `${projectName}.vibe.json`;
+        const project = new Project(projectName);
+        if (args.fps) {
+          project.setFrameRate(args.fps);
+        }
+        await saveProject(outputPath, project);
+        result = `Created project "${projectName}" at ${outputPath}`;
+        break;
+      }
+      case "project_info": {
+        const project = await loadProject(args.projectPath);
+        const meta = project.getMeta();
+        const info = {
+          name: meta.name,
+          aspectRatio: meta.aspectRatio,
+          frameRate: meta.frameRate,
+          duration: meta.duration,
+          sources: project.getSources().length,
+          tracks: project.getTracks().length,
+          clips: project.getClips().length
+        };
+        result = JSON.stringify(info, null, 2);
+        break;
+      }
+      case "timeline_add_source": {
+        const project = await loadProject(args.projectPath);
+        const mediaPath = resolve(process.cwd(), args.mediaPath);
+        const ext = mediaPath.split(".").pop()?.toLowerCase() || "";
+        const mediaTypes = {
+          mp4: "video",
+          webm: "video",
+          mov: "video",
+          avi: "video",
+          mp3: "audio",
+          wav: "audio",
+          aac: "audio",
+          ogg: "audio",
+          jpg: "image",
+          jpeg: "image",
+          png: "image",
+          gif: "image",
+          webp: "image"
+        };
+        const source = project.addSource({
+          name: args.name || mediaPath.split("/").pop() || "media",
+          type: mediaTypes[ext] || "video",
+          url: mediaPath,
+          duration: args.duration || 10
+        });
+        await saveProject(args.projectPath, project);
+        result = `Added source: ${source.id}`;
+        break;
+      }
+      case "timeline_add_clip": {
+        const project = await loadProject(args.projectPath);
+        const sourceId = args.sourceId;
+        const tracks = project.getTracks();
+        const trackId = args.trackId || tracks.find((t) => t.type === "video")?.id || tracks[0]?.id;
+        if (!trackId) {
+          throw new Error("No tracks available. Add a track first.");
+        }
+        const source = project.getSource(sourceId);
+        const duration = args.duration || source?.duration || 10;
+        const clip = project.addClip({
+          sourceId,
+          trackId,
+          startTime: args.startTime || 0,
+          duration,
+          sourceStartOffset: 0,
+          sourceEndOffset: duration
+        });
+        await saveProject(args.projectPath, project);
+        result = `Added clip: ${clip.id}`;
+        break;
+      }
+      case "timeline_split_clip": {
+        const project = await loadProject(args.projectPath);
+        const splitResult = project.splitClip(args.clipId, args.splitTime);
+        await saveProject(args.projectPath, project);
+        result = splitResult ? `Split clip. New clip ID: ${splitResult[1].id}` : "Failed to split clip";
+        break;
+      }
+      case "timeline_trim_clip": {
+        const project = await loadProject(args.projectPath);
+        if (args.trimStart !== void 0) {
+          project.trimClipStart(args.clipId, args.trimStart);
+        }
+        if (args.trimEnd !== void 0) {
+          project.trimClipEnd(args.clipId, args.trimEnd);
+        }
+        await saveProject(args.projectPath, project);
+        result = "Trimmed clip";
+        break;
+      }
+      case "timeline_move_clip": {
+        const project = await loadProject(args.projectPath);
+        const clip = project.getClips().find((c) => c.id === args.clipId);
+        if (!clip) throw new Error("Clip not found");
+        const newTrackId = args.newTrackId || clip.trackId;
+        const newStartTime = args.newStartTime ?? clip.startTime;
+        project.moveClip(args.clipId, newTrackId, newStartTime);
+        await saveProject(args.projectPath, project);
+        result = "Moved clip";
+        break;
+      }
+      case "timeline_delete_clip": {
+        const project = await loadProject(args.projectPath);
+        const success = project.removeClip(args.clipId);
+        await saveProject(args.projectPath, project);
+        result = success ? "Deleted clip" : "Clip not found";
+        break;
+      }
+      case "timeline_duplicate_clip": {
+        const project = await loadProject(args.projectPath);
+        const newClip = project.duplicateClip(args.clipId, args.newStartTime);
+        await saveProject(args.projectPath, project);
+        result = newClip ? `Duplicated clip. New clip ID: ${newClip.id}` : "Failed to duplicate clip";
+        break;
+      }
+      case "timeline_add_effect": {
+        const project = await loadProject(args.projectPath);
+        const effect = project.addEffect(args.clipId, {
+          type: args.effectType,
+          startTime: args.startTime || 0,
+          duration: args.duration || 1,
+          params: { intensity: args.intensity || 1 }
+        });
+        await saveProject(args.projectPath, project);
+        result = effect ? `Added effect: ${effect.id}` : "Failed to add effect";
+        break;
+      }
+      case "timeline_add_track": {
+        const project = await loadProject(args.projectPath);
+        const trackType = args.trackType;
+        const tracks = project.getTracks();
+        const track = project.addTrack({
+          type: trackType,
+          name: args.name || `${trackType}-${tracks.length + 1}`,
+          order: tracks.length,
+          isMuted: false,
+          isLocked: false,
+          isVisible: true
+        });
+        await saveProject(args.projectPath, project);
+        result = `Added track: ${track.id}`;
+        break;
+      }
+      case "timeline_list": {
+        const project = await loadProject(args.projectPath);
+        const data = {
+          sources: project.getSources().map((s) => ({
+            id: s.id,
+            name: s.name,
+            type: s.type,
+            duration: s.duration
+          })),
+          tracks: project.getTracks().map((t) => ({
+            id: t.id,
+            name: t.name,
+            type: t.type
+          })),
+          clips: project.getClips().map((c) => ({
+            id: c.id,
+            sourceId: c.sourceId,
+            trackId: c.trackId,
+            startTime: c.startTime,
+            duration: c.duration
+          }))
+        };
+        result = JSON.stringify(data, null, 2);
+        break;
+      }
+      default:
+        throw new Error(`Unknown tool: ${name}`);
+    }
+    return {
+      content: [{ type: "text", text: result }]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error instanceof Error ? error.message : "Unknown error"}`
+        }
+      ]
+    };
+  }
+}
+
+// src/resources/index.ts
+import { readFile as readFile2 } from "node:fs/promises";
+import { resolve as resolve2 } from "node:path";
+var resources = [
+  {
+    uri: "vibe://project/current",
+    name: "Current Project State",
+    description: "Full state of the currently active VibeFrame project",
+    mimeType: "application/json"
+  },
+  {
+    uri: "vibe://project/clips",
+    name: "Project Clips",
+    description: "List of all clips in the timeline",
+    mimeType: "application/json"
+  },
+  {
+    uri: "vibe://project/sources",
+    name: "Media Sources",
+    description: "List of all media sources in the project",
+    mimeType: "application/json"
+  },
+  {
+    uri: "vibe://project/tracks",
+    name: "Timeline Tracks",
+    description: "List of all tracks in the timeline",
+    mimeType: "application/json"
+  },
+  {
+    uri: "vibe://project/settings",
+    name: "Project Settings",
+    description: "Project configuration (resolution, fps, etc.)",
+    mimeType: "application/json"
+  }
+];
+var currentProjectPath = process.env.VIBE_PROJECT_PATH || null;
+async function loadProject2(projectPath) {
+  const absPath = resolve2(process.cwd(), projectPath);
+  const content = await readFile2(absPath, "utf-8");
+  const data = JSON.parse(content);
+  return Project.fromJSON(data);
+}
+async function readResource(uri) {
+  const match = uri.match(/^vibe:\/\/project\/(.+)$/);
+  if (!match) {
+    throw new Error(`Invalid resource URI: ${uri}`);
+  }
+  const resourceType = match[1];
+  const projectPath = currentProjectPath;
+  if (!projectPath) {
+    return {
+      contents: [
+        {
+          uri,
+          mimeType: "application/json",
+          text: JSON.stringify({
+            error: "No project loaded. Set VIBE_PROJECT_PATH environment variable or use project_create tool."
+          })
+        }
+      ]
+    };
+  }
+  try {
+    const project = await loadProject2(projectPath);
+    let data;
+    switch (resourceType) {
+      case "current":
+        data = project.toJSON();
+        break;
+      case "clips":
+        data = project.getClips().map((clip) => ({
+          id: clip.id,
+          sourceId: clip.sourceId,
+          trackId: clip.trackId,
+          startTime: clip.startTime,
+          duration: clip.duration,
+          sourceStartOffset: clip.sourceStartOffset,
+          effects: clip.effects
+        }));
+        break;
+      case "sources":
+        data = project.getSources().map((source) => ({
+          id: source.id,
+          name: source.name,
+          type: source.type,
+          url: source.url,
+          duration: source.duration,
+          width: source.width,
+          height: source.height
+        }));
+        break;
+      case "tracks":
+        data = project.getTracks().map((track) => ({
+          id: track.id,
+          name: track.name,
+          type: track.type,
+          order: track.order,
+          isMuted: track.isMuted,
+          isLocked: track.isLocked,
+          isVisible: track.isVisible
+        }));
+        break;
+      case "settings": {
+        const meta = project.getMeta();
+        data = {
+          name: meta.name,
+          aspectRatio: meta.aspectRatio,
+          frameRate: meta.frameRate,
+          duration: meta.duration
+        };
+        break;
+      }
+      default:
+        throw new Error(`Unknown resource type: ${resourceType}`);
+    }
+    return {
+      contents: [
+        {
+          uri,
+          mimeType: "application/json",
+          text: JSON.stringify(data, null, 2)
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      contents: [
+        {
+          uri,
+          mimeType: "application/json",
+          text: JSON.stringify({
+            error: error instanceof Error ? error.message : "Unknown error"
+          })
+        }
+      ]
+    };
+  }
+}
+
+// src/prompts/index.ts
+var prompts = [
+  {
+    name: "edit_video",
+    description: "Get guidance on editing a video with natural language instructions",
+    arguments: [
+      {
+        name: "instruction",
+        description: "Natural language description of the edit (e.g., 'trim the first 5 seconds')",
+        required: true
+      },
+      {
+        name: "projectPath",
+        description: "Path to the project file",
+        required: false
+      }
+    ]
+  },
+  {
+    name: "create_montage",
+    description: "Create a montage from multiple clips with automatic pacing",
+    arguments: [
+      {
+        name: "clips",
+        description: "Comma-separated list of clip IDs or media paths",
+        required: true
+      },
+      {
+        name: "duration",
+        description: "Target total duration in seconds",
+        required: false
+      },
+      {
+        name: "style",
+        description: "Montage style: fast, slow, rhythmic, dramatic",
+        required: false
+      }
+    ]
+  },
+  {
+    name: "add_transitions",
+    description: "Add transitions between clips in the timeline",
+    arguments: [
+      {
+        name: "transitionType",
+        description: "Transition type: fade, dissolve, wipe, cut",
+        required: false
+      },
+      {
+        name: "duration",
+        description: "Transition duration in seconds",
+        required: false
+      }
+    ]
+  },
+  {
+    name: "color_grade",
+    description: "Apply color grading to clips",
+    arguments: [
+      {
+        name: "style",
+        description: "Color grade style: cinematic, warm, cool, vintage, noir",
+        required: true
+      },
+      {
+        name: "intensity",
+        description: "Intensity of the effect (0-1)",
+        required: false
+      }
+    ]
+  },
+  {
+    name: "generate_subtitles",
+    description: "Generate subtitles from audio using AI transcription",
+    arguments: [
+      {
+        name: "language",
+        description: "Language code (e.g., en, ko, ja)",
+        required: false
+      },
+      {
+        name: "format",
+        description: "Output format: srt, vtt, json",
+        required: false
+      }
+    ]
+  },
+  {
+    name: "create_shorts",
+    description: "Create short-form content from a longer video",
+    arguments: [
+      {
+        name: "targetDuration",
+        description: "Target duration for each short (e.g., 60 for 60 seconds)",
+        required: false
+      },
+      {
+        name: "aspectRatio",
+        description: "Aspect ratio: 9:16, 1:1, 4:5",
+        required: false
+      }
+    ]
+  },
+  {
+    name: "sync_to_music",
+    description: "Sync video cuts to music beats",
+    arguments: [
+      {
+        name: "audioPath",
+        description: "Path to the audio/music file",
+        required: true
+      },
+      {
+        name: "cutStyle",
+        description: "Cut style: on-beat, off-beat, every-other",
+        required: false
+      }
+    ]
+  }
+];
+function getPrompt(name, args) {
+  switch (name) {
+    case "edit_video":
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Help me edit a video with the following instruction: "${args.instruction}"
+
+${args.projectPath ? `Project file: ${args.projectPath}` : "No project file specified."}
+
+Please analyze the request and suggest the appropriate timeline tools to use. Consider:
+1. What clips need to be affected?
+2. What operations are needed (trim, split, move, add effects, etc.)?
+3. What are the specific parameters?
+
+Provide step-by-step guidance using the available MCP tools.`
+            }
+          }
+        ]
+      };
+    case "create_montage":
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Help me create a ${args.style || "dynamic"} montage from these clips: ${args.clips}
+
+${args.duration ? `Target duration: ${args.duration} seconds` : ""}
+
+Please suggest:
+1. The order of clips for best flow
+2. Duration for each clip based on pacing
+3. Transition types between clips
+4. Any effects to enhance the montage
+
+Use the available MCP tools to implement this.`
+            }
+          }
+        ]
+      };
+    case "add_transitions":
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Add ${args.transitionType || "fade"} transitions between all clips in the timeline.
+
+${args.duration ? `Transition duration: ${args.duration} seconds` : "Default duration: 0.5 seconds"}
+
+Please:
+1. First list all clips in the timeline
+2. Identify clip boundaries
+3. Add appropriate effects (fadeOut to ending clip, fadeIn to starting clip)
+4. Ensure smooth visual flow`
+            }
+          }
+        ]
+      };
+    case "color_grade":
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Apply "${args.style}" color grading to the video.
+
+Intensity: ${args.intensity || "0.7"}
+
+For this style, suggest and apply:
+1. Brightness adjustments
+2. Contrast settings
+3. Saturation levels
+4. Any special effects (grayscale for noir, sepia for vintage, etc.)
+
+Use the timeline_add_effect tool to apply these to all clips.`
+            }
+          }
+        ]
+      };
+    case "generate_subtitles":
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Generate subtitles from the video's audio track.
+
+Language: ${args.language || "auto-detect"}
+Format: ${args.format || "srt"}
+
+Steps:
+1. Extract audio from the video
+2. Use Whisper transcription (vibe ai transcribe command)
+3. Format output as ${args.format || "SRT"} subtitles
+4. Optionally add as text overlay clips
+
+Note: This requires the CLI transcribe command to be run separately.`
+            }
+          }
+        ]
+      };
+    case "create_shorts":
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Create short-form content from this video for social media.
+
+Target duration per short: ${args.targetDuration || 60} seconds
+Aspect ratio: ${args.aspectRatio || "9:16"}
+
+Please:
+1. Analyze the timeline to find engaging segments
+2. Identify natural cut points (scene changes, pauses)
+3. Split the video into ${args.targetDuration || 60}-second segments
+4. Suggest which segments would work best as standalone shorts
+5. Note any reframing needed for vertical format`
+            }
+          }
+        ]
+      };
+    case "sync_to_music":
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Sync video cuts to music beats.
+
+Audio file: ${args.audioPath}
+Cut style: ${args.cutStyle || "on-beat"}
+
+Steps:
+1. Analyze the audio for beat detection (use vibe detect beats command)
+2. Get beat timestamps
+3. Split or trim clips to align with beats
+4. Add transitions at beat points for ${args.cutStyle || "on-beat"} style
+
+This creates a music video-style edit where cuts happen in rhythm with the music.`
+            }
+          }
+        ]
+      };
+    default:
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Unknown prompt: ${name}. Available prompts: edit_video, create_montage, add_transitions, color_grade, generate_subtitles, create_shorts, sync_to_music`
+            }
+          }
+        ]
+      };
+  }
+}
+
+// src/index.ts
+var server = new Server(
+  {
+    name: "vibeframe",
+    version: "0.1.0"
+  },
+  {
+    capabilities: {
+      tools: {},
+      resources: {},
+      prompts: {}
+    }
+  }
+);
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  return { tools };
+});
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+  return handleToolCall(name, args || {});
+});
+server.setRequestHandler(ListResourcesRequestSchema, async () => {
+  return { resources };
+});
+server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+  const { uri } = request.params;
+  return readResource(uri);
+});
+server.setRequestHandler(ListPromptsRequestSchema, async () => {
+  return { prompts };
+});
+server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+  return getPrompt(name, args || {});
+});
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("VibeFrame MCP Server started");
+}
+main().catch((error) => {
+  console.error("Server error:", error);
+  process.exit(1);
+});