@lumy-pack/scene-sieve 0.0.3 → 0.0.5

package/dist/cli.mjs

@@ -1,86 +1,94 @@
 #!/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.75;
-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, 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";
+    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 +163,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 () => {
@@ -182,7 +198,7 @@ async function ensureOpenCV() {
 async function preprocessFrame(framePath, scale) {
   const { data, info } = await sharp(framePath).resize({ width: scale, withoutEnlargement: true }).grayscale().blur(1).raw().toBuffer({ resolveWithObject: true });
   return {
-    data: new Uint8Array(data.buffer),
+    data: new Uint8Array(data.buffer, data.byteOffset, data.byteLength),
     width: info.width,
     height: info.height
   };
@@ -201,78 +217,12 @@ 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 mat1 = cvLib.matFromImageData({
-    data: frame1.data,
-    width: frame1.width,
-    height: frame1.height
-  });
-  const mat2 = cvLib.matFromImageData({
-    data: frame2.data,
-    width: frame2.width,
-    height: frame2.height
-  });
+  const cv = cvLib;
+  const mat1 = new cv.Mat(frame1.height, frame1.width, cv.CV_8UC1);
+  mat1.data.set(frame1.data);
+  const mat2 = new cv.Mat(frame2.height, frame2.width, cv.CV_8UC1);
+  mat2.data.set(frame2.data);
   const kp1 = new cvLib.KeyPointVector();
   const kp2 = new cvLib.KeyPointVector();
   const desc1 = new cvLib.Mat();
@@ -503,13 +453,79 @@ async function analyzeFrames(ctx) {
   logger.debug(`Computed ${edges.length} score edges`);
   return edges;
 }
-
-// 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 {
+      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;
+      }
+    };
+  }
+});
 
 // src/utils/paths.ts
 import { mkdir, stat } from "fs/promises";
@@ -544,11 +560,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");
   }
@@ -565,39 +591,21 @@ 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");
   await execa(ffmpegPath, [
@@ -643,12 +651,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) {
@@ -670,6 +683,7 @@ async function finalizeOutput(ctx, selectedFrames) {
     outputFiles.push(join3(outputPath, destName));
   }
   await ensureDir(join3(outputPath, ".."));
+  await rm(outputPath, { recursive: true, force: true });
   await rename(stagingDir, outputPath);
   return outputFiles;
 }
@@ -680,6 +694,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);
@@ -706,8 +735,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;
@@ -727,6 +766,7 @@ 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,
     debug: options.debug ?? false
@@ -752,50 +792,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) {
@@ -957,8 +1011,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();
@@ -1047,6 +1113,286 @@ 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,
+            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)"
+      ] }),
+      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
 var require3 = createRequire2(import.meta.url);
@@ -1055,50 +1401,25 @@ 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", "5").option(
+  "--max-frames <number>",
+  "Max frames to extract (auto-reduces FPS for long videos)",
+  "300"
+).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 { 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);
-  }
+      debug: opts.debug ?? false
+    })
+  );
+  await waitUntilExit();
 });
 program.parseAsync(process.argv).catch((error) => {
   console.error("Fatal error:", error.message);