@lumy-pack/scene-sieve 0.0.4 → 0.0.6

package/dist/cli.mjs

@@ -1,86 +1,95 @@
 #!/usr/bin/env node
-
-// src/cli.ts
-import { createRequire as createRequire2 } from "module";
-import { Command } from "commander";
-
-// src/core/orchestrator.ts
-import { randomUUID } from "crypto";
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
 // src/utils/logger.ts
 import pc from "picocolors";
-var debugMode = false;
 function setDebugMode(enabled) {
   debugMode = enabled;
 }
 function timestamp() {
   return (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", { hour12: false });
 }
-var logger = {
-  info(message) {
-    console.log(`${pc.blue("info")} ${message}`);
-  },
-  success(message) {
-    console.log(`
+var debugMode, logger;
+var init_logger = __esm({
+  "src/utils/logger.ts"() {
+    "use strict";
+    debugMode = false;
+    logger = {
+      info(message) {
+        console.log(`${pc.blue("info")} ${message}`);
+      },
+      success(message) {
+        console.log(`
 ${pc.green("done")} ${message}`);
-  },
-  warn(message) {
-    console.warn(`${pc.yellow("warn")} ${message}`);
-  },
-  error(message) {
-    console.error(`${pc.red("error")} ${message}`);
-  },
-  debug(message) {
-    if (debugMode) {
-      console.log(`${pc.gray(`[${timestamp()}] debug`)} ${message}`);
-    }
+      },
+      warn(message) {
+        console.warn(`${pc.yellow("warn")} ${message}`);
+      },
+      error(message) {
+        console.error(`${pc.red("error")} ${message}`);
+      },
+      debug(message) {
+        if (debugMode) {
+          console.log(`${pc.gray(`[${timestamp()}] debug`)} ${message}`);
+        }
+      }
+    };
   }
-};
-
-// src/core/analyzer.ts
-import { createRequire } from "module";
-import sharp from "sharp";
+});
 
 // src/constants.ts
 import { tmpdir } from "os";
 import { join } from "path";
-var APP_NAME = "scene-sieve";
-var DEFAULT_COUNT = 20;
-var DEFAULT_THRESHOLD = 0.5;
-var DEFAULT_FPS = 5;
-var DEFAULT_SCALE = 720;
-var DEFAULT_QUALITY = 80;
-var NORMALIZATION_PERCENTILE = 0.9;
-var WORKSPACE_PREFIX = `${APP_NAME}-`;
-var TEMP_BASE_DIR = tmpdir();
-var SUPPORTED_VIDEO_EXTENSIONS = [
-  ".mp4",
-  ".mov",
-  ".avi",
-  ".mkv",
-  ".webm"
-];
-var SUPPORTED_GIF_EXTENSIONS = [".gif"];
-var FRAME_OUTPUT_EXTENSION = ".jpg";
-var OPENCV_BATCH_SIZE = 10;
-var MIN_IFRAME_COUNT = 3;
-var DBSCAN_ALPHA = 0.03;
-var DBSCAN_MIN_PTS = 4;
-var IOU_THRESHOLD = 0.9;
-var DECAY_LAMBDA = 0.95;
-var ANIMATION_FRAME_THRESHOLD = 5;
-var MATCH_DISTANCE_THRESHOLD = 0.25;
-var PIXELDIFF_GAUSSIAN_KERNEL = 3;
-var PIXELDIFF_BINARY_THRESHOLD = 30;
-var PIXELDIFF_CONTOUR_MIN_AREA = 100;
-var PIXELDIFF_SAMPLE_SPACING = 8;
 function getTempWorkspaceDir(sessionId) {
   return join(TEMP_BASE_DIR, `${WORKSPACE_PREFIX}${sessionId}`);
 }
+var APP_NAME, DEFAULT_COUNT, DEFAULT_THRESHOLD, DEFAULT_FPS, DEFAULT_SCALE, DEFAULT_QUALITY, DEFAULT_MAX_FRAMES, NORMALIZATION_PERCENTILE, WORKSPACE_PREFIX, TEMP_BASE_DIR, SUPPORTED_VIDEO_EXTENSIONS, SUPPORTED_GIF_EXTENSIONS, FRAME_OUTPUT_EXTENSION, FRAME_FILENAME_PATTERN, OPENCV_BATCH_SIZE, DBSCAN_ALPHA, DBSCAN_MIN_PTS, IOU_THRESHOLD, DECAY_LAMBDA, ANIMATION_FRAME_THRESHOLD, MATCH_DISTANCE_THRESHOLD, PIXELDIFF_GAUSSIAN_KERNEL, PIXELDIFF_BINARY_THRESHOLD, PIXELDIFF_CONTOUR_MIN_AREA, PIXELDIFF_SAMPLE_SPACING;
+var init_constants = __esm({
+  "src/constants.ts"() {
+    "use strict";
+    APP_NAME = "scene-sieve";
+    DEFAULT_COUNT = 20;
+    DEFAULT_THRESHOLD = 0.5;
+    DEFAULT_FPS = 5;
+    DEFAULT_SCALE = 720;
+    DEFAULT_QUALITY = 80;
+    DEFAULT_MAX_FRAMES = 300;
+    NORMALIZATION_PERCENTILE = 0.9;
+    WORKSPACE_PREFIX = `${APP_NAME}-`;
+    TEMP_BASE_DIR = tmpdir();
+    SUPPORTED_VIDEO_EXTENSIONS = [
+      ".mp4",
+      ".mov",
+      ".avi",
+      ".mkv",
+      ".webm"
+    ];
+    SUPPORTED_GIF_EXTENSIONS = [".gif"];
+    FRAME_OUTPUT_EXTENSION = ".jpg";
+    FRAME_FILENAME_PATTERN = "frame_%06d.jpg";
+    OPENCV_BATCH_SIZE = 10;
+    DBSCAN_ALPHA = 0.03;
+    DBSCAN_MIN_PTS = 4;
+    IOU_THRESHOLD = 0.9;
+    DECAY_LAMBDA = 0.95;
+    ANIMATION_FRAME_THRESHOLD = 5;
+    MATCH_DISTANCE_THRESHOLD = 0.25;
+    PIXELDIFF_GAUSSIAN_KERNEL = 3;
+    PIXELDIFF_BINARY_THRESHOLD = 30;
+    PIXELDIFF_CONTOUR_MIN_AREA = 100;
+    PIXELDIFF_SAMPLE_SPACING = 8;
+  }
+});
 
 // src/core/dbscan.ts
-var UNVISITED = -2;
-var NOISE = -1;
 function dbscan(points, imageWidth, imageHeight, alpha, minPts) {
   if (points.length === 0) {
     return { labels: [], boundingBoxes: [] };
@@ -155,11 +164,19 @@ function findNeighbors(points, idx, epsSquared) {
   }
   return neighbors;
 }
+var UNVISITED, NOISE;
+var init_dbscan = __esm({
+  "src/core/dbscan.ts"() {
+    "use strict";
+    init_constants();
+    UNVISITED = -2;
+    NOISE = -1;
+  }
+});
 
 // src/core/analyzer.ts
-var OPENCV_INIT_TIMEOUT_MS = 3e4;
-var require2 = createRequire(import.meta.url);
-var cvReady = null;
+import { createRequire } from "module";
+import sharp from "sharp";
 async function ensureOpenCV() {
   if (!cvReady) {
     cvReady = (async () => {
@@ -201,67 +218,6 @@ function computeIoU(a, b) {
   const union = aArea + bArea - intersection;
   return union === 0 ? 0 : intersection / union;
 }
-var IoUTracker = class {
-  regions = [];
-  update(boxes, pairIndex) {
-    const animationIndices = /* @__PURE__ */ new Set();
-    const matched = /* @__PURE__ */ new Set();
-    for (let bi = 0; bi < boxes.length; bi++) {
-      const box = boxes[bi];
-      let bestIoU = 0;
-      let bestRegionIdx = -1;
-      for (let ri = 0; ri < this.regions.length; ri++) {
-        if (matched.has(ri)) continue;
-        const iou = computeIoU(box, this.regions[ri].box);
-        if (iou > bestIoU) {
-          bestIoU = iou;
-          bestRegionIdx = ri;
-        }
-      }
-      if (bestIoU > IOU_THRESHOLD && bestRegionIdx !== -1) {
-        const region = this.regions[bestRegionIdx];
-        const gap = pairIndex - region.lastSeen;
-        region.box = box;
-        region.consecutiveCount++;
-        region.lastSeen = pairIndex;
-        region.weight *= Math.pow(DECAY_LAMBDA, gap);
-        matched.add(bestRegionIdx);
-        if (region.consecutiveCount >= ANIMATION_FRAME_THRESHOLD) {
-          animationIndices.add(bi);
-        }
-      } else {
-        this.regions.push({
-          box,
-          consecutiveCount: 1,
-          lastSeen: pairIndex,
-          weight: 1
-        });
-      }
-    }
-    for (let ri = 0; ri < this.regions.length; ri++) {
-      if (!matched.has(ri)) {
-        const gap = pairIndex - this.regions[ri].lastSeen;
-        this.regions[ri].weight *= Math.pow(DECAY_LAMBDA, gap);
-      }
-    }
-    this.regions = this.regions.filter((r) => r.weight > 0.01);
-    return animationIndices;
-  }
-  getAnimationWeight(boxIndex, boxes) {
-    if (boxIndex >= boxes.length) return 0;
-    const box = boxes[boxIndex];
-    let maxWeight = 0;
-    for (const region of this.regions) {
-      if (region.consecutiveCount >= ANIMATION_FRAME_THRESHOLD) {
-        const iou = computeIoU(box, region.box);
-        if (iou > IOU_THRESHOLD) {
-          maxWeight = Math.max(maxWeight, region.weight);
-        }
-      }
-    }
-    return maxWeight;
-  }
-};
 async function computeAKAZEDiff(cvLib, frame1, frame2) {
   const cv = cvLib;
   const mat1 = new cv.Mat(frame1.height, frame1.width, cv.CV_8UC1);
@@ -476,13 +432,17 @@ async function analyzeBatch(cvLib, frames, scale, tracker, pairOffset) {
 }
 async function analyzeFrames(ctx) {
   const { frames } = ctx;
-  if (frames.length < 2) return [];
+  if (frames.length < 2) return { edges: [], animations: [] };
   logger.debug(
     `Analyzing ${frames.length} frames in batches of ${OPENCV_BATCH_SIZE}`
   );
   const cvLib = await ensureOpenCV();
   const edges = [];
-  const tracker = new IoUTracker();
+  const tracker = new IoUTracker(
+    ctx.options.fps,
+    ctx.options.iouThreshold,
+    ctx.options.animationThreshold
+  );
   const scale = ctx.options.scale;
   for (let i = 0; i < frames.length - 1; i += OPENCV_BATCH_SIZE) {
     const batchEnd = Math.min(i + OPENCV_BATCH_SIZE + 1, frames.length);
@@ -495,16 +455,120 @@ async function analyzeFrames(ctx) {
     );
     ctx.emitProgress(progress);
   }
-  logger.debug(`Computed ${edges.length} score edges`);
-  return edges;
+  const animations = tracker.flushAndGetAnimations();
+  logger.debug(
+    `Computed ${edges.length} score edges and ${animations.length} animations`
+  );
+  return { edges, animations };
 }
-
-// src/core/extractor.ts
-import { readdir } from "fs/promises";
-import { join as join2 } from "path";
-import { path as ffprobePath } from "@ffprobe-installer/ffprobe";
-import { execa } from "execa";
-import ffmpegPath from "ffmpeg-static";
+var OPENCV_INIT_TIMEOUT_MS, require2, cvReady, IoUTracker;
+var init_analyzer = __esm({
+  "src/core/analyzer.ts"() {
+    "use strict";
+    init_constants();
+    init_logger();
+    init_dbscan();
+    OPENCV_INIT_TIMEOUT_MS = 3e4;
+    require2 = createRequire(import.meta.url);
+    cvReady = null;
+    IoUTracker = class {
+      constructor(fps = DEFAULT_FPS, iouThreshold = IOU_THRESHOLD, animationThreshold = ANIMATION_FRAME_THRESHOLD) {
+        this.fps = fps;
+        this.iouThreshold = iouThreshold;
+        this.animationThreshold = animationThreshold;
+      }
+      regions = [];
+      extractedAnimations = [];
+      update(boxes, pairIndex) {
+        const animationIndices = /* @__PURE__ */ new Set();
+        const matched = /* @__PURE__ */ new Set();
+        for (let bi = 0; bi < boxes.length; bi++) {
+          const box = boxes[bi];
+          let bestIoU = 0;
+          let bestRegionIdx = -1;
+          for (let ri = 0; ri < this.regions.length; ri++) {
+            if (matched.has(ri)) continue;
+            const iou = computeIoU(box, this.regions[ri].box);
+            if (iou > bestIoU) {
+              bestIoU = iou;
+              bestRegionIdx = ri;
+            }
+          }
+          if (bestIoU > this.iouThreshold && bestRegionIdx !== -1) {
+            const region = this.regions[bestRegionIdx];
+            const gap = pairIndex - region.lastSeen;
+            region.box = box;
+            region.consecutiveCount++;
+            region.lastSeen = pairIndex;
+            region.weight *= Math.pow(DECAY_LAMBDA, gap);
+            matched.add(bestRegionIdx);
+            if (region.consecutiveCount >= this.animationThreshold) {
+              animationIndices.add(bi);
+            }
+          } else {
+            this.regions.push({
+              box,
+              consecutiveCount: 1,
+              firstSeen: pairIndex,
+              lastSeen: pairIndex,
+              weight: 1
+            });
+          }
+        }
+        for (let ri = 0; ri < this.regions.length; ri++) {
+          if (!matched.has(ri)) {
+            const gap = pairIndex - this.regions[ri].lastSeen;
+            this.regions[ri].weight *= Math.pow(DECAY_LAMBDA, gap);
+          }
+        }
+        for (let i = 0; i < this.regions.length; i++) {
+          const region = this.regions[i];
+          if (region.weight <= 0.01 && !matched.has(i)) {
+            this.collectAnimation(region);
+          }
+        }
+        this.regions = this.regions.filter(
+          (r, i) => r.weight > 0.01 || matched.has(i)
+        );
+        return animationIndices;
+      }
+      collectAnimation(region) {
+        if (region.consecutiveCount >= this.animationThreshold) {
+          const durationMs = region.consecutiveCount / this.fps * 1e3;
+          this.extractedAnimations.push({
+            type: "loading_spinner",
+            // 기본값으로 loading_spinner 사용
+            boundingBox: region.box,
+            startFrameId: region.firstSeen,
+            endFrameId: region.lastSeen,
+            durationMs
+          });
+        }
+      }
+      flushAndGetAnimations() {
+        for (const region of this.regions) {
+          this.collectAnimation(region);
+        }
+        this.regions = [];
+        return this.extractedAnimations;
+      }
+      getAnimationWeight(boxIndex, boxes) {
+        if (boxIndex >= boxes.length) return 0;
+        const box = boxes[boxIndex];
+        let maxWeight = 0;
+        for (const region of this.regions) {
+          if (region.consecutiveCount >= this.animationThreshold) {
+            const iou = computeIoU(box, region.box);
+            if (iou > this.iouThreshold) {
+              maxWeight = Math.max(maxWeight, region.weight);
+            }
+          }
+        }
+        return maxWeight;
+      }
+    };
+  }
+});
 
 // src/utils/paths.ts
 import { mkdir, stat } from "fs/promises";
@@ -539,11 +603,21 @@ function deriveOutputPath(inputPath) {
 function isSupportedFile(filePath, extensions) {
   return extensions.includes(extname(filePath).toLowerCase());
 }
+var init_paths = __esm({
+  "src/utils/paths.ts"() {
+    "use strict";
+  }
+});
 
 // src/core/extractor.ts
+import { readdir } from "fs/promises";
+import { join as join2 } from "path";
+import { path as ffprobePath } from "@ffprobe-installer/ffprobe";
+import { execa } from "execa";
+import ffmpegPath from "ffmpeg-static";
 async function extractFrames(ctx) {
   const framesDir = join2(ctx.workspacePath, "frames");
-  const { inputPath, fps, scale } = ctx.options;
+  const { inputPath, fps, maxFrames, scale } = ctx.options;
   if (!inputPath) {
     throw new Error("inputPath is required for frame extraction");
   }
@@ -560,41 +634,23 @@ async function extractFrames(ctx) {
   }
   logger.debug(`Extracting frames from: ${inputPath}`);
   await ensureDir(framesDir);
-  const isGif = isSupportedFile(inputPath, SUPPORTED_GIF_EXTENSIONS);
-  let frames;
-  if (isGif) {
-    logger.debug("GIF detected \u2014 using FPS extraction");
-    frames = await extractByFps(inputPath, framesDir, fps, scale);
-  } else {
-    frames = await extractIFrames(inputPath, framesDir, scale);
-    if (frames.length < MIN_IFRAME_COUNT) {
-      logger.debug(
-        `Insufficient I-frames (${frames.length}), falling back to FPS mode`
-      );
-      frames = await extractByFps(inputPath, framesDir, fps, scale);
-    }
+  let effectiveFps = fps;
+  const duration = await getVideoDuration(inputPath).catch(() => 0);
+  if (duration > 0) {
+    const fpsCap = maxFrames / duration;
+    effectiveFps = Math.min(fps, fpsCap);
+    effectiveFps = Math.max(0.5, effectiveFps);
+    logger.debug(
+      `Duration: ${duration.toFixed(1)}s, FPS: ${fps} \u2192 effective: ${effectiveFps.toFixed(2)} (maxFrames: ${maxFrames})`
+    );
   }
+  const frames = await extractByFps(inputPath, framesDir, effectiveFps, scale);
   ctx.emitProgress(100);
   logger.debug(`Extracted ${frames.length} frames`);
   return frames;
 }
-async function extractIFrames(inputPath, outputDir, scale) {
-  const outputPattern = join2(outputDir, "frame_%06d.jpg");
-  await execa(ffmpegPath, [
-    "-i",
-    inputPath,
-    "-vf",
-    `select='eq(pict_type,I)',scale=-1:${scale}`,
-    "-vsync",
-    "vfr",
-    "-q:v",
-    "2",
-    outputPattern
-  ]);
-  return buildFrameList(outputDir, inputPath);
-}
 async function extractByFps(inputPath, outputDir, fps, scale) {
-  const outputPattern = join2(outputDir, "frame_%06d.jpg");
+  const outputPattern = join2(outputDir, FRAME_FILENAME_PATTERN);
   await execa(ffmpegPath, [
     "-i",
     inputPath,
@@ -638,12 +694,17 @@ async function buildFrameList(framesDir, inputPath) {
     extractPath: join2(framesDir, file)
   }));
 }
-
-// src/core/input-resolver.ts
-import { join as join4 } from "path";
+var init_extractor = __esm({
+  "src/core/extractor.ts"() {
+    "use strict";
+    init_constants();
+    init_logger();
+    init_paths();
+  }
+});
 
 // src/core/workspace.ts
-import { rename, rm, writeFile } from "fs/promises";
+import { readdir as readdir2, rename, rm, stat as stat2, writeFile } from "fs/promises";
 import { join as join3 } from "path";
 import sharp2 from "sharp";
 async function createWorkspace(sessionId) {
@@ -657,13 +718,44 @@ async function finalizeOutput(ctx, selectedFrames) {
   const outputPath = ctx.options.outputPath;
   const quality = ctx.options.quality;
   const outputFiles = [];
+  const framesMetadata = [];
+  const totalFramesCount = ctx.frames.length;
+  const padding = Math.max(4, String(totalFramesCount).length);
   for (let i = 0; i < selectedFrames.length; i++) {
     const frame = selectedFrames[i];
-    const destName = `scene_${String(i + 1).padStart(3, "0")}.jpg`;
-    const destPath = join3(stagingDir, destName);
+    const fileName = `frame_${String(frame.id + 1).padStart(padding, "0")}.jpg`;
+    const destPath = join3(stagingDir, fileName);
     await sharp2(frame.extractPath).jpeg({ quality, mozjpeg: true }).toFile(destPath);
-    outputFiles.push(join3(outputPath, destName));
+    outputFiles.push(join3(outputPath, fileName));
+    framesMetadata.push({
+      step: i + 1,
+      fileName,
+      frameId: frame.id + 1,
+      timestampMs: Math.round(frame.timestamp * 1e3)
+    });
   }
+  const metadata = {
+    video: {
+      originalDurationMs: Math.round(
+        (ctx.frames.length > 0 ? ctx.frames[ctx.frames.length - 1].timestamp : 0) * 1e3
+      ),
+      fps: ctx.options.fps,
+      resolution: {
+        width: ctx.options.scale,
+        height: Math.round(ctx.options.scale * 9 / 16)
+      }
+    },
+    frames: framesMetadata,
+    animations: (ctx.animations || []).map((anim) => ({
+      ...anim,
+      startFrameId: anim.startFrameId + 1,
+      endFrameId: anim.endFrameId + 1,
+      durationMs: Math.round(anim.durationMs)
+    }))
+  };
+  const metadataPath = join3(stagingDir, ".metadata.json");
+  await writeFile(metadataPath, JSON.stringify(metadata, null, 2));
+  outputFiles.push(join3(outputPath, ".metadata.json"));
   await ensureDir(join3(outputPath, ".."));
   await rm(outputPath, { recursive: true, force: true });
   await rename(stagingDir, outputPath);
@@ -676,6 +768,21 @@ async function cleanupWorkspace(workspacePath) {
   } catch {
   }
 }
+async function cleanupStaleWorkspaces() {
+  const entries = await readdir2(TEMP_BASE_DIR);
+  const now = Date.now();
+  for (const entry of entries) {
+    if (!entry.startsWith(WORKSPACE_PREFIX)) continue;
+    const fullPath = join3(TEMP_BASE_DIR, entry);
+    try {
+      const info = await stat2(fullPath);
+      if (info.isDirectory() && now - info.mtimeMs > STALE_THRESHOLD_MS) {
+        await rm(fullPath, { recursive: true, force: true });
+      }
+    } catch {
+    }
+  }
+}
 async function writeInputBuffer(buffer, workspacePath) {
   const inputDir = join3(workspacePath, "input");
   await ensureDir(inputDir);
@@ -702,8 +809,18 @@ async function readFramesAsBuffers(frameNodes, quality) {
     )
   );
 }
+var STALE_THRESHOLD_MS;
+var init_workspace = __esm({
+  "src/core/workspace.ts"() {
+    "use strict";
+    init_constants();
+    init_paths();
+    STALE_THRESHOLD_MS = 60 * 60 * 1e3;
+  }
+});
 
 // src/core/input-resolver.ts
+import { join as join4 } from "path";
 function resolveOptions(options) {
   const mode = options.mode;
   const inputPath = mode === "file" ? resolveAbsolute(options.inputPath) : void 0;
@@ -723,8 +840,11 @@ function resolveOptions(options) {
     pruneMode,
     outputPath,
     fps: options.fps ?? DEFAULT_FPS,
+    maxFrames: options.maxFrames ?? DEFAULT_MAX_FRAMES,
     scale: options.scale ?? DEFAULT_SCALE,
     quality: options.quality ?? DEFAULT_QUALITY,
+    iouThreshold: options.iouThreshold ?? IOU_THRESHOLD,
+    animationThreshold: options.animationThreshold ?? ANIMATION_FRAME_THRESHOLD,
     debug: options.debug ?? false
   };
 }
@@ -748,50 +868,64 @@ async function resolveInput(options, workspacePath) {
   }
   throw new Error(`Unsupported input mode: ${options.mode}`);
 }
+var init_input_resolver = __esm({
+  "src/core/input-resolver.ts"() {
+    "use strict";
+    init_constants();
+    init_paths();
+    init_workspace();
+  }
+});
 
 // src/utils/min-heap.ts
-var MinHeap = class {
-  h = [];
-  get size() {
-    return this.h.length;
-  }
-  push(entry) {
-    this.h.push(entry);
-    this.siftUp(this.h.length - 1);
-  }
-  pop() {
-    const n = this.h.length;
-    if (n === 0) return void 0;
-    const top = this.h[0];
-    const last = this.h.pop();
-    if (n > 1) {
-      this.h[0] = last;
-      this.siftDown(0);
-    }
-    return top;
-  }
-  siftUp(i) {
-    while (i > 0) {
-      const p = i - 1 >> 1;
-      if (this.h[p].score <= this.h[i].score) break;
-      [this.h[p], this.h[i]] = [this.h[i], this.h[p]];
-      i = p;
-    }
-  }
-  siftDown(i) {
-    const n = this.h.length;
-    for (; ; ) {
-      let m = i;
-      const l = 2 * i + 1;
-      const r = 2 * i + 2;
-      if (l < n && this.h[l].score < this.h[m].score) m = l;
-      if (r < n && this.h[r].score < this.h[m].score) m = r;
-      if (m === i) break;
-      [this.h[m], this.h[i]] = [this.h[i], this.h[m]];
-      i = m;
-    }
+var MinHeap;
+var init_min_heap = __esm({
+  "src/utils/min-heap.ts"() {
+    "use strict";
+    MinHeap = class {
+      h = [];
+      get size() {
+        return this.h.length;
+      }
+      push(entry) {
+        this.h.push(entry);
+        this.siftUp(this.h.length - 1);
+      }
+      pop() {
+        const n = this.h.length;
+        if (n === 0) return void 0;
+        const top = this.h[0];
+        const last = this.h.pop();
+        if (n > 1) {
+          this.h[0] = last;
+          this.siftDown(0);
+        }
+        return top;
+      }
+      siftUp(i) {
+        while (i > 0) {
+          const p = i - 1 >> 1;
+          if (this.h[p].score <= this.h[i].score) break;
+          [this.h[p], this.h[i]] = [this.h[i], this.h[p]];
+          i = p;
+        }
+      }
+      siftDown(i) {
+        const n = this.h.length;
+        for (; ; ) {
+          let m = i;
+          const l = 2 * i + 1;
+          const r = 2 * i + 2;
+          if (l < n && this.h[l].score < this.h[m].score) m = l;
+          if (r < n && this.h[r].score < this.h[m].score) m = r;
+          if (m === i) break;
+          [this.h[m], this.h[i]] = [this.h[i], this.h[m]];
+          i = m;
+        }
+      }
+    };
   }
-};
+});
 
 // src/core/pruner.ts
 function pruneTo(graph, frames, targetCount) {
@@ -953,8 +1087,20 @@ function pruneByThresholdWithCap(graph, frames, threshold, maxCount) {
   }
   return pruneTo(syntheticEdges, survivingFrames, maxCount);
 }
+var init_pruner = __esm({
+  "src/core/pruner.ts"() {
+    "use strict";
+    init_constants();
+    init_min_heap();
+  }
+});
 
 // src/core/orchestrator.ts
+var orchestrator_exports = {};
+__export(orchestrator_exports, {
+  runPipeline: () => runPipeline
+});
+import { randomUUID } from "crypto";
 async function runPipeline(options) {
   const startTime = Date.now();
   const sessionId = randomUUID();
@@ -995,7 +1141,9 @@ async function runPipeline(options) {
     }
     ctx.emitProgress(100);
     ctx.status = "ANALYZING";
-    ctx.graph = await analyzeFrames(ctx);
+    const { edges, animations } = await analyzeFrames(ctx);
+    ctx.graph = edges;
+    ctx.animations = animations;
     ctx.status = "PRUNING";
     const survivingIds = pruneByThresholdWithCap(
       ctx.graph,
@@ -1028,6 +1176,15 @@ async function runPipeline(options) {
       prunedFramesCount: prunedFrames.length,
       outputFiles,
       outputBuffers,
+      animations: ctx.animations,
+      video: {
+        originalDurationMs: ctx.frames.length / ctx.options.fps * 1e3,
+        fps: ctx.options.fps,
+        resolution: {
+          width: ctx.options.scale,
+          height: Math.round(ctx.options.scale * 9 / 16)
+        }
+      },
       executionTimeMs: Date.now() - startTime
     };
   } catch (error) {
@@ -1043,58 +1200,339 @@ async function runPipeline(options) {
     }
   }
 }
+var init_orchestrator = __esm({
+  "src/core/orchestrator.ts"() {
+    "use strict";
+    init_logger();
+    init_analyzer();
+    init_extractor();
+    init_input_resolver();
+    init_pruner();
+    init_workspace();
+  }
+});
 
 // src/cli.ts
+import { createRequire as createRequire2 } from "module";
+import { Command } from "commander";
+import { render } from "ink";
+import React2 from "react";
+
+// src/commands/Sieve.tsx
+import { Box as Box2, Text as Text3, useApp } from "ink";
+import { useEffect, useState } from "react";
+
+// src/components/PhaseStep.tsx
+import { Box, Text as Text2 } from "ink";
+import Spinner from "ink-spinner";
+
+// src/components/ProgressBar.tsx
+import { Text } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+var ProgressBar = ({
+  percent,
+  width = 30
+}) => {
+  const clamped = Math.max(0, Math.min(100, percent));
+  const filled = Math.round(width * (clamped / 100));
+  const empty = width - filled;
+  return /* @__PURE__ */ jsxs(Text, { children: [
+    /* @__PURE__ */ jsx(Text, { color: "green", children: "\u2588".repeat(filled) }),
+    /* @__PURE__ */ jsx(Text, { color: "gray", children: "\u2591".repeat(empty) }),
+    /* @__PURE__ */ jsxs(Text, { children: [
+      " ",
+      clamped,
+      "%"
+    ] })
+  ] });
+};
+
+// src/components/PhaseStep.tsx
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var PhaseStep = ({ phase }) => {
+  const icon = (() => {
+    switch (phase.status) {
+      case "done":
+        return /* @__PURE__ */ jsx2(Text2, { color: "green", children: "\u2713" });
+      case "running":
+        return /* @__PURE__ */ jsx2(Text2, { color: "yellow", children: /* @__PURE__ */ jsx2(Spinner, { type: "dots" }) });
+      case "failed":
+        return /* @__PURE__ */ jsx2(Text2, { color: "red", children: "\u2717" });
+      default:
+        return /* @__PURE__ */ jsx2(Text2, { color: "gray", children: "\u25CB" });
+    }
+  })();
+  const duration = phase.status === "done" && phase.durationMs !== void 0 ? `Done (${Math.round(phase.durationMs / 1e3)}s)` : "";
+  return /* @__PURE__ */ jsxs2(Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs2(Text2, { children: [
+      "  ",
+      icon,
+      " ",
+      phase.label,
+      duration ? /* @__PURE__ */ jsxs2(Text2, { color: "gray", children: [
+        "  ",
+        duration
+      ] }) : null
+    ] }),
+    phase.status === "running" && phase.hasProgress && phase.percent > 0 && /* @__PURE__ */ jsxs2(Text2, { children: [
+      "      ",
+      /* @__PURE__ */ jsx2(ProgressBar, { percent: phase.percent })
+    ] })
+  ] });
+};
+
+// src/core/run-in-worker.ts
+import { dirname, join as join5 } from "path";
+import { fileURLToPath } from "url";
+import { Worker } from "worker_threads";
+async function runPipelineInWorker(options, onProgress) {
+  const currentFile = fileURLToPath(import.meta.url);
+  if (!currentFile.endsWith(".mjs")) {
+    const { runPipeline: runPipeline2 } = await Promise.resolve().then(() => (init_orchestrator(), orchestrator_exports));
+    return runPipeline2({ ...options, onProgress });
+  }
+  const workerPath = join5(dirname(currentFile), "pipeline-worker.mjs");
+  return new Promise((resolve2, reject) => {
+    const worker = new Worker(workerPath, { workerData: options });
+    worker.on(
+      "message",
+      (msg) => {
+        if (msg.type === "progress" && msg.phase && msg.percent !== void 0) {
+          onProgress(msg.phase, msg.percent);
+        } else if (msg.type === "result") {
+          resolve2(msg.result);
+          worker.terminate();
+        } else if (msg.type === "error") {
+          reject(new Error(msg.message));
+          worker.terminate();
+        }
+      }
+    );
+    worker.on("error", reject);
+    worker.on("exit", (code) => {
+      if (code !== 0 && code !== 1) {
+        reject(new Error(`Worker exited with code ${code}`));
+      }
+    });
+  });
+}
+
+// src/commands/Sieve.tsx
+init_workspace();
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+var PHASE_DEFS = [
+  { key: "INIT", label: "Initializing workspace", hasProgress: false },
+  { key: "EXTRACTING", label: "Extracting frames", hasProgress: false },
+  { key: "ANALYZING", label: "Analyzing frame similarity", hasProgress: true },
+  { key: "PRUNING", label: "Pruning similar frames", hasProgress: false },
+  { key: "FINALIZING", label: "Finalizing output", hasProgress: false }
+];
+function createInitialPhases() {
+  return PHASE_DEFS.map((def) => ({
+    label: def.label,
+    status: "pending",
+    hasProgress: def.hasProgress,
+    percent: 0
+  }));
+}
+function phaseKeyToIndex(phase) {
+  return PHASE_DEFS.findIndex((d) => d.key === phase);
+}
+var SieveView = (props) => {
+  const { exit } = useApp();
+  const [phases, setPhases] = useState(createInitialPhases);
+  const [result, setResult] = useState(null);
+  const [error, setError] = useState(null);
+  useEffect(() => {
+    const phaseStartTimes = PHASE_DEFS.map(() => 0);
+    let currentPhaseKey = "";
+    (async () => {
+      try {
+        await cleanupStaleWorkspaces().catch(() => {
+        });
+        phaseStartTimes[0] = Date.now();
+        setPhases((prev) => {
+          const next = [...prev];
+          next[0] = { ...next[0], status: "running" };
+          return next;
+        });
+        const res = await runPipelineInWorker(
+          {
+            mode: "file",
+            inputPath: props.input,
+            ...props.threshold !== void 0 ? { threshold: props.threshold } : {},
+            ...props.count !== void 0 ? { count: props.count } : {},
+            outputPath: props.output,
+            fps: props.fps,
+            maxFrames: props.maxFrames,
+            scale: props.scale,
+            quality: props.quality,
+            iouThreshold: props.iouThreshold,
+            animationThreshold: props.animationThreshold,
+            debug: props.debug
+          },
+          (phase, percent) => {
+            const phaseIdx = phaseKeyToIndex(phase);
+            if (phaseIdx < 0) return;
+            if (phase !== currentPhaseKey) {
+              const now2 = Date.now();
+              currentPhaseKey = phase;
+              phaseStartTimes[phaseIdx] = now2;
+              setPhases((prev) => {
+                const next = [...prev];
+                for (let i = 0; i < next.length; i++) {
+                  if (i < phaseIdx) {
+                    if (next[i].status !== "done") {
+                      next[i] = {
+                        ...next[i],
+                        status: "done",
+                        percent: 100,
+                        durationMs: phaseStartTimes[i] ? now2 - phaseStartTimes[i] : 0
+                      };
+                    }
+                  } else if (i === phaseIdx) {
+                    next[i] = { ...next[i], status: "running", percent: 0 };
+                  }
+                }
+                return next;
+              });
+            }
+            setPhases((prev) => {
+              const next = [...prev];
+              if (next[phaseIdx].status === "running") {
+                next[phaseIdx] = {
+                  ...next[phaseIdx],
+                  percent: Math.round(percent)
+                };
+              }
+              return next;
+            });
+          }
+        );
+        const now = Date.now();
+        setPhases(
+          (prev) => prev.map((p, i) => {
+            if (p.status !== "done") {
+              return {
+                ...p,
+                status: "done",
+                percent: 100,
+                durationMs: phaseStartTimes[i] ? now - phaseStartTimes[i] : 0
+              };
+            }
+            return p;
+          })
+        );
+        setResult(res);
+        setTimeout(() => exit(), 100);
+      } catch (err) {
+        const now = Date.now();
+        setPhases((prev) => {
+          const next = [...prev];
+          for (let i = 0; i < next.length; i++) {
+            if (next[i].status === "running") {
+              next[i] = {
+                ...next[i],
+                status: "failed",
+                durationMs: phaseStartTimes[i] ? now - phaseStartTimes[i] : 0
+              };
+            }
+          }
+          return next;
+        });
+        setError(err instanceof Error ? err.message : String(err));
+        setTimeout(() => exit(), 100);
+      }
+    })();
+  }, []);
+  return /* @__PURE__ */ jsxs3(Box2, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs3(Text3, { bold: true, children: [
+      "\u25B8 scene-sieve",
+      " \u2014 ",
+      props.input.split("/").pop()
+    ] }),
+    /* @__PURE__ */ jsx3(Text3, { children: " " }),
+    phases.map((phase, i) => /* @__PURE__ */ jsx3(PhaseStep, { phase }, i)),
+    error && /* @__PURE__ */ jsx3(Box2, { marginTop: 1, children: /* @__PURE__ */ jsxs3(Text3, { color: "red", children: [
+      "\u2717 Failed \u2014 ",
+      error
+    ] }) }),
+    result && /* @__PURE__ */ jsxs3(Box2, { flexDirection: "column", marginTop: 1, children: [
+      /* @__PURE__ */ jsx3(Text3, { color: "gray", children: "  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500" }),
+      /* @__PURE__ */ jsxs3(Text3, { color: "green", bold: true, children: [
+        "\u2713 Done",
+        " \u2014 ",
+        result.originalFramesCount,
+        " frames \u2192",
+        " ",
+        result.prunedFramesCount,
+        " scenes (",
+        (result.executionTimeMs / 1e3).toFixed(1),
+        "s)"
+      ] }),
+      result.animations && result.animations.length > 0 && /* @__PURE__ */ jsxs3(Text3, { color: "blue", children: [
+        "\u2139 Found",
+        " ",
+        result.animations.length,
+        " animations (recorded in .metadata.json)"
+      ] }),
+      props.debug && result.outputFiles.length > 0 && /* @__PURE__ */ jsxs3(Box2, { flexDirection: "column", marginTop: 1, children: [
+        /* @__PURE__ */ jsxs3(Text3, { color: "gray", children: [
+          "Output: ",
+          result.outputFiles[0]?.replace(/\/[^/]+$/, "/")
+        ] }),
+        result.outputFiles.map((f, i) => /* @__PURE__ */ jsxs3(Text3, { color: "gray", children: [
+          "  - ",
+          f
+        ] }, i))
+      ] })
+    ] })
+  ] });
+};
+
+// src/cli.ts
+init_constants();
 var require3 = createRequire2(import.meta.url);
 var { version } = require3("../package.json");
 var program = new Command();
 program.name("scene-sieve").description("Extract key frames from video and GIF files").version(version).argument("<input>", "Input video or GIF file path").option("-n, --count <number>", "Max number of frames to keep (default: 20)").option(
   "-t, --threshold <number>",
   "Normalized threshold 0~1 (default: 0.5; keeps frames above ratio of max change)"
-).option("-o, --output <path>", "Output directory path").option("--fps <number>", "Fallback FPS for frame extraction", "5").option("-s, --scale <number>", "Scale size for vision analysis", "720").option("-q, --quality <number>", "JPEG output quality 1-100", "80").option("--debug", "Enable debug mode (preserve temp workspace)").action(async (input, opts) => {
-  const { default: ora } = await import("ora");
-  const { default: cliProgress } = await import("cli-progress");
-  const spinner = ora("Initializing...").start();
-  try {
-    spinner.stop();
-    const bar = new cliProgress.SingleBar({
-      format: "{phase} |{bar}| {percentage}%",
-      barCompleteChar: "\u2588",
-      barIncompleteChar: "\u2591",
-      hideCursor: true
-    });
-    bar.start(100, 0, { phase: "EXTRACTING" });
-    const result = await runPipeline({
-      mode: "file",
-      inputPath: input,
+).option("-o, --output <path>", "Output directory path").option("--fps <number>", "Max FPS for frame extraction", String(DEFAULT_FPS)).option(
+  "-mf, --max-frames <number>",
+  "Max frames to extract (auto-reduces FPS for long videos)",
+  String(DEFAULT_MAX_FRAMES)
+).option(
+  "-s, --scale <number>",
+  "Scale size for vision analysis",
+  String(DEFAULT_SCALE)
+).option(
+  "-q, --quality <number>",
+  "JPEG output quality 1-100",
+  String(DEFAULT_QUALITY)
+).option(
+  "-it, --iou-threshold <number>",
+  `IoU threshold for animation tracking (0-1) (default: ${IOU_THRESHOLD})`
+).option(
+  "-at, --anim-threshold <number>",
+  `Min consecutive frames for animation (default: ${ANIMATION_FRAME_THRESHOLD})`
+).option("--debug", "Enable debug mode (preserve temp workspace)").action(async (input, opts) => {
+  const { waitUntilExit } = render(
+    React2.createElement(SieveView, {
+      input,
       ...opts.threshold !== void 0 ? { threshold: parseFloat(opts.threshold) } : {},
       ...opts.count !== void 0 ? { count: parseInt(opts.count, 10) } : {},
-      outputPath: opts.output,
+      output: opts.output,
       fps: parseInt(opts.fps, 10),
+      maxFrames: parseInt(opts.maxFrames, 10),
       scale: parseInt(opts.scale, 10),
       quality: parseInt(opts.quality, 10),
-      debug: opts.debug ?? false,
-      onProgress: (phase, percent) => {
-        bar.update(Math.round(percent), { phase });
-      }
-    });
-    bar.stop();
-    console.log(
-      `
-Done! ${result.originalFramesCount} frames -> ${result.prunedFramesCount} scenes (${result.executionTimeMs}ms)`
-    );
-    if (opts.debug) {
-      console.log(
-        `Output: ${result.outputFiles[0]?.replace(/\/[^/]+$/, "/")}`
-      );
-      result.outputFiles.forEach((f) => console.log(`  - ${f}`));
-    }
-  } catch (error) {
-    spinner.fail(
-      `Failed: ${error instanceof Error ? error.message : String(error)}`
-    );
-    process.exit(1);
-  }
+      iouThreshold: opts.iouThreshold !== void 0 ? parseFloat(opts.iouThreshold) : void 0,
+      animationThreshold: opts.animThreshold !== void 0 ? parseInt(opts.animThreshold, 10) : void 0,
+      debug: opts.debug ?? false
+    })
+  );
+  await waitUntilExit();
 });
 program.parseAsync(process.argv).catch((error) => {
   console.error("Fatal error:", error.message);