ossclip 0.1.7 → 0.1.10

package/src/program.ts

@@ -1,5 +1,5 @@
 import { spawn } from "node:child_process";
-import { readFileSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { Command, InvalidArgumentError } from "commander";
 import { z } from "zod/v4";
@@ -51,31 +51,83 @@ export function buildProgram(): Command {
   // Bare `ossclip` at a TTY opens the menu. Piped or in CI it prints help,
   // byte for byte what it printed before — a front door must not become a
   // hang for a script.
-  program.action(async () => {
-    const { isInteractive } = await import("./interactive/tty");
-    if (!isInteractive()) {
-      program.outputHelp();
-      return;
-    }
-    const { chooseFromMenu, menuArgv } = await import("./interactive/menu");
-    const choice = await chooseFromMenu();
-    const direct = menuArgv(choice);
-    const { renderCommand } = await import("./interactive/render");
-    if (direct !== null) {
-      // Echoed for the same reason the wizard echoes: the README promises
-      // "every choice prints the equivalent command before it runs, so the
-      // menu is also how you learn the flags", and three of the four entries
-      // printed nothing. The menu's whole pedagogical point is this line.
-      console.log(`\n▸ running:\n    ${renderCommand(direct)}\n`);
-      await program.parseAsync(["node", "ossclip", ...direct]);
-      return;
-    }
-    const { produceWizard } = await import("./interactive/produce-wizard");
-    const { loadConfig } = await import("@ossclip/core");
-    const argv = await produceWizard({ speaker: loadConfig().speaker });
-    console.log(`\n▸ running:\n    ${renderCommand(argv)}\n`);
-    await program.parseAsync(["node", "ossclip", ...argv]);
-  });
+  //
+  // Bare `ossclip <path>` ROUTES (0.1.9 first-contact, 2026-08-05): with no
+  // argument declared here, commander's default allow-excess-args silently
+  // DROPPED the positional — `ossclip "./Anyhropic c Compiler"` opened the
+  // menu as if nothing had been typed, and the user re-answered the wizard's
+  // input prompt by hand, wrongly, with all of ~/Downloads. Commander
+  // dispatches registered subcommand names before this action ever runs, so
+  // `produce`/`edit`/… always win over path interpretation (a folder that
+  // happens to be NAMED `doctor` goes to the subcommand — acceptable);
+  // anything that lands here is a path or a typo, and a typo must be a loud
+  // error naming what was tried, never the menu.
+  program
+    .argument(
+      "[path]",
+      "an existing video file or clips folder — shorthand for `ossclip produce <path>`, " +
+        "with the wizard asking the remaining questions",
+    )
+    // Commander 12 allows excess args by default, which is the SECOND half of
+    // the field failure (review, Important): the report's path was typed
+    // UNQUOTED — `ossclip ./Anyhropic c Compiler` — and with excess args
+    // allowed, `c` and `Compiler` would vanish wordlessly the moment
+    // `./Anyhropic` happened to exist, producing the wrong scope. An unquoted
+    // multi-word path must be a loud error, never a partial run.
+    .allowExcessArguments(false)
+    .action(async (path: string | undefined) => {
+      const { isInteractive } = await import("./interactive/tty");
+      if (path !== undefined) {
+        if (!existsSync(path)) {
+          throw new Error(
+            `no such file or directory: ${path}\n` +
+              "  bare `ossclip <path>` produces an existing video file or clips folder;\n" +
+              "  run `ossclip --help` for the commands.",
+          );
+        }
+        const { renderCommand } = await import("./interactive/render");
+        // Both branches hand argv back through `program.parseAsync` — the same
+        // re-entry shape as the wizard paths below, for the same reason: the
+        // zod checks in the produce action must run on this input exactly as
+        // they do on a typed command line.
+        if (!isInteractive()) {
+          // No TTY means no wizard for the remaining questions, but the input
+          // IS supplied — a piped `ossclip <path>` is `ossclip produce <path>`.
+          const direct = ["produce", path];
+          console.log(`\n▸ running:\n    ${renderCommand(direct)}\n`);
+          await program.parseAsync(["node", "ossclip", ...direct]);
+          return;
+        }
+        const { produceWizard } = await import("./interactive/produce-wizard");
+        const { loadConfig } = await import("@ossclip/core");
+        const argv = await produceWizard({ speaker: loadConfig().speaker, input: path });
+        console.log(`\n▸ running:\n    ${renderCommand(argv)}\n`);
+        await program.parseAsync(["node", "ossclip", ...argv]);
+        return;
+      }
+      if (!isInteractive()) {
+        program.outputHelp();
+        return;
+      }
+      const { chooseFromMenu, menuArgv } = await import("./interactive/menu");
+      const choice = await chooseFromMenu();
+      const direct = menuArgv(choice);
+      const { renderCommand } = await import("./interactive/render");
+      if (direct !== null) {
+        // Echoed for the same reason the wizard echoes: the README promises
+        // "every choice prints the equivalent command before it runs, so the
+        // menu is also how you learn the flags", and three of the four entries
+        // printed nothing. The menu's whole pedagogical point is this line.
+        console.log(`\n▸ running:\n    ${renderCommand(direct)}\n`);
+        await program.parseAsync(["node", "ossclip", ...direct]);
+        return;
+      }
+      const { produceWizard } = await import("./interactive/produce-wizard");
+      const { loadConfig } = await import("@ossclip/core");
+      const argv = await produceWizard({ speaker: loadConfig().speaker });
+      console.log(`\n▸ running:\n    ${renderCommand(argv)}\n`);
+      await program.parseAsync(["node", "ossclip", ...argv]);
+    });
 
   program
     .command("produce")
@@ -83,7 +135,10 @@ export function buildProgram(): Command {
     // OPTIONAL so a bare `ossclip produce` at a TTY opens the wizard instead of
     // printing a usage error at somebody who does not yet know the flags. A
     // non-interactive run still gets commander's "missing required argument".
-    .argument("[input]", "input video file")
+    .argument(
+      "[input]",
+      "input video file, or a folder of clips to concatenate (by name; see --sort)",
+    )
     .option("-o, --out <path>", "output video path (default: <input>.ossclip.mp4)")
     .option("--cleanup <level>", "exact | light | standard | aggressive", "standard")
     .option("--transcript <path>", "inject a transcript JSON instead of running whisper")
@@ -95,6 +150,12 @@ export function buildProgram(): Command {
     )
     .option("--noise-db <db>", "override the measured silence threshold, e.g. -30", parseFloat)
     .option("--workdir <dir>", "cache/work directory (default: <input dir>/.ossclip)")
+    .option(
+      "--sort <order>",
+      "when <input> is a folder: order its clips before concatenating them — " +
+        "name (default, plain codepoint sort, matches `ls`) or mtime (oldest first)",
+      "name",
+    )
     .option(
       "--aspect <ratio>",
       "output shape: 9:16 (vertical, default) or 16:9 (landscape, 1920x1080)",
@@ -161,6 +222,12 @@ export function buildProgram(): Command {
       "cut the flubbed take whenever you say this word out loud (e.g. blooper): " +
         "removal runs back to the start of the sentence it spoiled. Off unless given",
     )
+    .option(
+      "--collapse-retakes",
+      "deterministically collapse consecutive near-identical sentences, keeping only " +
+        "the last complete attempt — the flub the speaker did NOT mark. Off by default",
+      false,
+    )
     .option("--no-cover", "skip the cover image written beside the video")
     .option("--cover <path>", "cover image output path (default: <out>.cover.jpg)")
     .option("--open-editor", "open the editor when the run finishes")
@@ -212,6 +279,13 @@ export function buildProgram(): Command {
       // Parsed, not coerced: a typo'd `--source-fit containn` silently falling
       // back to cover is exactly the crop the flag exists to prevent.
       const sourceFit = z.enum(["cover", "contain"]).parse(opts.sourceFit);
+      // Same reasoning as --source-fit: a typo'd --sort dat must not silently
+      // become the default rather than an error naming the mistake.
+      const sort = z.enum(["name", "mtime"]).parse(opts.sort);
+      // Final-review fix wave, cheap minor c: distinguishes "the user typed
+      // --sort" from "commander's own default filled it in" so produce() can
+      // say something when --sort is given for a file, where it does nothing.
+      const sortExplicit = command.getOptionValueSource("sort") === "cli";
       const result = await produce(input, {
         out: opts.out,
         cleanup,
@@ -219,6 +293,8 @@ export function buildProgram(): Command {
         render: opts.render,
         mezzanine: opts.mezzanine,
         workdir: opts.workdir,
+        sort,
+        sortExplicit,
         aspect: opts.aspect === "16:9" ? "16:9" : "9:16",
         noiseDb: opts.noiseDb,
         produce: opts.produce,
@@ -235,6 +311,7 @@ export function buildProgram(): Command {
         // string on the same key.
         sourceIsEdited: opts.sourceIsEdited === true,
         blooperMarker: opts.blooperMarker,
+        collapseRetakes: opts.collapseRetakes,
         sourceFit,
         cover: opts.cover !== false,
         coverPath: typeof opts.cover === "string" ? opts.cover : undefined,