@vibeframe/cli 0.27.0 → 0.30.0

package/src/engine/project.ts

@@ -1,439 +0,0 @@
-/**
- * Headless Project Engine for CLI operations
- * No React/Zustand dependency - pure TypeScript
- */
-
-import type {
-  TimelineState,
-  ProjectMeta,
-  Track,
-  Clip,
-  MediaSource,
-  Effect,
-  Transition,
-  Id,
-  TimeSeconds,
-  AspectRatio,
-  MediaType,
-} from "@vibeframe/core/timeline";
-
-/** Generate unique ID */
-export const generateId = (): Id => {
-  return `${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
-};
-
-/** Project file format */
-export interface ProjectFile {
-  version: string;
-  state: TimelineState;
-}
-
-/** Create default project state */
-function createDefaultState(name: string = "Untitled Project"): TimelineState {
-  return {
-    project: {
-      id: generateId(),
-      name,
-      createdAt: new Date(),
-      updatedAt: 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,
-  };
-}
-
-/**
- * Headless Project Engine
- * Manages timeline state without React/Zustand
- */
-export class Project {
-  private state: TimelineState;
-  private filePath: string | null = null;
-
-  constructor(name?: string) {
-    this.state = createDefaultState(name);
-  }
-
-  /** Get current state (immutable copy) */
-  getState(): TimelineState {
-    return structuredClone(this.state);
-  }
-
-  /** Get project metadata */
-  getMeta(): ProjectMeta {
-    return { ...this.state.project };
-  }
-
-  /** Get file path */
-  getFilePath(): string | null {
-    return this.filePath;
-  }
-
-  // ============ Project Operations ============
-
-  setName(name: string): void {
-    this.state.project.name = name;
-    this.state.project.updatedAt = new Date();
-  }
-
-  setAspectRatio(ratio: AspectRatio): void {
-    this.state.project.aspectRatio = ratio;
-    this.state.project.updatedAt = new Date();
-  }
-
-  setFrameRate(fps: number): void {
-    this.state.project.frameRate = fps;
-    this.state.project.updatedAt = new Date();
-  }
-
-  // ============ Media Source Operations ============
-
-  addSource(source: Omit<MediaSource, "id">): MediaSource {
-    const newSource: MediaSource = { ...source, id: generateId() };
-    this.state.sources.push(newSource);
-    return newSource;
-  }
-
-  removeSource(id: Id): boolean {
-    const index = this.state.sources.findIndex((s) => s.id === id);
-    if (index === -1) return false;
-
-    this.state.sources.splice(index, 1);
-    // Also remove clips using this source
-    this.state.clips = this.state.clips.filter((c) => c.sourceId !== id);
-    this.calculateDuration();
-    return true;
-  }
-
-  getSource(id: Id): MediaSource | undefined {
-    return this.state.sources.find((s) => s.id === id);
-  }
-
-  getSources(): MediaSource[] {
-    return [...this.state.sources];
-  }
-
-  // ============ Track Operations ============
-
-  addTrack(track: Omit<Track, "id">): Track {
-    const newTrack: Track = { ...track, id: generateId() };
-    this.state.tracks.push(newTrack);
-    return newTrack;
-  }
-
-  removeTrack(id: Id): boolean {
-    const index = this.state.tracks.findIndex((t) => t.id === id);
-    if (index === -1) return false;
-
-    this.state.tracks.splice(index, 1);
-    // Also remove clips on this track
-    this.state.clips = this.state.clips.filter((c) => c.trackId !== id);
-    this.calculateDuration();
-    return true;
-  }
-
-  updateTrack(id: Id, updates: Partial<Omit<Track, "id">>): boolean {
-    const track = this.state.tracks.find((t) => t.id === id);
-    if (!track) return false;
-    Object.assign(track, updates);
-    return true;
-  }
-
-  getTrack(id: Id): Track | undefined {
-    return this.state.tracks.find((t) => t.id === id);
-  }
-
-  getTracks(): Track[] {
-    return [...this.state.tracks];
-  }
-
-  getTracksByType(type: MediaType): Track[] {
-    return this.state.tracks.filter((t) => t.type === type);
-  }
-
-  // ============ Clip Operations ============
-
-  addClip(clip: Omit<Clip, "id" | "effects">): Clip {
-    const newClip: Clip = {
-      ...clip,
-      id: generateId(),
-      effects: [],
-    };
-    this.state.clips.push(newClip);
-    this.calculateDuration();
-    return newClip;
-  }
-
-  removeClip(id: Id): boolean {
-    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: Id, updates: Partial<Omit<Clip, "id">>): boolean {
-    const clip = this.state.clips.find((c) => c.id === id);
-    if (!clip) return false;
-    Object.assign(clip, updates);
-    this.calculateDuration();
-    return true;
-  }
-
-  moveClip(id: Id, trackId: Id, startTime: TimeSeconds): boolean {
-    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: Id, newStartTime: TimeSeconds): boolean {
-    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: Id, newDuration: TimeSeconds): boolean {
-    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: Id): Clip | undefined {
-    return this.state.clips.find((c) => c.id === id);
-  }
-
-  getClips(): Clip[] {
-    return [...this.state.clips];
-  }
-
-  getClipsByTrack(trackId: Id): Clip[] {
-    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: Id, splitTime: TimeSeconds): [Clip, Clip] | null {
-    const clip = this.state.clips.find((c) => c.id === id);
-    if (!clip) return null;
-
-    // Validate split time
-    if (splitTime <= 0 || splitTime >= clip.duration) {
-      return null;
-    }
-
-    // Create the second clip (after split point)
-    const secondClip: Clip = {
-      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
-    };
-
-    // Modify the first clip (before split point)
-    clip.duration = splitTime;
-    clip.sourceEndOffset = clip.sourceStartOffset + splitTime;
-
-    // Add the second clip
-    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: Id, offsetTime?: TimeSeconds): Clip | null {
-    const clip = this.state.clips.find((c) => c.id === id);
-    if (!clip) return null;
-
-    const newStartTime = offsetTime ?? clip.startTime + clip.duration;
-
-    const duplicatedClip: Clip = {
-      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: Id, effect: Omit<Effect, "id">): Effect | null {
-    const clip = this.state.clips.find((c) => c.id === clipId);
-    if (!clip) return null;
-
-    const newEffect: Effect = { ...effect, id: generateId() };
-    clip.effects.push(newEffect);
-    return newEffect;
-  }
-
-  removeEffect(clipId: Id, effectId: Id): boolean {
-    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: Id, effectId: Id, updates: Partial<Omit<Effect, "id">>): boolean {
-    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: Omit<Transition, "id">): Transition {
-    const newTransition: Transition = { ...transition, id: generateId() };
-    this.state.transitions.push(newTransition);
-    return newTransition;
-  }
-
-  removeTransition(id: Id): boolean {
-    const index = this.state.transitions.findIndex((t) => t.id === id);
-    if (index === -1) return false;
-
-    this.state.transitions.splice(index, 1);
-    return true;
-  }
-
-  getTransitions(): Transition[] {
-    return [...this.state.transitions];
-  }
-
-  // ============ Duration Calculation ============
-
-  private calculateDuration(): void {
-    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(): TimeSeconds {
-    return this.state.project.duration;
-  }
-
-  // ============ Serialization ============
-
-  toJSON(): ProjectFile {
-    return {
-      version: "1.0.0",
-      state: this.getState(),
-    };
-  }
-
-  static fromJSON(data: ProjectFile): Project {
-    const project = new Project();
-    // Convert date strings back to Date objects
-    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: string): void {
-    this.filePath = path;
-  }
-
-  // ============ Summary ============
-
-  getSummary(): {
-    name: string;
-    duration: TimeSeconds;
-    aspectRatio: AspectRatio;
-    frameRate: number;
-    trackCount: number;
-    clipCount: number;
-    sourceCount: number;
-  } {
-    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,
-    };
-  }
-}

package/src/index.ts

@@ -1,146 +0,0 @@
-#!/usr/bin/env node
-
-// Debug: Check if script starts at all
-if (process.env.VIBE_DEBUG === "1") {
-  console.log("[CLI] Script started, loading modules...");
-}
-
-import { Command } from "commander";
-import { createRequire } from "module";
-import chalk from "chalk";
-
-const require = createRequire(import.meta.url);
-const pkg = require("../package.json");
-
-// Re-export engine for library usage
-export { Project, generateId, type ProjectFile } from "./engine/index.js";
-import { projectCommand } from "./commands/project.js";
-import { timelineCommand } from "./commands/timeline.js";
-import { generateCommand } from "./commands/generate.js";
-import { editCommand } from "./commands/edit-cmd.js";
-import { analyzeCommand } from "./commands/analyze.js";
-import { audioCommand } from "./commands/audio.js";
-import { pipelineCommand } from "./commands/pipeline.js";
-import { schemaCommand } from "./commands/schema.js";
-import { mediaCommand } from "./commands/media.js";
-import { exportCommand } from "./commands/export.js";
-import { batchCommand } from "./commands/batch.js";
-import { detectCommand } from "./commands/detect.js";
-import { setupCommand } from "./commands/setup.js";
-import { doctorCommand } from "./commands/doctor.js";
-import { agentCommand, startAgent } from "./commands/agent.js";
-import { ApiKeyError } from "./utils/api-key.js";
-import { isFirstRun, showFirstRunBanner } from "./utils/first-run.js";
-import { exitWithError } from "./commands/output.js";
-
-export { startAgent } from "./commands/agent.js";
-export { loadConfig, saveConfig, isConfigured, type VibeConfig } from "./config/index.js";
-export { AgentExecutor, ToolRegistry, ConversationMemory } from "./agent/index.js";
-export type { AgentConfig, AgentContext, AgentMessage, ToolCall, ToolResult, LLMAdapter } from "./agent/index.js";
-
-const program = new Command();
-
-program
-  .name("vibe")
-  .showSuggestionAfterError(true)
-  .description("VibeFrame CLI - AI-First Video Editor")
-  .version(pkg.version)
-  .option("--json", "Output in JSON format")
-  .option("-q, --quiet", "Output only the primary result value (path, URL, or ID)")
-  .option("--fields <fields>", "Limit JSON output to specific fields (comma-separated)")
-  .configureOutput({
-    outputError: (str, write) => {
-      write(chalk.red(str.trim()) + "\n");
-      write(chalk.dim("Run with --help for full options.\n"));
-    },
-  })
-  .addHelpText(
-    "after",
-    `
-Tips:
-  vibe setup               Configure API keys and preferences
-  vibe doctor              Check system health and available commands
-  vibe schema <command>    Show JSON schema for any command (e.g., vibe schema generate.image)
-  vibe                     Start interactive Agent mode (no args)
-
-More commands: vibe project|timeline|export|batch|detect|schema --help
-`
-  );
-
-// Set JSON mode env var before subcommand parsing
-// Also check for first-run and show banner
-program.hook("preAction", async (thisCommand) => {
-  const opts = program.opts();
-
-  // --json flag or auto-detect non-TTY stdout
-  if (opts.json || (!process.stdout.isTTY && !process.env.VIBE_HUMAN_OUTPUT)) {
-    process.env.VIBE_JSON_OUTPUT = "1";
-  }
-
-  // --quiet flag
-  if (opts.quiet) {
-    process.env.VIBE_QUIET_OUTPUT = "1";
-  }
-
-  // --fields flag
-  if (opts.fields) {
-    process.env.VIBE_OUTPUT_FIELDS = opts.fields;
-  }
-
-  // Show first-run banner for non-setup/doctor commands
-  const cmdName = thisCommand.name();
-  const skipBannerCommands = ["setup", "doctor", "help"];
-  if (!skipBannerCommands.includes(cmdName) && process.stdin.isTTY) {
-    try {
-      if (await isFirstRun()) {
-        showFirstRunBanner();
-      }
-    } catch {
-      // Don't block on first-run check failure
-    }
-  }
-});
-
-// Main commands (visible in --help)
-program.addCommand(generateCommand);
-program.addCommand(editCommand);
-program.addCommand(analyzeCommand);
-program.addCommand(audioCommand);
-program.addCommand(pipelineCommand);
-program.addCommand(setupCommand);
-program.addCommand(doctorCommand);
-program.addCommand(agentCommand);
-
-// Infrastructure commands (hidden from --help, still fully functional)
-program.addCommand(projectCommand, { hidden: true });
-program.addCommand(timelineCommand, { hidden: true });
-program.addCommand(schemaCommand, { hidden: true });
-program.addCommand(mediaCommand, { hidden: true });
-program.addCommand(exportCommand, { hidden: true });
-program.addCommand(batchCommand, { hidden: true });
-program.addCommand(detectCommand, { hidden: true });
-
-// Check if any arguments provided
-if (process.argv.length <= 2) {
-  // No arguments - start Agent mode
-  if (process.env.VIBE_DEBUG === "1") {
-    console.log("[CLI] No args, starting Agent...");
-  }
-  startAgent().catch((err) => {
-    console.error("Failed to start Agent:", err);
-    process.exit(1);
-  });
-} else {
-  // Arguments provided - parse normally with global error handling
-  (async () => {
-    try {
-      await program.parseAsync();
-    } catch (err) {
-      if (err instanceof ApiKeyError) {
-        exitWithError(err.toStructured());
-      }
-      // Re-throw non-ApiKeyError errors
-      throw err;
-    }
-  })();
-}

package/src/utils/api-key.test.ts

@@ -1,41 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-import { loadEnv, getApiKey } from "./api-key.js";
-
-describe("api-key utilities", () => {
-  const originalEnv = process.env;
-
-  beforeEach(() => {
-    vi.resetModules();
-    process.env = { ...originalEnv };
-  });
-
-  afterEach(() => {
-    process.env = originalEnv;
-  });
-
-  describe("loadEnv", () => {
-    it("does not throw when .env file is missing", () => {
-      expect(() => loadEnv()).not.toThrow();
-    });
-  });
-
-  describe("getApiKey", () => {
-    it("returns option value if provided", async () => {
-      const result = await getApiKey("TEST_KEY", "Test", "my-api-key");
-      expect(result).toBe("my-api-key");
-    });
-
-    it("returns env value if option not provided", async () => {
-      process.env.TEST_KEY = "env-api-key";
-      const result = await getApiKey("TEST_KEY", "Test");
-      expect(result).toBe("env-api-key");
-    });
-
-    it("returns null when no key available and not TTY", async () => {
-      // In test environment, stdin is not TTY, so it should return null
-      delete process.env.TEST_KEY;
-      const result = await getApiKey("TEST_KEY", "Test");
-      expect(result).toBeNull();
-    });
-  });
-});