@filmwhisper/cli 0.1.0

package/src/__tests__/migrate.test.ts

@@ -0,0 +1,600 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import Database from "better-sqlite3";
+import { migrateCommand } from "../commands/migrate.js";
+
+// ============================================================
+// Helpers — create a realistic v1 mock database
+// ============================================================
+
+function createMockV1Db(dbPath: string): void {
+  const db = new Database(dbPath);
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+
+  db.exec(`
+    CREATE TABLE projects (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      name TEXT NOT NULL UNIQUE,
+      source_type TEXT NOT NULL,
+      source_uri TEXT NOT NULL,
+      proxy_spec_json TEXT NOT NULL,
+      analysis_provider TEXT NOT NULL DEFAULT 'gemini',
+      language TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      target_duration_seconds INTEGER
+    );
+
+    CREATE TABLE assets (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      project_id INTEGER NOT NULL,
+      source_path TEXT NOT NULL,
+      proxy_path TEXT,
+      source_hash TEXT NOT NULL,
+      source_spec_json TEXT NOT NULL,
+      proxy_spec_json TEXT,
+      duration_ms INTEGER,
+      start_timecode TEXT,
+      transcode_status TEXT NOT NULL DEFAULT 'pending',
+      analyze_status TEXT NOT NULL DEFAULT 'pending',
+      transcribe_status TEXT NOT NULL DEFAULT 'pending',
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      UNIQUE(project_id, source_path),
+      FOREIGN KEY(project_id) REFERENCES projects(id)
+    );
+
+    CREATE TABLE asset_analysis (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      asset_id INTEGER NOT NULL UNIQUE,
+      model_name TEXT NOT NULL,
+      model_version TEXT NOT NULL,
+      prompt_version TEXT NOT NULL,
+      subject TEXT NOT NULL,
+      subject_action TEXT NOT NULL,
+      camera_movement TEXT NOT NULL,
+      overall_description TEXT NOT NULL,
+      segments_json TEXT NOT NULL,
+      candidate_score_json TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      editorial_role TEXT NOT NULL DEFAULT 'core',
+      energy INTEGER NOT NULL DEFAULT 3,
+      shot_type TEXT NOT NULL DEFAULT 'medium',
+      is_intro_candidate INTEGER NOT NULL DEFAULT 0,
+      is_outro_candidate INTEGER NOT NULL DEFAULT 0,
+      duplicate_group TEXT NOT NULL DEFAULT '',
+      story_value REAL NOT NULL DEFAULT 0.5,
+      keep_priority INTEGER NOT NULL DEFAULT 50,
+      FOREIGN KEY(asset_id) REFERENCES assets(id)
+    );
+
+    CREATE TABLE transcripts (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      asset_id INTEGER NOT NULL,
+      utterance_index INTEGER NOT NULL,
+      speaker_label TEXT NOT NULL,
+      text TEXT NOT NULL,
+      start_ms INTEGER NOT NULL,
+      end_ms INTEGER NOT NULL,
+      confidence REAL,
+      created_at TEXT NOT NULL,
+      UNIQUE(asset_id, utterance_index),
+      FOREIGN KEY(asset_id) REFERENCES assets(id)
+    );
+
+    CREATE TABLE search_chunks (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      project_id INTEGER NOT NULL,
+      asset_id INTEGER NOT NULL,
+      segment_index INTEGER NOT NULL,
+      segment_start_ms INTEGER NOT NULL,
+      segment_end_ms INTEGER NOT NULL,
+      chunk_text TEXT NOT NULL,
+      editorial_role TEXT NOT NULL,
+      shot_type TEXT NOT NULL,
+      story_value REAL NOT NULL,
+      duplicate_group TEXT NOT NULL,
+      embedding_model TEXT NOT NULL,
+      embedding_version TEXT NOT NULL,
+      qdrant_point_id TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      transcript_text TEXT NOT NULL DEFAULT '',
+      speaker_labels TEXT NOT NULL DEFAULT '[]',
+      UNIQUE(project_id, asset_id, segment_index, embedding_version),
+      FOREIGN KEY(project_id) REFERENCES projects(id),
+      FOREIGN KEY(asset_id) REFERENCES assets(id)
+    );
+
+    CREATE TABLE segment_reviews (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      project_id INTEGER NOT NULL,
+      asset_id INTEGER NOT NULL,
+      segment_index INTEGER NOT NULL,
+      status TEXT NOT NULL,
+      review_order INTEGER NOT NULL DEFAULT 0,
+      updated_at TEXT NOT NULL,
+      UNIQUE(project_id, asset_id, segment_index),
+      FOREIGN KEY(project_id) REFERENCES projects(id),
+      FOREIGN KEY(asset_id) REFERENCES assets(id)
+    );
+
+    CREATE TABLE edit_packages (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      project_id INTEGER NOT NULL,
+      version INTEGER NOT NULL,
+      decision_list_path TEXT NOT NULL,
+      relink_map_path TEXT NOT NULL,
+      preview_path TEXT,
+      xml_path TEXT,
+      manifest_path TEXT,
+      status TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      FOREIGN KEY(project_id) REFERENCES projects(id)
+    );
+
+    CREATE TABLE support_docs (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      project_id INTEGER NOT NULL,
+      doc_type TEXT NOT NULL,
+      path TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      UNIQUE(project_id, doc_type),
+      FOREIGN KEY(project_id) REFERENCES projects(id)
+    );
+
+    CREATE TABLE jobs (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      project_id INTEGER NOT NULL,
+      job_type TEXT NOT NULL,
+      status TEXT NOT NULL,
+      payload_json TEXT NOT NULL,
+      error_message TEXT,
+      created_at TEXT NOT NULL,
+      started_at TEXT,
+      finished_at TEXT,
+      FOREIGN KEY(project_id) REFERENCES projects(id)
+    );
+  `);
+
+  // Insert test project
+  db.prepare(`
+    INSERT INTO projects (name, source_type, source_uri, proxy_spec_json, language, created_at, updated_at, target_duration_seconds)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(
+    "test-project",
+    "local",
+    "/tmp/test-raws",
+    '{"width":1280}',
+    "ko",
+    "2026-03-01T00:00:00Z",
+    "2026-03-01T00:00:00Z",
+    60,
+  );
+
+  // Insert test assets
+  const insertAsset = db.prepare(`
+    INSERT INTO assets (project_id, source_path, proxy_path, source_hash, source_spec_json, duration_ms, transcode_status, analyze_status, transcribe_status, created_at, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+
+  insertAsset.run(
+    1, "/tmp/test-raws/clip1.mp4", null,
+    "aabbccdd1111", '{}', 5000,
+    "complete", "complete", "complete",
+    "2026-03-01T00:00:00Z", "2026-03-01T00:00:00Z",
+  );
+
+  insertAsset.run(
+    1, "/tmp/test-raws/clip2.mp4", "/tmp/proxies/clip2.mp4",
+    "eeff00112222", '{}', 10000,
+    "complete", "complete", "pending",
+    "2026-03-01T00:00:00Z", "2026-03-01T00:00:00Z",
+  );
+
+  // Insert analysis for asset 1
+  db.prepare(`
+    INSERT INTO asset_analysis (asset_id, model_name, model_version, prompt_version, subject, subject_action, camera_movement, overall_description, segments_json, candidate_score_json, created_at, editorial_role, energy, shot_type, story_value, keep_priority)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(
+    1, "gpt-5", "1.0", "v1",
+    "A person walking",
+    "walking forward",
+    "tracking",
+    "A person walks through a garden.",
+    JSON.stringify([
+      { start_ms: 0, end_ms: 2500, summary: "Person enters frame" },
+      { start_ms: 2500, end_ms: 5000, summary: "Person walks through garden" },
+    ]),
+    JSON.stringify({ score: 75, reason: "Good walking shot" }),
+    "2026-03-01T00:00:00Z",
+    "core", 4, "medium", 0.7, 75,
+  );
+
+  // Insert transcripts for asset 1
+  const insertTranscript = db.prepare(`
+    INSERT INTO transcripts (asset_id, utterance_index, speaker_label, text, start_ms, end_ms, confidence, created_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+
+  insertTranscript.run(1, 0, "Speaker A", "Hello world", 0, 1000, 0.95, "2026-03-01T00:00:00Z");
+  insertTranscript.run(1, 1, "Speaker B", "Hi there", 1200, 2000, 0.88, "2026-03-01T00:00:00Z");
+
+  // Insert search chunks
+  db.prepare(`
+    INSERT INTO search_chunks (project_id, asset_id, segment_index, segment_start_ms, segment_end_ms, chunk_text, editorial_role, shot_type, story_value, duplicate_group, embedding_model, embedding_version, qdrant_point_id, created_at, transcript_text, speaker_labels)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(
+    1, 1, 0, 0, 2500,
+    "Person enters frame",
+    "core", "medium", 0.7, "",
+    "text-embedding-3", "v1", "uuid-1",
+    "2026-03-01T00:00:00Z",
+    "Hello world",
+    "Speaker A",
+  );
+
+  // Insert segment review
+  db.prepare(`
+    INSERT INTO segment_reviews (project_id, asset_id, segment_index, status, updated_at)
+    VALUES (?, ?, ?, ?, ?)
+  `).run(1, 1, 0, "keep", "2026-03-01T00:00:00Z");
+
+  db.close();
+}
+
+function createMockEdl(edlPath: string, assets: Array<{ id: number; hash: string }>): void {
+  const dir = path.dirname(edlPath);
+  fs.mkdirSync(dir, { recursive: true });
+
+  const edl = {
+    clips: assets.map((a, i) => ({
+      asset_id: a.id,
+      clip_id: `clip-${a.id}`,
+      original_path: `/tmp/test-raws/clip${a.id}.mp4`,
+      proxy_path: null,
+      selection_reason: `Test clip ${i}`,
+      source_in_ms: 0,
+      source_out_ms: 2500,
+      start_timecode: "00:00:00:00",
+      timeline_in_ms: i * 2500,
+      timeline_out_ms: (i + 1) * 2500,
+    })),
+  };
+  fs.writeFileSync(edlPath, JSON.stringify(edl));
+}
+
+function addEditPackageToDb(dbPath: string, edlPath: string): void {
+  const db = new Database(dbPath);
+  db.prepare(`
+    INSERT INTO edit_packages (project_id, version, decision_list_path, relink_map_path, status, created_at)
+    VALUES (?, ?, ?, ?, ?, ?)
+  `).run(1, 1, edlPath, "/tmp/relink.json", "complete", "2026-03-01T00:00:00Z");
+  db.close();
+}
+
+// ============================================================
+// Tests
+// ============================================================
+
+describe("migrate command", () => {
+  let tmpDir: string;
+  let v1DbPath: string;
+  let targetDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "fw-migrate-test-"));
+    v1DbPath = path.join(tmpDir, "filmwhisper.db");
+    targetDir = path.join(tmpDir, "v2-project");
+    fs.mkdirSync(targetDir, { recursive: true });
+
+    vi.spyOn(process, "exit").mockImplementation(((code?: number) => {
+      throw new Error(`process.exit(${code})`);
+    }) as never);
+    vi.spyOn(console, "log").mockImplementation(() => {});
+    vi.spyOn(console, "error").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("requires --source option", async () => {
+    await expect(migrateCommand({})).rejects.toThrow("process.exit(1)");
+    expect(console.error).toHaveBeenCalledWith("Error: --source <path> is required");
+  });
+
+  it("errors when source database does not exist", async () => {
+    await expect(
+      migrateCommand({ source: "/nonexistent/path/v1.sqlite" }),
+    ).rejects.toThrow("process.exit(1)");
+    expect(console.error).toHaveBeenCalledWith(
+      expect.stringContaining("Source database not found"),
+    );
+  });
+
+  it("errors when v1 database has no projects", async () => {
+    // Create empty DB with schema but no data
+    const emptyDb = new Database(v1DbPath);
+    emptyDb.exec("CREATE TABLE projects (id INTEGER PRIMARY KEY, name TEXT UNIQUE, source_type TEXT, source_uri TEXT, proxy_spec_json TEXT, language TEXT, created_at TEXT, updated_at TEXT, target_duration_seconds INTEGER, analysis_provider TEXT DEFAULT 'gemini')");
+    emptyDb.close();
+
+    await expect(
+      migrateCommand({ source: v1DbPath, target: targetDir }),
+    ).rejects.toThrow("process.exit(1)");
+    expect(console.error).toHaveBeenCalledWith("Error: No projects found in v1 database");
+  });
+
+  describe("successful migration", () => {
+    beforeEach(() => {
+      createMockV1Db(v1DbPath);
+    });
+
+    it("migrates project, assets, analysis, and transcripts to v2 structure", async () => {
+      const result = await migrateCommand({ source: v1DbPath, target: targetDir });
+
+      expect(result).toBeDefined();
+      expect(result!.projectName).toBe("test-project");
+      expect(result!.assetsCount).toBe(2);
+      expect(result!.analysisCount).toBe(1);
+      expect(result!.transcriptAssets).toBe(1);
+
+      // Verify project.fw.json
+      const projectJson = JSON.parse(
+        fs.readFileSync(path.join(targetDir, ".fw", "project.fw.json"), "utf-8"),
+      );
+      expect(projectJson.fw_version).toBe("2.0.0");
+      expect(projectJson.schema).toBe("project");
+      expect(projectJson.name).toBe("test-project");
+      expect(projectJson.language).toBe("ko");
+      expect(projectJson.target_duration_seconds).toBe(60);
+
+      // Verify asset JSON files exist
+      const assetsDir = path.join(targetDir, ".fw", "assets");
+      const assetFiles = fs.readdirSync(assetsDir);
+      expect(assetFiles).toHaveLength(2);
+      expect(assetFiles).toContain("aabbccdd1111.fw.json");
+      expect(assetFiles).toContain("eeff00112222.fw.json");
+
+      // Verify asset with analysis and transcript
+      const asset1 = JSON.parse(
+        fs.readFileSync(path.join(assetsDir, "aabbccdd1111.fw.json"), "utf-8"),
+      );
+      expect(asset1.fw_version).toBe("2.0.0");
+      expect(asset1.schema).toBe("asset");
+      expect(asset1.asset_hash).toBe("aabbccdd1111");
+      expect(asset1.filename).toBe("clip1.mp4");
+      expect(asset1.duration_seconds).toBe(5);
+      expect(asset1.analysis).toBeDefined();
+      expect(asset1.analysis.semantic.subject).toBe("A person walking");
+      expect(asset1.analysis.semantic.summary).toBe("A person walks through a garden.");
+      expect(asset1.analysis.segments).toHaveLength(2);
+      expect(asset1.segments).toHaveLength(2);
+      expect(asset1.segments[0].segment_index).toBe(0);
+      expect(asset1.segments[0].editorial_role).toBe("core");
+      expect(asset1.transcript).toBeDefined();
+      expect(asset1.transcript.speakers).toEqual(["Speaker A", "Speaker B"]);
+      expect(asset1.transcript.utterances).toHaveLength(2);
+
+      // Verify asset without analysis
+      const asset2 = JSON.parse(
+        fs.readFileSync(path.join(assetsDir, "eeff00112222.fw.json"), "utf-8"),
+      );
+      expect(asset2.analysis).toBeUndefined();
+      expect(asset2.transcript).toBeUndefined();
+      expect(asset2.proxy_path).toBe("/tmp/proxies/clip2.mp4");
+    });
+
+    it("migrates search chunks to state.sqlite segments_source", async () => {
+      const result = await migrateCommand({ source: v1DbPath, target: targetDir });
+
+      expect(result!.searchChunks).toBe(1);
+
+      const stateDb = new Database(path.join(targetDir, ".fw", "state.sqlite"), { readonly: true });
+      const rows = stateDb.prepare("SELECT * FROM segments_source").all() as Array<{
+        asset_hash: string;
+        segment_index: number;
+        transcript_text: string;
+        analysis_summary: string;
+      }>;
+      expect(rows).toHaveLength(1);
+      expect(rows[0].asset_hash).toBe("aabbccdd1111");
+      expect(rows[0].transcript_text).toBe("Hello world");
+      expect(rows[0].analysis_summary).toBe("Person enters frame");
+      stateDb.close();
+    });
+
+    it("migrates segment reviews to state.sqlite", async () => {
+      const result = await migrateCommand({ source: v1DbPath, target: targetDir });
+
+      expect(result!.segmentReviews).toBe(1);
+
+      const stateDb = new Database(path.join(targetDir, ".fw", "state.sqlite"), { readonly: true });
+      const rows = stateDb.prepare("SELECT * FROM segment_reviews").all() as Array<{
+        asset_hash: string;
+        segment_index: number;
+        status: string;
+      }>;
+      expect(rows).toHaveLength(1);
+      expect(rows[0].asset_hash).toBe("aabbccdd1111");
+      expect(rows[0].status).toBe("keep");
+      stateDb.close();
+    });
+
+    it("migrates edit packages to timeline_clips", async () => {
+      const edlPath = path.join(tmpDir, "edl", "edit_decision_list.json");
+      createMockEdl(edlPath, [
+        { id: 1, hash: "aabbccdd1111" },
+        { id: 2, hash: "eeff00112222" },
+      ]);
+      addEditPackageToDb(v1DbPath, edlPath);
+
+      const result = await migrateCommand({ source: v1DbPath, target: targetDir });
+
+      expect(result!.timelineClips).toBe(2);
+
+      const stateDb = new Database(path.join(targetDir, ".fw", "state.sqlite"), { readonly: true });
+      const clips = stateDb
+        .prepare("SELECT * FROM timeline_clips ORDER BY clip_index")
+        .all() as Array<{
+        asset_hash: string;
+        clip_index: number;
+        in_point_ms: number;
+        out_point_ms: number;
+      }>;
+      expect(clips).toHaveLength(2);
+      expect(clips[0].asset_hash).toBe("aabbccdd1111");
+      expect(clips[0].in_point_ms).toBe(0);
+      expect(clips[0].out_point_ms).toBe(2500);
+      expect(clips[1].asset_hash).toBe("eeff00112222");
+      stateDb.close();
+    });
+
+    it("creates backup of source database", async () => {
+      await migrateCommand({ source: v1DbPath, target: targetDir });
+
+      expect(fs.existsSync(`${v1DbPath}.bak`)).toBe(true);
+
+      // Verify backup is identical
+      const original = fs.readFileSync(v1DbPath);
+      const backup = fs.readFileSync(`${v1DbPath}.bak`);
+      expect(original.length).toBe(backup.length);
+    });
+
+    it("does not modify source database", async () => {
+      const originalSize = fs.statSync(v1DbPath).size;
+      const originalContent = fs.readFileSync(v1DbPath);
+
+      await migrateCommand({ source: v1DbPath, target: targetDir });
+
+      // Source should be unchanged
+      const afterContent = fs.readFileSync(v1DbPath);
+      expect(afterContent.length).toBe(originalContent.length);
+    });
+  });
+
+  describe("--dry-run flag", () => {
+    beforeEach(() => {
+      createMockV1Db(v1DbPath);
+    });
+
+    it("reports plan without making changes", async () => {
+      const result = await migrateCommand({
+        source: v1DbPath,
+        target: targetDir,
+        dryRun: true,
+      });
+
+      // No result returned for dry run
+      expect(result).toBeUndefined();
+
+      // No .fw directory should be created
+      expect(fs.existsSync(path.join(targetDir, ".fw"))).toBe(false);
+
+      // No backup should be created
+      expect(fs.existsSync(`${v1DbPath}.bak`)).toBe(false);
+
+      // Should log dry run info
+      expect(console.log).toHaveBeenCalledWith(
+        expect.stringContaining("[DRY RUN]"),
+      );
+    });
+  });
+
+  describe("rollback / failure handling", () => {
+    it("preserves original when target directory is invalid", async () => {
+      createMockV1Db(v1DbPath);
+
+      // Create a file at target path to block directory creation
+      const blockingFile = path.join(tmpDir, "blocking-file");
+      fs.writeFileSync(blockingFile, "block");
+      const invalidTarget = path.join(blockingFile, "subdir");
+
+      await expect(
+        migrateCommand({ source: v1DbPath, target: invalidTarget }),
+      ).rejects.toThrow();
+
+      // Source DB should still be readable
+      const db = new Database(v1DbPath, { readonly: true });
+      const count = (
+        db.prepare("SELECT COUNT(*) as count FROM projects").get() as { count: number }
+      ).count;
+      expect(count).toBe(1);
+      db.close();
+    });
+  });
+
+  describe("edge cases", () => {
+    it("handles assets with no analysis or transcripts", async () => {
+      // Create a minimal v1 DB with just a project and asset, no analysis
+      const db = new Database(v1DbPath);
+      db.exec(`
+        CREATE TABLE projects (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT UNIQUE, source_type TEXT, source_uri TEXT, proxy_spec_json TEXT, language TEXT, created_at TEXT, updated_at TEXT, target_duration_seconds INTEGER, analysis_provider TEXT DEFAULT 'gemini');
+        CREATE TABLE assets (id INTEGER PRIMARY KEY AUTOINCREMENT, project_id INTEGER, source_path TEXT, proxy_path TEXT, source_hash TEXT, source_spec_json TEXT, duration_ms INTEGER, transcode_status TEXT DEFAULT 'pending', analyze_status TEXT DEFAULT 'pending', transcribe_status TEXT DEFAULT 'pending', created_at TEXT, updated_at TEXT, FOREIGN KEY(project_id) REFERENCES projects(id));
+        CREATE TABLE asset_analysis (id INTEGER PRIMARY KEY, asset_id INTEGER UNIQUE, model_name TEXT, model_version TEXT, prompt_version TEXT, subject TEXT, subject_action TEXT, camera_movement TEXT, overall_description TEXT, segments_json TEXT, candidate_score_json TEXT, created_at TEXT, editorial_role TEXT DEFAULT 'core', energy INTEGER DEFAULT 3, shot_type TEXT DEFAULT 'medium', story_value REAL DEFAULT 0.5, keep_priority INTEGER DEFAULT 50, FOREIGN KEY(asset_id) REFERENCES assets(id));
+        CREATE TABLE transcripts (id INTEGER PRIMARY KEY, asset_id INTEGER, utterance_index INTEGER, speaker_label TEXT, text TEXT, start_ms INTEGER, end_ms INTEGER, confidence REAL, created_at TEXT, UNIQUE(asset_id, utterance_index), FOREIGN KEY(asset_id) REFERENCES assets(id));
+        CREATE TABLE search_chunks (id INTEGER PRIMARY KEY, project_id INTEGER, asset_id INTEGER, segment_index INTEGER, segment_start_ms INTEGER, segment_end_ms INTEGER, chunk_text TEXT, editorial_role TEXT, shot_type TEXT, story_value REAL, duplicate_group TEXT, embedding_model TEXT, embedding_version TEXT, qdrant_point_id TEXT, created_at TEXT, transcript_text TEXT DEFAULT '', speaker_labels TEXT DEFAULT '[]', UNIQUE(project_id, asset_id, segment_index, embedding_version));
+        CREATE TABLE segment_reviews (id INTEGER PRIMARY KEY, project_id INTEGER, asset_id INTEGER, segment_index INTEGER, status TEXT, review_order INTEGER DEFAULT 0, updated_at TEXT, UNIQUE(project_id, asset_id, segment_index));
+        CREATE TABLE edit_packages (id INTEGER PRIMARY KEY, project_id INTEGER, version INTEGER, decision_list_path TEXT, relink_map_path TEXT, preview_path TEXT, xml_path TEXT, manifest_path TEXT, status TEXT, created_at TEXT);
+      `);
+
+      db.prepare(
+        "INSERT INTO projects (name, source_type, source_uri, proxy_spec_json, language, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?)",
+      ).run("empty-project", "local", "/tmp/empty", "{}", "en", "2026-01-01T00:00:00Z", "2026-01-01T00:00:00Z");
+
+      db.prepare(
+        "INSERT INTO assets (project_id, source_path, source_hash, source_spec_json, duration_ms, transcode_status, analyze_status, transcribe_status, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
+      ).run(1, "/tmp/empty/video.mp4", "hash123", "{}", 3000, "pending", "pending", "pending", "2026-01-01T00:00:00Z", "2026-01-01T00:00:00Z");
+
+      db.close();
+
+      const result = await migrateCommand({ source: v1DbPath, target: targetDir });
+
+      expect(result).toBeDefined();
+      expect(result!.assetsCount).toBe(1);
+      expect(result!.analysisCount).toBe(0);
+      expect(result!.transcriptAssets).toBe(0);
+
+      const asset = JSON.parse(
+        fs.readFileSync(path.join(targetDir, ".fw", "assets", "hash123.fw.json"), "utf-8"),
+      );
+      expect(asset.analysis).toBeUndefined();
+      expect(asset.transcript).toBeUndefined();
+      expect(asset.duration_seconds).toBe(3);
+    });
+
+    it("handles null duration_ms gracefully", async () => {
+      const db = new Database(v1DbPath);
+      db.exec(`
+        CREATE TABLE projects (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT UNIQUE, source_type TEXT, source_uri TEXT, proxy_spec_json TEXT, language TEXT, created_at TEXT, updated_at TEXT, target_duration_seconds INTEGER, analysis_provider TEXT DEFAULT 'gemini');
+        CREATE TABLE assets (id INTEGER PRIMARY KEY AUTOINCREMENT, project_id INTEGER, source_path TEXT, proxy_path TEXT, source_hash TEXT, source_spec_json TEXT, duration_ms INTEGER, transcode_status TEXT DEFAULT 'pending', analyze_status TEXT DEFAULT 'pending', transcribe_status TEXT DEFAULT 'pending', created_at TEXT, updated_at TEXT);
+        CREATE TABLE asset_analysis (id INTEGER PRIMARY KEY, asset_id INTEGER UNIQUE, model_name TEXT, model_version TEXT, prompt_version TEXT, subject TEXT, subject_action TEXT, camera_movement TEXT, overall_description TEXT, segments_json TEXT, candidate_score_json TEXT, created_at TEXT, editorial_role TEXT DEFAULT 'core', energy INTEGER DEFAULT 3, shot_type TEXT DEFAULT 'medium', story_value REAL DEFAULT 0.5, keep_priority INTEGER DEFAULT 50);
+        CREATE TABLE transcripts (id INTEGER PRIMARY KEY, asset_id INTEGER, utterance_index INTEGER, speaker_label TEXT, text TEXT, start_ms INTEGER, end_ms INTEGER, confidence REAL, created_at TEXT, UNIQUE(asset_id, utterance_index));
+        CREATE TABLE search_chunks (id INTEGER PRIMARY KEY, project_id INTEGER, asset_id INTEGER, segment_index INTEGER, segment_start_ms INTEGER, segment_end_ms INTEGER, chunk_text TEXT, editorial_role TEXT, shot_type TEXT, story_value REAL, duplicate_group TEXT, embedding_model TEXT, embedding_version TEXT, qdrant_point_id TEXT, created_at TEXT, transcript_text TEXT DEFAULT '', speaker_labels TEXT DEFAULT '[]', UNIQUE(project_id, asset_id, segment_index, embedding_version));
+        CREATE TABLE segment_reviews (id INTEGER PRIMARY KEY, project_id INTEGER, asset_id INTEGER, segment_index INTEGER, status TEXT, review_order INTEGER DEFAULT 0, updated_at TEXT, UNIQUE(project_id, asset_id, segment_index));
+        CREATE TABLE edit_packages (id INTEGER PRIMARY KEY, project_id INTEGER, version INTEGER, decision_list_path TEXT, relink_map_path TEXT, preview_path TEXT, xml_path TEXT, manifest_path TEXT, status TEXT, created_at TEXT);
+      `);
+
+      db.prepare(
+        "INSERT INTO projects (name, source_type, source_uri, proxy_spec_json, language, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?)",
+      ).run("null-dur", "local", "/tmp/x", "{}", "en", "2026-01-01T00:00:00Z", "2026-01-01T00:00:00Z");
+
+      db.prepare(
+        "INSERT INTO assets (project_id, source_path, source_hash, source_spec_json, duration_ms, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?)",
+      ).run(1, "/tmp/x/a.mp4", "nullhash", "{}", null, "2026-01-01T00:00:00Z", "2026-01-01T00:00:00Z");
+
+      db.close();
+
+      const result = await migrateCommand({ source: v1DbPath, target: targetDir });
+      expect(result!.assetsCount).toBe(1);
+
+      const asset = JSON.parse(
+        fs.readFileSync(path.join(targetDir, ".fw", "assets", "nullhash.fw.json"), "utf-8"),
+      );
+      expect(asset.duration_seconds).toBe(0);
+    });
+  });
+});

package/src/commands/init.ts

@@ -0,0 +1,19 @@
+import { createMcpClient } from "../mcp-client.js";
+
+export async function initCommand(sourcePath: string, options: { name?: string }) {
+  const client = await createMcpClient();
+  try {
+    const name = options.name ?? sourcePath.split("/").filter(Boolean).pop() ?? "untitled";
+    const result = await client.callTool("fw_project_init", {
+      source_path: sourcePath,
+      name,
+    });
+    console.log("Project initialized:");
+    console.log(JSON.stringify(JSON.parse(result.content[0].text), null, 2));
+  } catch (err) {
+    console.error("Error:", err instanceof Error ? err.message : err);
+    process.exit(1);
+  } finally {
+    await client.close();
+  }
+}