vidistill 0.2.0 → 0.2.2

package/dist/index.js

@@ -1,15 +1,18 @@
 #!/usr/bin/env node
+var __glob = (map) => (path) => {
+  var fn = map[path];
+  if (fn) return fn();
+  throw new Error("Module not found in bundle: " + path);
+};
 
 // src/cli/index.ts
+import { createRequire as createRequire2 } from "module";
 import { defineCommand, runMain } from "citty";
-import { log as log10 } from "@clack/prompts";
-import pc5 from "picocolors";
-import { basename as basename3, extname as extname2, resolve } from "path";
 
 // src/cli/ui.ts
 import figlet from "figlet";
 import pc from "picocolors";
-import { intro, log } from "@clack/prompts";
+import { intro, note } from "@clack/prompts";
 function showLogo() {
   const ascii = figlet.textSync("VIDISTILL", { font: "Big" });
   console.log(pc.cyan(ascii));
@@ -17,17 +20,22 @@ function showLogo() {
 function showIntro() {
   intro(pc.dim("video intelligence distiller"));
 }
-function showConfig(config) {
+function showConfigBox(config) {
   const lines = [
-    `  input   ${pc.cyan(config.input)}`,
-    `  context ${config.context ? pc.white(config.context) : pc.dim("(none)")}`,
-    `  output  ${pc.white(config.output)}`
+    `Video:   ${config.input}`,
+    `Context: ${config.context ?? "(none)"}`,
+    `Output:  ${config.output}`
   ];
-  log.message(lines.join("\n"), { symbol: pc.green("\xBB") });
+  note(lines.join("\n"), "Configuration");
 }
 
+// src/commands/distill.ts
+import { log as log8, cancel as cancel2 } from "@clack/prompts";
+import pc4 from "picocolors";
+import { basename as basename3, extname as extname2, resolve } from "path";
+
 // src/cli/prompts.ts
-import { text, password, confirm, isCancel, cancel } from "@clack/prompts";
+import { text, password, confirm, select, isCancel, cancel } from "@clack/prompts";
 function handleCancel(value) {
   if (isCancel(value)) {
     cancel("Operation cancelled.");
@@ -39,7 +47,7 @@ async function promptVideoSource() {
     message: "YouTube URL or local file path",
     placeholder: "https://youtube.com/watch?v=...",
     validate(input) {
-      if (input.trim().length === 0) {
+      if (!input || input.trim().length === 0) {
         return "A video source is required.";
       }
     }
@@ -60,7 +68,7 @@ async function promptApiKey() {
   const value = await password({
     message: "Gemini API key",
     validate(input) {
-      if (input.trim().length === 0) {
+      if (!input || input.trim().length === 0) {
         return "An API key is required.";
       }
     }
@@ -76,12 +84,25 @@ async function promptSaveKey() {
   handleCancel(value);
   return value;
 }
+async function promptConfirmation() {
+  const value = await select({
+    message: "Ready to process?",
+    options: [
+      { value: "start", label: "Start processing" },
+      { value: "edit-video", label: "Edit video source" },
+      { value: "edit-context", label: "Edit context" },
+      { value: "cancel", label: "Cancel" }
+    ]
+  });
+  handleCancel(value);
+  return value;
+}
 
 // src/cli/config.ts
 import { promises as fs } from "fs";
 import { join } from "path";
 import os from "os";
-import { log as log2 } from "@clack/prompts";
+import { log } from "@clack/prompts";
 import pc2 from "picocolors";
 
 // src/gemini/client.ts
@@ -187,12 +208,12 @@ async function saveConfig(config) {
 async function resolveApiKey() {
   const envKey = process.env["GEMINI_API_KEY"];
   if (envKey && envKey.trim().length > 0) {
-    log2.info(pc2.dim("(using GEMINI_API_KEY from environment)"));
+    log.info(pc2.dim("(using GEMINI_API_KEY from environment)"));
     return envKey.trim();
   }
   const config = await loadConfig();
   if (config?.apiKey && config.apiKey.trim().length > 0) {
-    log2.info(pc2.dim("(using API key from ~/.vidistill/config.json)"));
+    log.info(pc2.dim("(using API key from ~/.vidistill/config.json)"));
     return config.apiKey.trim();
   }
   for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
@@ -200,9 +221,9 @@ async function resolveApiKey() {
     const client = new GeminiClient(key);
     const valid = await client.validateKey();
     if (!valid) {
-      log2.error(pc2.red("Invalid API key"));
+      log.error(pc2.red("Invalid API key"));
       if (attempt === MAX_ATTEMPTS) {
-        log2.error(pc2.red("Maximum attempts reached. Exiting."));
+        log.error(pc2.red("Maximum attempts reached. Exiting."));
         process.exit(1);
       }
       continue;
@@ -218,64 +239,50 @@ async function resolveApiKey() {
 }
 
 // src/cli/progress.ts
-import { spinner, log as log3 } from "@clack/prompts";
-import pc3 from "picocolors";
+import { spinner, progress } from "@clack/prompts";
+var PHASE_LABELS = {
+  pass0: "Understanding your video...",
+  pass1: "Extracting transcript...",
+  pass2: "Analyzing visuals...",
+  pass3a: "Reconstructing code...",
+  pass3b: "Identifying participants...",
+  pass3c: "Reading chat messages...",
+  pass3d: "Detecting insights...",
+  synthesis: "Synthesizing notes...",
+  output: "Writing output files..."
+};
 function createProgressDisplay() {
   const s = spinner();
-  s.start("Starting pipeline...");
+  s.start(PHASE_LABELS.pass0);
+  let progressBar = null;
+  let seenTotalSteps = false;
   function update(status) {
-    const segNum = status.segment + 1;
-    const total = status.totalSegments;
+    const label = PHASE_LABELS[status.phase] ?? status.phase;
     if (status.phase === "pass0") {
-      s.message("Analyzing video...");
-    } else if (status.phase === "pass1") {
-      s.message(`Pass 1: Transcript (${segNum}/${total} segments)`);
-    } else if (status.phase === "pass2") {
-      s.message(`Pass 2: Visual extraction (${segNum}/${total} segments)`);
-    } else if (status.phase === "pass3a") {
-      if (total > 1) {
-        s.message(`Reconstructing code (run ${segNum}/${total})...`);
-      } else {
-        s.message("Reconstructing code...");
-      }
-    } else if (status.phase === "pass3b") {
-      s.message("People extraction...");
-    } else if (status.phase === "pass3c") {
-      s.message(`Chat extraction (${segNum}/${total} segments)`);
-    } else if (status.phase === "pass3d") {
-      s.message(`Implicit signals (${segNum}/${total} segments)`);
-    } else if (status.phase === "synthesis") {
-      s.message("Synthesizing results...");
-    } else if (status.phase === "output") {
-      s.message("Generating output files...");
-    } else {
-      s.message(`${status.phase} (${segNum}/${total} segments)`);
+      s.message(label);
+      return;
     }
-  }
-  function onWait(delayMs) {
-    const secs = Math.ceil(delayMs / 1e3);
-    s.message(`Waiting for rate limit... (${secs}s)`);
-  }
-  function complete(result, elapsedMs) {
-    const elapsedSecs = Math.round(elapsedMs / 1e3);
-    const mins = Math.floor(elapsedSecs / 60);
-    const secs = elapsedSecs % 60;
-    const elapsed = mins > 0 ? `${mins}m ${secs}s` : `${secs}s`;
-    const errorCount = result.errors.length;
-    if (errorCount > 0) {
-      s.stop(pc3.yellow("Pipeline complete (with errors)"));
-    } else {
-      s.stop(pc3.green("Pipeline complete"));
+    if (!seenTotalSteps && status.totalSteps != null) {
+      seenTotalSteps = true;
+      s.stop("");
+      progressBar = progress({ max: status.totalSteps });
     }
-    log3.info(`Segments processed: ${pc3.cyan(String(result.segments.length))}`);
-    log3.info(`Passes run: ${pc3.cyan(result.passesRun.join(", "))}`);
-    log3.info(`Time elapsed: ${pc3.cyan(elapsed)}`);
-    if (errorCount > 0) {
-      log3.warn(`Errors: ${pc3.yellow(String(errorCount))}`);
+    if (progressBar != null) {
+      if (status.status === "done" && status.currentStep != null) {
+        progressBar.advance(1, label);
+      }
     } else {
-      log3.success("All segments completed successfully");
+      if (status.status === "done" && status.currentStep != null && status.totalSteps != null) {
+        s.message(`${label} (${status.currentStep}/${status.totalSteps})`);
+      } else {
+        s.message(label);
+      }
     }
   }
+  function onWait(_delayMs) {
+  }
+  function complete(_result, _elapsedMs) {
+  }
   return { update, onWait, complete };
 }
 
@@ -332,8 +339,8 @@ import { tmpdir } from "os";
 import { join as join2 } from "path";
 import { unlink } from "fs/promises";
 import { YtDlp } from "ytdlp-nodejs";
-import { log as log4 } from "@clack/prompts";
-import pc4 from "picocolors";
+import { log as log2 } from "@clack/prompts";
+import pc3 from "picocolors";
 
 // src/gemini/models.ts
 var MODELS = {
@@ -377,7 +384,7 @@ async function handleYouTube(url, client) {
     });
     return { fileUri: url, mimeType: "video/mp4", source: "direct" };
   } catch (err) {
-    log4.warn(pc4.dim("Direct Gemini probe failed. Falling back to yt-dlp."));
+    log2.warn(pc3.dim("Direct Gemini probe failed. Falling back to yt-dlp."));
   }
   const tempPath2 = await downloadWithYtDlp(url);
   try {
@@ -437,7 +444,7 @@ import { existsSync as existsSync2, statSync, openSync, readSync, closeSync, unl
 import * as childProc from "child_process";
 import { tmpdir as tmpdir2 } from "os";
 import { join as join3, extname, basename } from "path";
-import { log as log5 } from "@clack/prompts";
+import { log as log3 } from "@clack/prompts";
 var GB = 1024 * 1024 * 1024;
 var SIZE_3GB = 3 * GB;
 var SIZE_2GB = 2 * GB;
@@ -533,7 +540,7 @@ function convertMkvToMp4(inputPath) {
 }
 function compressTo720p(inputPath) {
   const output = tempPath(".mp4");
-  log5.info("Compressing video to 720p...");
+  log3.info("Compressing video to 720p...");
   try {
     childProc.execFileSync(
       "ffmpeg",
@@ -596,7 +603,7 @@ async function handleLocalFile(filePath, client) {
 
 // src/input/duration.ts
 import { createRequire } from "module";
-import { log as log6 } from "@clack/prompts";
+import { log as log4 } from "@clack/prompts";
 var _require = createRequire(import.meta.url);
 var ffmpeg = _require("fluent-ffmpeg");
 var BYTES_PER_SECOND = 5e5;
@@ -625,7 +632,7 @@ async function detectDuration(source) {
       const message = err instanceof Error ? err.message : String(err);
       const isNotFound = /ENOENT|not found|no such file|spawn.*ffprobe|Cannot find/i.test(message);
       if (isNotFound) {
-        log6.warn(
+        log4.warn(
           "ffprobe not found \u2014 video duration will be estimated. Install: brew install ffmpeg"
         );
       }
@@ -649,7 +656,7 @@ async function detectDuration(source) {
     bytes = source.fileSize;
   }
   if (bytes !== void 0 && bytes > 0) {
-    log6.warn(
+    log4.warn(
       "Duration estimated from file size \u2014 segmentation may be inaccurate"
     );
     return Math.max(1, Math.round(bytes / BYTES_PER_SECOND));
@@ -658,7 +665,7 @@ async function detectDuration(source) {
 }
 
 // src/core/pipeline.ts
-import { log as log8 } from "@clack/prompts";
+import { log as log6 } from "@clack/prompts";
 
 // src/constants/prompts.ts
 var SYSTEM_INSTRUCTION_PASS_1 = `
@@ -1896,7 +1903,7 @@ async function runSynthesis(params) {
 }
 
 // src/core/strategy.ts
-var BASE_PASSES = ["transcript", "visual", "synthesis"];
+var BASE_PASSES = ["transcript", "visual"];
 function determineStrategy(profile) {
   const passes = new Set(BASE_PASSES);
   const { type, visualContent, audioContent, complexity, recommendations } = profile;
@@ -1936,6 +1943,7 @@ function determineStrategy(profile) {
   }
   const resolution = recommendations.resolution ?? "medium";
   const segmentMinutes = complexity === "complex" && recommendations.segmentMinutes > 8 ? 8 : recommendations.segmentMinutes;
+  passes.add("synthesis");
   return {
     passes: Array.from(passes),
     resolution,
@@ -1991,7 +1999,7 @@ function createSegmentPlan(durationSeconds, options) {
 }
 
 // src/core/consensus.ts
-import { log as log7 } from "@clack/prompts";
+import { log as log5 } from "@clack/prompts";
 function tokenize(content) {
   const tokens = content.match(/[\p{L}\p{N}_]+/gu) ?? [];
   return new Set(tokens);
@@ -2069,7 +2077,7 @@ async function runCodeConsensus(params) {
       successfulRuns.push(result);
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e);
-      log7.warn(`consensus run ${i + 1}/${runs} failed: ${msg}`);
+      log5.warn(`consensus run ${i + 1}/${runs} failed: ${msg}`);
     }
     onProgress?.(i + 1, runs);
   }
@@ -2293,7 +2301,7 @@ async function runPipeline(config) {
     "pass0"
   );
   if (pass0Attempt.error !== null) {
-    log8.warn(pass0Attempt.error);
+    log6.warn(pass0Attempt.error);
     errors.push(pass0Attempt.error);
     videoProfile = DEFAULT_PROFILE;
   } else {
@@ -2301,8 +2309,6 @@ async function runPipeline(config) {
   }
   strategy = determineStrategy(videoProfile);
   onProgress?.({ phase: "pass0", segment: 0, totalSegments: 1, status: "done" });
-  log8.info(`Video type: ${videoProfile.type}`);
-  log8.info(`Strategy: ${strategy.passes.join(" \u2192 ")}`);
   const plan = createSegmentPlan(duration, {
     segmentMinutes: strategy.segmentMinutes,
     resolution: strategy.resolution
@@ -2311,6 +2317,10 @@ async function runPipeline(config) {
   const resolution = plan.resolution;
   const results = [];
   const n = segments.length;
+  const callsPerSegment = 2 + (strategy.passes.includes("chat") ? 1 : 0) + (strategy.passes.includes("implicit") ? 1 : 0);
+  const postSegmentCalls = (strategy.passes.includes("people") ? 1 : 0) + (strategy.passes.includes("code") ? 3 : 0) + (strategy.passes.includes("synthesis") ? 1 : 0);
+  const totalSteps = n * callsPerSegment + postSegmentCalls;
+  let currentStep = 0;
   let pass1RanOnce = false;
   let pass2RanOnce = false;
   let pass3cRanOnce = false;
@@ -2324,21 +2334,22 @@ async function runPipeline(config) {
       break;
     }
     const segment = segments[i];
-    onProgress?.({ phase: "pass1", segment: i, totalSegments: n, status: "running" });
+    onProgress?.({ phase: "pass1", segment: i, totalSegments: n, status: "running", totalSteps });
     let pass1 = null;
     const pass1Attempt = await withRetry(
       () => rateLimiter.execute(() => runTranscript({ client, fileUri, mimeType, segment, model, resolution }), { onWait }),
       `segment ${i} pass1`
     );
     if (pass1Attempt.error !== null) {
-      log8.warn(pass1Attempt.error);
+      log6.warn(pass1Attempt.error);
       errors.push(pass1Attempt.error);
     } else {
       pass1 = pass1Attempt.result;
       pass1RanOnce = true;
     }
-    onProgress?.({ phase: "pass1", segment: i, totalSegments: n, status: "done" });
-    onProgress?.({ phase: "pass2", segment: i, totalSegments: n, status: "running" });
+    currentStep++;
+    onProgress?.({ phase: "pass1", segment: i, totalSegments: n, status: "done", currentStep, totalSteps });
+    onProgress?.({ phase: "pass2", segment: i, totalSegments: n, status: "running", totalSteps });
     let pass2 = null;
     const pass2Attempt = await withRetry(
       () => rateLimiter.execute(
@@ -2356,16 +2367,17 @@ async function runPipeline(config) {
       `segment ${i} pass2`
     );
     if (pass2Attempt.error !== null) {
-      log8.warn(pass2Attempt.error);
+      log6.warn(pass2Attempt.error);
       errors.push(pass2Attempt.error);
     } else {
       pass2 = pass2Attempt.result;
       pass2RanOnce = true;
     }
-    onProgress?.({ phase: "pass2", segment: i, totalSegments: n, status: "done" });
+    currentStep++;
+    onProgress?.({ phase: "pass2", segment: i, totalSegments: n, status: "done", currentStep, totalSteps });
     let pass3c;
     if (strategy.passes.includes("chat")) {
-      onProgress?.({ phase: "pass3c", segment: i, totalSegments: n, status: "running" });
+      onProgress?.({ phase: "pass3c", segment: i, totalSegments: n, status: "running", totalSteps });
       const pass3cAttempt = await withRetry(
         () => rateLimiter.execute(
           () => runChatExtraction({
@@ -2382,18 +2394,19 @@ async function runPipeline(config) {
         `segment ${i} pass3c`
       );
       if (pass3cAttempt.error !== null) {
-        log8.warn(pass3cAttempt.error);
+        log6.warn(pass3cAttempt.error);
         errors.push(pass3cAttempt.error);
         pass3c = null;
       } else {
         pass3c = pass3cAttempt.result;
         pass3cRanOnce = true;
       }
-      onProgress?.({ phase: "pass3c", segment: i, totalSegments: n, status: "done" });
+      currentStep++;
+      onProgress?.({ phase: "pass3c", segment: i, totalSegments: n, status: "done", currentStep, totalSteps });
     }
     let pass3d;
     if (strategy.passes.includes("implicit")) {
-      onProgress?.({ phase: "pass3d", segment: i, totalSegments: n, status: "running" });
+      onProgress?.({ phase: "pass3d", segment: i, totalSegments: n, status: "running", totalSteps });
       const pass3dAttempt = await withRetry(
         () => rateLimiter.execute(
           () => runImplicitSignals({
@@ -2411,14 +2424,15 @@ async function runPipeline(config) {
         `segment ${i} pass3d`
       );
       if (pass3dAttempt.error !== null) {
-        log8.warn(pass3dAttempt.error);
+        log6.warn(pass3dAttempt.error);
         errors.push(pass3dAttempt.error);
         pass3d = null;
       } else {
         pass3d = pass3dAttempt.result;
         pass3dRanOnce = true;
       }
-      onProgress?.({ phase: "pass3d", segment: i, totalSegments: n, status: "done" });
+      currentStep++;
+      onProgress?.({ phase: "pass3d", segment: i, totalSegments: n, status: "done", currentStep, totalSteps });
     }
     results.push({ index: segment.index, pass1, pass2, pass3c, pass3d });
   }
@@ -2447,7 +2461,7 @@ async function runPipeline(config) {
   const pass2Results = results.map((r) => r.pass2);
   let peopleExtraction = null;
   if (strategy.passes.includes("people")) {
-    onProgress?.({ phase: "pass3b", segment: 0, totalSegments: 1, status: "running" });
+    onProgress?.({ phase: "pass3b", segment: 0, totalSegments: 1, status: "running", totalSteps });
     const pass3bAttempt = await withRetry(
       () => rateLimiter.execute(
         () => runPeopleExtraction({
@@ -2462,12 +2476,13 @@ async function runPipeline(config) {
       "pass3b"
     );
     if (pass3bAttempt.error !== null) {
-      log8.warn(pass3bAttempt.error);
+      log6.warn(pass3bAttempt.error);
       errors.push(pass3bAttempt.error);
     } else {
       peopleExtraction = pass3bAttempt.result;
     }
-    onProgress?.({ phase: "pass3b", segment: 0, totalSegments: 1, status: "done" });
+    currentStep++;
+    onProgress?.({ phase: "pass3b", segment: 0, totalSegments: 1, status: "done", currentStep, totalSteps });
     if (peopleExtraction !== null) passesRun.push("pass3b");
   }
   let codeReconstruction = null;
@@ -2491,13 +2506,14 @@ async function runPipeline(config) {
       ),
       pass2Results,
       onProgress: (run, total) => {
-        onProgress?.({ phase: "pass3a", segment: run - 1, totalSegments: total, status: "running" });
+        onProgress?.({ phase: "pass3a", segment: run - 1, totalSegments: total, status: "running", totalSteps });
+        currentStep++;
+        onProgress?.({ phase: "pass3a", segment: run - 1, totalSegments: total, status: "done", currentStep, totalSteps });
       }
     });
-    onProgress?.({ phase: "pass3a", segment: consensusConfig.runs - 1, totalSegments: consensusConfig.runs, status: "done" });
     if (consensusResult.runsCompleted === 0) {
       const errMsg = "pass3a: all consensus runs failed";
-      log8.warn(errMsg);
+      log6.warn(errMsg);
       errors.push(errMsg);
     } else {
       const validationResult = validateCodeReconstruction({
@@ -2513,13 +2529,12 @@ async function runPipeline(config) {
         };
         uncertainCodeFiles = validationResult.uncertain.map((f) => f.filename);
       }
-      log8.info(`Code: ${validationResult.confirmed.length} confirmed, ${validationResult.uncertain.length} uncertain, ${validationResult.rejected.length} rejected`);
     }
     if (codeReconstruction !== null) passesRun.push("pass3a");
   }
   let synthesisResult;
   if (strategy.passes.includes("synthesis")) {
-    onProgress?.({ phase: "synthesis", segment: 0, totalSegments: 1, status: "running" });
+    onProgress?.({ phase: "synthesis", segment: 0, totalSegments: 1, status: "running", totalSteps });
     const synthAttempt = await withRetry(
       () => rateLimiter.execute(
         () => runSynthesis({
@@ -2536,12 +2551,13 @@ async function runPipeline(config) {
       "synthesis"
     );
     if (synthAttempt.error !== null) {
-      log8.warn(synthAttempt.error);
+      log6.warn(synthAttempt.error);
       errors.push(synthAttempt.error);
     } else {
       synthesisResult = synthAttempt.result ?? void 0;
     }
-    onProgress?.({ phase: "synthesis", segment: 0, totalSegments: 1, status: "done" });
+    currentStep++;
+    onProgress?.({ phase: "synthesis", segment: 0, totalSegments: 1, status: "done", currentStep, totalSteps });
     if (synthesisResult !== void 0) passesRun.push("synthesis");
   }
   return {
@@ -2742,8 +2758,8 @@ function renderCodeEvent(block) {
   lines.push("```");
   return lines.join("\n");
 }
-function renderVisualEvent(note) {
-  return `_[${note.timestamp}]_ **${note.visual_type}:** ${note.description}`;
+function renderVisualEvent(note2) {
+  return `_[${note2.timestamp}]_ **${note2.visual_type}:** ${note2.description}`;
 }
 function renderEvent(event) {
   switch (event.kind) {
@@ -2774,8 +2790,8 @@ function writeCombined(params) {
       for (const block of pass2.code_blocks) {
         events.push({ timestamp: block.timestamp, kind: "code", segmentIndex: seg.index, data: block });
       }
-      for (const note of pass2.visual_notes) {
-        events.push({ timestamp: note.timestamp, kind: "visual", segmentIndex: seg.index, data: note });
+      for (const note2 of pass2.visual_notes) {
+        events.push({ timestamp: note2.timestamp, kind: "visual", segmentIndex: seg.index, data: note2 });
       }
     }
     if (events.length === 0) {
@@ -3521,21 +3537,31 @@ async function generateOutput(params) {
 }
 
 // src/core/shutdown.ts
-import { log as log9 } from "@clack/prompts";
+import { log as log7 } from "@clack/prompts";
 function createShutdownHandler(params) {
   const { client, uploadedFileNames } = params;
   let shuttingDown = false;
   let handler = null;
+  let forceHandler = null;
+  let progressCurrentStep = 0;
+  let progressTotalSteps = 0;
+  let hasProgress = false;
   const sigintHandler = () => {
     if (shuttingDown) {
       process.exit(1);
       return;
     }
     shuttingDown = true;
-    log9.warn("Interrupted. Saving partial results...");
+    if (hasProgress) {
+      log7.warn(`Interrupted \u2014 progress saved (${progressCurrentStep}/${progressTotalSteps} steps)`);
+      log7.info(`Resume: vidistill ${params.source} -o ${params.outputDir}/`);
+    } else {
+      log7.warn("Interrupted");
+    }
     const forceExitHandler = () => {
       process.exit(1);
     };
+    forceHandler = forceExitHandler;
     process.once("SIGINT", forceExitHandler);
     const cleanupAndExit = async () => {
       for (const fileName of uploadedFileNames) {
@@ -3564,21 +3590,168 @@ function createShutdownHandler(params) {
         process.removeListener("SIGINT", handler);
         handler = null;
       }
+      if (forceHandler !== null) {
+        process.removeListener("SIGINT", forceHandler);
+        forceHandler = null;
+      }
+    },
+    setProgress(currentStep, totalSteps) {
+      progressCurrentStep = currentStep;
+      progressTotalSteps = totalSteps;
+      hasProgress = true;
     }
   };
 }
 
+// src/commands/distill.ts
+async function runDistill(args) {
+  const apiKey = await resolveApiKey();
+  let rawInput = args.input ?? await promptVideoSource();
+  let context = args.context ?? await promptContext();
+  const allFlagsProvided = args.input != null && args.context != null;
+  if (!allFlagsProvided) {
+    let confirmed = false;
+    while (!confirmed) {
+      showConfigBox({ input: rawInput, context, output: args.output });
+      const choice = await promptConfirmation();
+      switch (choice) {
+        case "start":
+          confirmed = true;
+          break;
+        case "edit-video":
+          rawInput = await promptVideoSource();
+          break;
+        case "edit-context":
+          context = await promptContext();
+          break;
+        case "cancel":
+          cancel2("Cancelled.");
+          process.exit(0);
+      }
+    }
+  }
+  const resolved = resolveInput(rawInput);
+  const client = new GeminiClient(apiKey);
+  let fileUri;
+  let mimeType;
+  let duration;
+  let videoTitle;
+  let uploadedFileNames = [];
+  if (resolved.type === "youtube") {
+    const result = await handleYouTube(resolved.value, client);
+    fileUri = result.fileUri;
+    mimeType = result.mimeType;
+    duration = await detectDuration({
+      ytDlpDuration: result.duration,
+      geminiDuration: result.duration
+    });
+    if (result.uploadedFileName != null) {
+      uploadedFileNames = [result.uploadedFileName];
+    }
+    const videoId = extractVideoId(resolved.value);
+    videoTitle = videoId != null ? `youtube-${videoId}` : resolved.value;
+  } else {
+    const result = await handleLocalFile(resolved.value, client);
+    fileUri = result.fileUri;
+    mimeType = result.mimeType;
+    duration = await detectDuration({
+      filePath: resolved.value,
+      geminiDuration: result.duration
+    });
+    if (result.uploadedFileName != null) {
+      uploadedFileNames = [result.uploadedFileName];
+    }
+    videoTitle = basename3(resolved.value, extname2(resolved.value));
+  }
+  const model = MODELS.flash;
+  const outputDir = resolve(args.output);
+  const slug = slugify(videoTitle);
+  const finalOutputDir = `${outputDir}/${slug}`;
+  const shutdownHandler = createShutdownHandler({
+    client,
+    uploadedFileNames,
+    outputDir,
+    videoTitle,
+    source: rawInput,
+    duration,
+    model
+  });
+  shutdownHandler.register();
+  const rateLimiter = new RateLimiter();
+  const progress2 = createProgressDisplay();
+  const startTime = Date.now();
+  const pipelineResult = await runPipeline({
+    client,
+    fileUri,
+    mimeType,
+    duration,
+    model,
+    context,
+    rateLimiter,
+    onProgress: (status) => {
+      progress2.update(status);
+      if (status.currentStep != null && status.totalSteps != null) {
+        shutdownHandler.setProgress(status.currentStep, status.totalSteps);
+      }
+    },
+    onWait: (delayMs) => progress2.onWait(delayMs),
+    isShuttingDown: () => shutdownHandler.isShuttingDown()
+  });
+  const elapsedMs = Date.now() - startTime;
+  shutdownHandler.deregister();
+  progress2.complete(pipelineResult, elapsedMs);
+  if (pipelineResult.interrupted != null) {
+    return;
+  }
+  const outputResult = await generateOutput({
+    pipelineResult,
+    outputDir,
+    videoTitle,
+    source: rawInput,
+    duration,
+    model,
+    processingTimeMs: elapsedMs
+  });
+  const elapsedSecs = Math.round(elapsedMs / 1e3);
+  const elapsedMins = Math.floor(elapsedSecs / 60);
+  const remainSecs = elapsedSecs % 60;
+  const elapsed = elapsedMins > 0 ? `${elapsedMins}m ${remainSecs}s` : `${remainSecs}s`;
+  log8.success(`Done in ${elapsed}`);
+  log8.info(`Output: ${finalOutputDir}/`);
+  log8.info(pc4.dim("Open guide.md for an overview"));
+  if (pipelineResult.codeReconstruction != null) {
+    log8.info(pc4.dim("Tip: vidistill extract code <input> for code-only extraction next time"));
+  } else if (pipelineResult.peopleExtraction?.participants != null && pipelineResult.peopleExtraction.participants.length > 1) {
+    log8.info(pc4.dim("Tip: vidistill rename-speakers <dir> to assign real names"));
+  } else {
+    log8.info(pc4.dim('Tip: vidistill ask <dir> "your question" to query this video'));
+  }
+  if (outputResult.errors.length > 0) {
+    log8.warn(`Output errors: ${pc4.yellow(String(outputResult.errors.length))}`);
+    for (const err of outputResult.errors) {
+      log8.warn(pc4.dim(`  ${err}`));
+    }
+  }
+}
+
+// import("../commands/**/*.js") in src/cli/index.ts
+var globImport_commands_js = __glob({});
+
 // src/cli/index.ts
+var _require2 = createRequire2(import.meta.url);
+var { version } = _require2("../package.json");
 var DEFAULT_OUTPUT = "./vidistill-output/";
+var SUBCOMMANDS = /* @__PURE__ */ new Set(["ask", "search", "extract", "mcp", "watch", "rename-speakers"]);
 var main = defineCommand({
   meta: {
     name: "vidistill",
-    description: "Video Intelligence Distiller \u2014 turn video into structured notes"
+    version,
+    description: "Video Intelligence Distiller \u2014 turn video into structured notes\n\nCommands: ask, search, extract, mcp, watch, rename-speakers"
   },
   args: {
     input: {
       type: "positional",
-      description: "YouTube URL or local file path",
+      description: "YouTube URL, local file path, or subcommand name",
       required: false
     },
     context: {
@@ -3591,107 +3764,38 @@ var main = defineCommand({
       description: `Output directory for generated notes (default: ${DEFAULT_OUTPUT})`,
       alias: "o",
       default: DEFAULT_OUTPUT
+    },
+    lang: {
+      type: "string",
+      description: "Output language",
+      alias: "l"
     }
   },
   async run({ args }) {
     showLogo();
     showIntro();
+    const name = args.input;
+    if (name != null && SUBCOMMANDS.has(name)) {
+      const mod = await globImport_commands_js(`../commands/${name}.js`);
+      if (typeof mod.run !== "function") {
+        throw new Error(`Subcommand "${name}" does not export a run function`);
+      }
+      await mod.run(process.argv.slice(3));
+      return;
+    }
     try {
-      const apiKey = await resolveApiKey();
-      const rawInput = args.input ?? await promptVideoSource();
-      const context = args.context ?? await promptContext();
-      showConfig({ input: rawInput, context, output: args.output });
-      const resolved = resolveInput(rawInput);
-      const client = new GeminiClient(apiKey);
-      let fileUri;
-      let mimeType;
-      let duration;
-      let videoTitle;
-      let uploadedFileNames = [];
-      if (resolved.type === "youtube") {
-        const result = await handleYouTube(resolved.value, client);
-        fileUri = result.fileUri;
-        mimeType = result.mimeType;
-        duration = await detectDuration({
-          ytDlpDuration: result.duration,
-          geminiDuration: result.duration
-        });
-        if (result.uploadedFileName != null) {
-          uploadedFileNames = [result.uploadedFileName];
-        }
-        const videoId = extractVideoId(resolved.value);
-        videoTitle = videoId != null ? `youtube-${videoId}` : resolved.value;
-      } else {
-        const result = await handleLocalFile(resolved.value, client);
-        fileUri = result.fileUri;
-        mimeType = result.mimeType;
-        duration = await detectDuration({
-          filePath: resolved.value,
-          geminiDuration: result.duration
-        });
-        if (result.uploadedFileName != null) {
-          uploadedFileNames = [result.uploadedFileName];
-        }
-        videoTitle = basename3(resolved.value, extname2(resolved.value));
-      }
-      const mins = Math.floor(duration / 60);
-      const secs = Math.round(duration % 60);
-      log10.info(`Duration: ${pc5.cyan(`${mins}m ${secs}s`)} (${Math.round(duration)}s)`);
-      const model = MODELS.flash;
-      const outputDir = resolve(args.output);
-      const slug = slugify(videoTitle);
-      const finalOutputDir = `${outputDir}/${slug}`;
-      const shutdownHandler = createShutdownHandler({
-        client,
-        uploadedFileNames,
-        outputDir,
-        videoTitle,
-        source: rawInput,
-        duration,
-        model
-      });
-      shutdownHandler.register();
-      const rateLimiter = new RateLimiter();
-      const progress = createProgressDisplay();
-      const startTime = Date.now();
-      const pipelineResult = await runPipeline({
-        client,
-        fileUri,
-        mimeType,
-        duration,
-        model,
-        context,
-        rateLimiter,
-        onProgress: (status) => progress.update(status),
-        onWait: (delayMs) => progress.onWait(delayMs),
-        isShuttingDown: () => shutdownHandler.isShuttingDown()
+      await runDistill({
+        input: args.input,
+        context: args.context,
+        output: args.output,
+        lang: args.lang
       });
-      const elapsedMs = Date.now() - startTime;
-      shutdownHandler.deregister();
-      progress.complete(pipelineResult, elapsedMs);
-      const outputResult = await generateOutput({
-        pipelineResult,
-        outputDir,
-        videoTitle,
-        source: rawInput,
-        duration,
-        model,
-        processingTimeMs: elapsedMs
-      });
-      const fileCount = outputResult.filesGenerated.length;
-      log10.success(
-        `Output: ${pc5.cyan(finalOutputDir + "/")} \u2014 ${pc5.cyan(String(fileCount))} files generated ${pc5.dim("(guide.md for overview)")}`
-      );
-      if (outputResult.errors.length > 0) {
-        log10.warn(`Output errors: ${pc5.yellow(String(outputResult.errors.length))}`);
-        for (const err of outputResult.errors) {
-          log10.warn(pc5.dim(`  ${err}`));
-        }
-      }
     } catch (err) {
+      const { log: log9 } = await import("@clack/prompts");
+      const { default: pc5 } = await import("picocolors");
       const raw = err instanceof Error ? err.message : String(err);
       const message = raw.split("\n")[0].slice(0, 200);
-      log10.error(pc5.red(message));
+      log9.error(pc5.red(message));
       process.exit(1);
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vidistill",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Video intelligence distiller — extract structured notes, transcripts, and insights from any video using Gemini",
   "type": "module",
   "license": "MIT",
@@ -29,7 +29,7 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@clack/prompts": "^0.9.1",
+    "@clack/prompts": "1.0.1",
     "@google/genai": "^1.40.0",
     "citty": "^0.1.6",
     "figlet": "^1.8.0",