@filmwhisper/cli 0.1.0

package/src/commands/migrate.ts

@@ -0,0 +1,734 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import Database from "better-sqlite3";
+import { randomUUID } from "node:crypto";
+
+// ============================================================
+// Types
+// ============================================================
+
+interface MigrateOptions {
+  source?: string;
+  target?: string;
+  dryRun?: boolean;
+}
+
+// v1 row types
+interface V1Project {
+  id: number;
+  name: string;
+  source_type: string;
+  source_uri: string;
+  proxy_spec_json: string;
+  language: string;
+  target_duration_seconds: number | null;
+  created_at: string;
+  updated_at: string;
+}
+
+interface V1Asset {
+  id: number;
+  project_id: number;
+  source_path: string;
+  proxy_path: string | null;
+  source_hash: string;
+  duration_ms: number | null;
+  transcode_status: string;
+  analyze_status: string;
+  transcribe_status: string;
+  created_at: string;
+  updated_at: string;
+}
+
+interface V1Analysis {
+  asset_id: number;
+  subject: string;
+  overall_description: string;
+  editorial_role: string;
+  energy: number;
+  shot_type: string;
+  story_value: number;
+  segments_json: string;
+}
+
+interface V1Transcript {
+  asset_id: number;
+  utterance_index: number;
+  speaker_label: string;
+  text: string;
+  start_ms: number;
+  end_ms: number;
+  confidence: number | null;
+}
+
+interface V1SearchChunk {
+  asset_id: number;
+  segment_index: number;
+  chunk_text: string;
+  transcript_text: string;
+  editorial_role: string;
+  speaker_labels: string;
+}
+
+interface V1SegmentReview {
+  asset_id: number;
+  segment_index: number;
+  status: string;
+  updated_at: string;
+}
+
+interface V1EditPackage {
+  id: number;
+  project_id: number;
+  version: number;
+  decision_list_path: string;
+  status: string;
+}
+
+interface V1EdlClip {
+  asset_id: number;
+  clip_id: string;
+  selection_reason: string;
+  source_in_ms: number;
+  source_out_ms: number;
+}
+
+// v2 types (inline to avoid import issues in CLI)
+interface FwProject {
+  fw_version: string;
+  schema: "project";
+  name: string;
+  source_path: string;
+  language: string;
+  proxy_spec?: string;
+  target_duration_seconds?: number;
+  created_at: string;
+  updated_at: string;
+}
+
+interface FwAsset {
+  fw_version: string;
+  schema: "asset";
+  asset_hash: string;
+  filename: string;
+  source_path: string;
+  duration_seconds: number;
+  created_at: string;
+  updated_at: string;
+  transcode_status: string;
+  transcribe_status: string;
+  analyze_status: string;
+  proxy_path?: string;
+  analysis?: {
+    semantic?: {
+      subject: string;
+      editorial_role: string;
+      energy: number;
+      shot_type: string;
+      story_value: number;
+      summary: string;
+    };
+    segments?: Array<{
+      segment_index: number;
+      start_ms: number;
+      end_ms: number;
+      editorial_role: string;
+      energy: number;
+      story_value: number;
+      summary: string;
+    }>;
+  };
+  transcript?: {
+    speakers: string[];
+    utterances: Array<{
+      speaker_label: string;
+      text: string;
+      start_ms: number;
+      end_ms: number;
+      confidence: number;
+    }>;
+  };
+  segments?: Array<{
+    segment_index: number;
+    start_ms: number;
+    end_ms: number;
+    editorial_role: string;
+    energy: number;
+    story_value: number;
+    summary: string;
+  }>;
+}
+
+interface CountRow {
+  count: number;
+}
+
+interface TableRow {
+  name: string;
+}
+
+const FW_VERSION = "2.0.0";
+
+// ============================================================
+// Migration logic
+// ============================================================
+
+export interface MigrationResult {
+  projectName: string;
+  assetsCount: number;
+  analysisCount: number;
+  transcriptAssets: number;
+  searchChunks: number;
+  segmentReviews: number;
+  timelineClips: number;
+  targetPath: string;
+  backupPath: string;
+}
+
+function mapProcessingStatus(status: string): string {
+  const valid = ["pending", "running", "complete", "failed"];
+  return valid.includes(status) ? status : "pending";
+}
+
+function mapReviewStatus(status: string): string {
+  const valid = ["keep", "exclude", "needs_review"];
+  if (valid.includes(status)) return status;
+  // v1 may have different status values — map common ones
+  if (status === "approved" || status === "accepted") return "keep";
+  if (status === "rejected" || status === "removed") return "exclude";
+  return "needs_review";
+}
+
+/**
+ * Build asset_id → source_hash lookup from v1 DB.
+ */
+function buildAssetIdToHash(v1: Database.Database): Map<number, string> {
+  const rows = v1.prepare("SELECT id, source_hash FROM assets").all() as Array<{
+    id: number;
+    source_hash: string;
+  }>;
+  const map = new Map<number, string>();
+  for (const row of rows) {
+    map.set(row.id, row.source_hash);
+  }
+  return map;
+}
+
+function analyzeV1(v1: Database.Database): {
+  tables: string[];
+  counts: Record<string, number>;
+} {
+  const tables = (
+    v1.prepare("SELECT name FROM sqlite_master WHERE type='table'").all() as TableRow[]
+  ).map((r) => r.name);
+
+  const counts: Record<string, number> = {};
+  for (const name of tables) {
+    const row = v1.prepare(`SELECT COUNT(*) as count FROM "${name}"`).get() as CountRow;
+    counts[name] = row.count;
+  }
+  return { tables, counts };
+}
+
+function migrateProject(v1: Database.Database, projectId: number): FwProject {
+  const row = v1
+    .prepare("SELECT * FROM projects WHERE id = ?")
+    .get(projectId) as V1Project | undefined;
+  if (!row) throw new Error(`v1 project id=${projectId} not found`);
+
+  const project: FwProject = {
+    fw_version: FW_VERSION,
+    schema: "project",
+    name: row.name,
+    source_path: row.source_uri,
+    language: row.language,
+    created_at: row.created_at,
+    updated_at: row.updated_at,
+  };
+  if (row.proxy_spec_json && row.proxy_spec_json !== "{}") {
+    project.proxy_spec = row.proxy_spec_json;
+  }
+  if (row.target_duration_seconds != null) {
+    project.target_duration_seconds = row.target_duration_seconds;
+  }
+  return project;
+}
+
+function migrateAssets(
+  v1: Database.Database,
+  projectId: number,
+): FwAsset[] {
+  const assets = v1
+    .prepare("SELECT * FROM assets WHERE project_id = ?")
+    .all(projectId) as V1Asset[];
+
+  // Pre-fetch analyses and transcripts for all assets
+  const analyses = new Map<number, V1Analysis>();
+  const rows = v1
+    .prepare(
+      "SELECT * FROM asset_analysis WHERE asset_id IN (SELECT id FROM assets WHERE project_id = ?)",
+    )
+    .all(projectId) as V1Analysis[];
+  for (const a of rows) {
+    analyses.set(a.asset_id, a);
+  }
+
+  const transcriptRows = v1
+    .prepare(
+      "SELECT * FROM transcripts WHERE asset_id IN (SELECT id FROM assets WHERE project_id = ?) ORDER BY asset_id, utterance_index",
+    )
+    .all(projectId) as V1Transcript[];
+  const transcriptsByAsset = new Map<number, V1Transcript[]>();
+  for (const t of transcriptRows) {
+    const list = transcriptsByAsset.get(t.asset_id) ?? [];
+    list.push(t);
+    transcriptsByAsset.set(t.asset_id, list);
+  }
+
+  return assets.map((asset) => {
+    const fwAsset: FwAsset = {
+      fw_version: FW_VERSION,
+      schema: "asset",
+      asset_hash: asset.source_hash,
+      filename: path.basename(asset.source_path),
+      source_path: asset.source_path,
+      duration_seconds: (asset.duration_ms ?? 0) / 1000,
+      created_at: asset.created_at,
+      updated_at: asset.updated_at,
+      transcode_status: mapProcessingStatus(asset.transcode_status),
+      transcribe_status: mapProcessingStatus(asset.transcribe_status),
+      analyze_status: mapProcessingStatus(asset.analyze_status),
+    };
+
+    if (asset.proxy_path) {
+      fwAsset.proxy_path = asset.proxy_path;
+    }
+
+    // Merge analysis
+    const analysis = analyses.get(asset.id);
+    if (analysis) {
+      let segments: FwAsset["segments"];
+      try {
+        const rawSegments = JSON.parse(analysis.segments_json) as Array<{
+          start_ms: number;
+          end_ms: number;
+          summary: string;
+        }>;
+        segments = rawSegments.map((s, i) => ({
+          segment_index: i,
+          start_ms: s.start_ms,
+          end_ms: s.end_ms,
+          editorial_role: analysis.editorial_role,
+          energy: analysis.energy,
+          story_value: analysis.story_value,
+          summary: s.summary,
+        }));
+      } catch {
+        segments = undefined;
+      }
+
+      fwAsset.analysis = {
+        semantic: {
+          subject: analysis.subject,
+          editorial_role: analysis.editorial_role,
+          energy: analysis.energy,
+          shot_type: analysis.shot_type,
+          story_value: analysis.story_value,
+          summary: analysis.overall_description,
+        },
+        segments,
+      };
+      fwAsset.segments = segments;
+    }
+
+    // Merge transcripts
+    const transcripts = transcriptsByAsset.get(asset.id);
+    if (transcripts && transcripts.length > 0) {
+      const speakers = [...new Set(transcripts.map((t) => t.speaker_label))];
+      fwAsset.transcript = {
+        speakers,
+        utterances: transcripts.map((t) => ({
+          speaker_label: t.speaker_label,
+          text: t.text,
+          start_ms: t.start_ms,
+          end_ms: t.end_ms,
+          confidence: t.confidence ?? 0,
+        })),
+      };
+    }
+
+    return fwAsset;
+  });
+}
+
+function migrateSearchChunks(
+  v1: Database.Database,
+  v2State: Database.Database,
+  projectId: number,
+  assetIdToHash: Map<number, string>,
+): number {
+  const chunks = v1
+    .prepare("SELECT * FROM search_chunks WHERE project_id = ?")
+    .all(projectId) as V1SearchChunk[];
+
+  if (chunks.length === 0) return 0;
+
+  const insert = v2State.prepare(
+    `INSERT OR IGNORE INTO segments_source (asset_hash, segment_index, transcript_text, analysis_summary, editorial_role, speaker_labels)
+     VALUES (?, ?, ?, ?, ?, ?)`,
+  );
+
+  let count = 0;
+  for (const chunk of chunks) {
+    const hash = assetIdToHash.get(chunk.asset_id);
+    if (!hash) continue;
+    insert.run(
+      hash,
+      chunk.segment_index,
+      chunk.transcript_text || null,
+      chunk.chunk_text || null,
+      chunk.editorial_role || null,
+      chunk.speaker_labels || null,
+    );
+    count++;
+  }
+  return count;
+}
+
+function migrateSegmentReviews(
+  v1: Database.Database,
+  v2State: Database.Database,
+  projectId: number,
+  assetIdToHash: Map<number, string>,
+): number {
+  const reviews = v1
+    .prepare("SELECT * FROM segment_reviews WHERE project_id = ?")
+    .all(projectId) as V1SegmentReview[];
+
+  if (reviews.length === 0) return 0;
+
+  const insert = v2State.prepare(
+    `INSERT OR IGNORE INTO segment_reviews (asset_hash, segment_index, status, updated_at)
+     VALUES (?, ?, ?, ?)`,
+  );
+
+  let count = 0;
+  for (const review of reviews) {
+    const hash = assetIdToHash.get(review.asset_id);
+    if (!hash) continue;
+    insert.run(
+      hash,
+      review.segment_index,
+      mapReviewStatus(review.status),
+      review.updated_at,
+    );
+    count++;
+  }
+  return count;
+}
+
+function migrateEditPackages(
+  v1: Database.Database,
+  v2State: Database.Database,
+  projectId: number,
+  assetIdToHash: Map<number, string>,
+): number {
+  // Find the latest complete edit package
+  const pkg = v1
+    .prepare(
+      "SELECT * FROM edit_packages WHERE project_id = ? AND status = 'complete' ORDER BY version DESC LIMIT 1",
+    )
+    .get(projectId) as V1EditPackage | undefined;
+
+  if (!pkg) return 0;
+
+  // Try to read the EDL JSON file
+  let clips: V1EdlClip[];
+  try {
+    const edlContent = fs.readFileSync(pkg.decision_list_path, "utf-8");
+    const edl = JSON.parse(edlContent) as { clips: V1EdlClip[] };
+    clips = edl.clips ?? [];
+  } catch {
+    // EDL file not readable — skip timeline migration
+    return 0;
+  }
+
+  if (clips.length === 0) return 0;
+
+  const insert = v2State.prepare(
+    `INSERT INTO timeline_clips (id, asset_hash, clip_index, in_point_ms, out_point_ms, editorial_rationale, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+  );
+
+  const now = new Date().toISOString();
+  let count = 0;
+  for (let i = 0; i < clips.length; i++) {
+    const clip = clips[i];
+    const hash = assetIdToHash.get(clip.asset_id);
+    if (!hash) continue;
+    insert.run(
+      randomUUID(),
+      hash,
+      i,
+      clip.source_in_ms,
+      clip.source_out_ms,
+      clip.selection_reason || null,
+      now,
+      now,
+    );
+    count++;
+  }
+  return count;
+}
+
+function initV2StateDb(dbPath: string): Database.Database {
+  const dir = path.dirname(dbPath);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+
+  const db = new Database(dbPath);
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS revisions (
+      scope TEXT PRIMARY KEY,
+      revision INTEGER NOT NULL DEFAULT 0
+    );
+    INSERT OR IGNORE INTO revisions (scope, revision) VALUES ('timeline', 0);
+    INSERT OR IGNORE INTO revisions (scope, revision) VALUES ('reviews', 0);
+    INSERT OR IGNORE INTO revisions (scope, revision) VALUES ('project', 0);
+    INSERT OR IGNORE INTO revisions (scope, revision) VALUES ('jobs', 0);
+    INSERT OR IGNORE INTO revisions (scope, revision) VALUES ('fts', 0);
+
+    CREATE TABLE IF NOT EXISTS timeline_clips (
+      id TEXT PRIMARY KEY,
+      asset_hash TEXT NOT NULL,
+      clip_index INTEGER NOT NULL,
+      in_point_ms INTEGER NOT NULL,
+      out_point_ms INTEGER NOT NULL,
+      editorial_rationale TEXT,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS segment_reviews (
+      asset_hash TEXT NOT NULL,
+      segment_index INTEGER NOT NULL,
+      status TEXT NOT NULL CHECK(status IN ('keep', 'exclude', 'needs_review')),
+      reviewer TEXT,
+      updated_at TEXT NOT NULL,
+      PRIMARY KEY (asset_hash, segment_index)
+    );
+
+    CREATE TABLE IF NOT EXISTS undo_history (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      scope TEXT NOT NULL,
+      operation TEXT NOT NULL,
+      created_at TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS jobs (
+      job_id TEXT PRIMARY KEY,
+      project_id TEXT NOT NULL,
+      type TEXT NOT NULL,
+      status TEXT NOT NULL DEFAULT 'pending',
+      progress REAL DEFAULT 0,
+      step TEXT,
+      params TEXT,
+      result TEXT,
+      error TEXT,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS segments_source (
+      asset_hash TEXT NOT NULL,
+      segment_index INTEGER NOT NULL,
+      transcript_text TEXT,
+      analysis_summary TEXT,
+      editorial_role TEXT,
+      speaker_labels TEXT,
+      PRIMARY KEY (asset_hash, segment_index)
+    );
+
+    CREATE VIRTUAL TABLE IF NOT EXISTS segments_fts USING fts5(
+      transcript_text,
+      analysis_summary,
+      editorial_role,
+      speaker_labels,
+      content='segments_source',
+      content_rowid='rowid',
+      tokenize='unicode61'
+    );
+
+    CREATE TRIGGER IF NOT EXISTS segments_source_ai AFTER INSERT ON segments_source BEGIN
+      INSERT INTO segments_fts(rowid, transcript_text, analysis_summary, editorial_role, speaker_labels)
+      VALUES (new.rowid, new.transcript_text, new.analysis_summary, new.editorial_role, new.speaker_labels);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS segments_source_ad AFTER DELETE ON segments_source BEGIN
+      INSERT INTO segments_fts(segments_fts, rowid, transcript_text, analysis_summary, editorial_role, speaker_labels)
+      VALUES ('delete', old.rowid, old.transcript_text, old.analysis_summary, old.editorial_role, old.speaker_labels);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS segments_source_au AFTER UPDATE ON segments_source BEGIN
+      INSERT INTO segments_fts(segments_fts, rowid, transcript_text, analysis_summary, editorial_role, speaker_labels)
+      VALUES ('delete', old.rowid, old.transcript_text, old.analysis_summary, old.editorial_role, old.speaker_labels);
+      INSERT INTO segments_fts(rowid, transcript_text, analysis_summary, editorial_role, speaker_labels)
+      VALUES (new.rowid, new.transcript_text, new.analysis_summary, new.editorial_role, new.speaker_labels);
+    END;
+  `);
+
+  return db;
+}
+
+// ============================================================
+// Public command
+// ============================================================
+
+export async function migrateCommand(options: MigrateOptions): Promise<MigrationResult | undefined> {
+  const { source, dryRun } = options;
+
+  if (!source) {
+    console.error("Error: --source <path> is required");
+    process.exit(1);
+  }
+
+  if (!fs.existsSync(source)) {
+    console.error(`Error: Source database not found: ${source}`);
+    process.exit(1);
+  }
+
+  const v1 = new Database(source, { readonly: true });
+
+  try {
+    // Step 1: Analyze v1
+    const { tables, counts } = analyzeV1(v1);
+
+    console.log("v1 데이터베이스 분석:");
+    console.log("=====================");
+    for (const name of tables) {
+      console.log(`  ${name}: ${counts[name]} 레코드`);
+    }
+
+    // Determine which project to migrate (first one)
+    const projects = v1.prepare("SELECT * FROM projects ORDER BY id").all() as V1Project[];
+    if (projects.length === 0) {
+      console.error("Error: No projects found in v1 database");
+      process.exit(1);
+    }
+
+    // Migrate each project
+    for (const v1Project of projects) {
+      console.log(`\n프로젝트 마이그레이션: "${v1Project.name}" (id=${v1Project.id})`);
+
+      // Determine target path
+      const targetPath = options.target
+        ? projects.length > 1
+          ? path.join(options.target, v1Project.name)
+          : options.target
+        : v1Project.source_uri;
+
+      if (dryRun) {
+        console.log("\n[DRY RUN] 실제 변경 없음");
+        console.log(`  대상 경로: ${targetPath}`);
+
+        const assetCount = (
+          v1.prepare("SELECT COUNT(*) as count FROM assets WHERE project_id = ?").get(v1Project.id) as CountRow
+        ).count;
+        const analysisCount = (
+          v1
+            .prepare(
+              "SELECT COUNT(*) as count FROM asset_analysis WHERE asset_id IN (SELECT id FROM assets WHERE project_id = ?)",
+            )
+            .get(v1Project.id) as CountRow
+        ).count;
+
+        console.log(`  에셋: ${assetCount}개`);
+        console.log(`  분석: ${analysisCount}개`);
+        console.log(`  → .fw/project.fw.json 생성 예정`);
+        console.log(`  → .fw/assets/*.fw.json ${assetCount}개 생성 예정`);
+        console.log(`  → .fw/state.sqlite 생성 예정`);
+        continue;
+      }
+
+      // Step 2: Backup source
+      const backupPath = `${source}.bak`;
+      if (!fs.existsSync(backupPath)) {
+        fs.copyFileSync(source, backupPath);
+        console.log(`  백업 생성: ${backupPath}`);
+      } else {
+        console.log(`  백업 이미 존재: ${backupPath}`);
+      }
+
+      // Step 3: Create target directory
+      const fwDir = path.join(targetPath, ".fw");
+      const assetsDir = path.join(fwDir, "assets");
+      fs.mkdirSync(assetsDir, { recursive: true });
+      console.log(`  디렉토리 생성: ${fwDir}`);
+
+      // Step 4: Build asset ID → hash lookup
+      const assetIdToHash = buildAssetIdToHash(v1);
+
+      // Step 5: Migrate project JSON
+      const project = migrateProject(v1, v1Project.id);
+      const projectJsonPath = path.join(fwDir, "project.fw.json");
+      fs.writeFileSync(projectJsonPath, JSON.stringify(project, null, 2));
+      console.log(`  project.fw.json 생성 완료`);
+
+      // Step 6: Migrate assets
+      const fwAssets = migrateAssets(v1, v1Project.id);
+      let analysisCount = 0;
+      let transcriptAssets = 0;
+      for (const asset of fwAssets) {
+        const assetPath = path.join(assetsDir, `${asset.asset_hash}.fw.json`);
+        fs.writeFileSync(assetPath, JSON.stringify(asset, null, 2));
+        if (asset.analysis) analysisCount++;
+        if (asset.transcript) transcriptAssets++;
+      }
+      console.log(`  에셋 ${fwAssets.length}개 마이그레이션 (분석: ${analysisCount}, 트랜스크립트: ${transcriptAssets})`);
+
+      // Step 7: Migrate state.sqlite data
+      const statePath = path.join(fwDir, "state.sqlite");
+      const v2State = initV2StateDb(statePath);
+
+      try {
+        const migrateSqlite = v2State.transaction(() => {
+          const chunks = migrateSearchChunks(v1, v2State, v1Project.id, assetIdToHash);
+          console.log(`  검색 청크 ${chunks}개 마이그레이션`);
+
+          const reviews = migrateSegmentReviews(v1, v2State, v1Project.id, assetIdToHash);
+          console.log(`  세그먼트 리뷰 ${reviews}개 마이그레이션`);
+
+          const clips = migrateEditPackages(v1, v2State, v1Project.id, assetIdToHash);
+          console.log(`  타임라인 클립 ${clips}개 마이그레이션`);
+
+          return { chunks, reviews, clips };
+        });
+
+        const { chunks, reviews, clips } = migrateSqlite();
+
+        console.log(`\n마이그레이션 완료: "${v1Project.name}"`);
+        console.log(`  경로: ${targetPath}/.fw/`);
+
+        return {
+          projectName: v1Project.name,
+          assetsCount: fwAssets.length,
+          analysisCount,
+          transcriptAssets,
+          searchChunks: chunks,
+          segmentReviews: reviews,
+          timelineClips: clips,
+          targetPath,
+          backupPath,
+        };
+      } finally {
+        v2State.close();
+      }
+    }
+  } finally {
+    v1.close();
+  }
+
+  return undefined;
+}