ossclip 0.1.10 → 0.1.12

package/src/program.ts

@@ -7,6 +7,7 @@ import { CleanupLevelSchema, SceneComponentIdSchema } from "@ossclip/core";
 import { STUDIO_ENTRY } from "@ossclip/renderer";
 import { loadEnvFiles } from "./env";
 import { produce } from "./produce";
+import { setReplayArgv } from "./replay-argv";
 
 // Before anything reads a provider key (R16 §77) — including the auto-detect
 // order in `defaultProviderName`, which decides which model runs.
@@ -95,13 +96,29 @@ export function buildProgram(): Command {
           // IS supplied — a piped `ossclip <path>` is `ossclip produce <path>`.
           const direct = ["produce", path];
           console.log(`\n▸ running:\n    ${renderCommand(direct)}\n`);
+          // §129: THIS argv — not process.argv, which still says `ossclip
+          // <path>` with no `produce` literal — is the invocation
+          // command.json must record for the editor's Render to replay.
+          // Every parseAsync re-entry below stashes for the same reason.
+          setReplayArgv(direct);
           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 });
+        const cfg = loadConfig();
+        // modelDir so the wizard can enumerate installed whisper models
+        // (Urdu field test 2026-08-05) — same resolution produce.ts uses.
+        // watermark so the extras entry can say when the config already has
+        // the credit on (unchecked ≠ off there — review, minor a).
+        const argv = await produceWizard({
+          speaker: cfg.speaker,
+          modelDir: cfg.modelDir,
+          input: path,
+          watermark: cfg.watermark,
+        });
         console.log(`\n▸ running:\n    ${renderCommand(argv)}\n`);
+        setReplayArgv(argv); // §129
         await program.parseAsync(["node", "ossclip", ...argv]);
         return;
       }
@@ -119,13 +136,24 @@ export function buildProgram(): Command {
         // 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`);
+        // §129: stashed even for non-produce choices — the invariant is that
+        // the stash always mirrors the parse being entered, and only
+        // produce's recording ever reads it (consume-on-read keeps a
+        // non-produce stash from leaking past this parse).
+        setReplayArgv(direct);
         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 });
+      const cfg = loadConfig();
+      const argv = await produceWizard({
+        speaker: cfg.speaker,
+        modelDir: cfg.modelDir,
+        watermark: cfg.watermark,
+      });
       console.log(`\n▸ running:\n    ${renderCommand(argv)}\n`);
+      setReplayArgv(argv); // §129
       await program.parseAsync(["node", "ossclip", ...argv]);
     });
 
@@ -202,6 +230,10 @@ export function buildProgram(): Command {
       "skip the ASR mishearing repair pass (captions then show the raw transcription)",
     )
     .option("--whisper-model <name>", "transcription model for this run, e.g. base.en | small.en | medium.en")
+    .option(
+      "--whisper-language <code>",
+      "transcription language code for a multilingual model, e.g. ur | de | auto (whisper defaults to en)",
+    )
     .option(
       "--force-component <id>",
       "debug: render every graphic with this component (e.g. FlowDiagram) to exercise it on real copy",
@@ -228,6 +260,16 @@ export function buildProgram(): Command {
         "the last complete attempt — the flub the speaker did NOT mark. Off by default",
       false,
     )
+    // Declared as the same tri-state pair as --open-editor/--no-open-editor:
+    // positive first so commander's default stays undefined ("not typed"),
+    // which is what lets the config supply the default while a typed
+    // --no-watermark still beats a config-on.
+    .option(
+      "--watermark",
+      'credit the tool: a small "made with ossclip" wordmark in the top-left safe area ' +
+        "(set it once with watermark: true in ~/.ossclip/config.json)",
+    )
+    .option("--no-watermark", "no wordmark, even when the config turns it on")
     .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")
@@ -259,10 +301,16 @@ export function buildProgram(): Command {
         const { produceWizard } = await import("./interactive/produce-wizard");
         const { renderCommand } = await import("./interactive/render");
         const { loadConfig } = await import("@ossclip/core");
-        const argv = await produceWizard({ speaker: loadConfig().speaker });
+        const cfg = loadConfig();
+        const argv = await produceWizard({
+          speaker: cfg.speaker,
+          modelDir: cfg.modelDir,
+          watermark: cfg.watermark,
+        });
         console.log(`\n▸ running:\n    ${renderCommand(argv)}\n`);
         // Re-entering the SAME parse the flags take: the zod checks below run
         // on wizard output exactly as they do on a typed command line.
+        setReplayArgv(argv); // §129
         await program.parseAsync(["node", "ossclip", ...argv]);
         return;
       }
@@ -286,6 +334,14 @@ export function buildProgram(): Command {
       // --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";
+      // Not an enum — whisper accepts dozens of codes plus "auto" and the list
+      // grows with fine-tunes — but an empty string would reach whisper as a
+      // bare `-l` and must be an error naming the flag, not a silent English
+      // run over an Urdu model (Urdu field test 2026-08-05).
+      const whisperLanguage =
+        opts.whisperLanguage !== undefined
+          ? z.string().trim().min(1, "--whisper-language needs a code, e.g. ur").parse(opts.whisperLanguage)
+          : undefined;
       const result = await produce(input, {
         out: opts.out,
         cleanup,
@@ -306,6 +362,7 @@ export function buildProgram(): Command {
         scenes: opts.scenes,
         repair: opts.repair,
         whisperModel: opts.whisperModel,
+        whisperLanguage,
         forceComponent,
         // commander gives `--no-cover` as cover:false and `--cover <path>` as a
         // string on the same key.
@@ -313,6 +370,8 @@ export function buildProgram(): Command {
         blooperMarker: opts.blooperMarker,
         collapseRetakes: opts.collapseRetakes,
         sourceFit,
+        // undefined = "not typed", so produce can let the config decide.
+        watermark: opts.watermark,
         cover: opts.cover !== false,
         coverPath: typeof opts.cover === "string" ? opts.cover : undefined,
         clip: opts.clip,
@@ -331,6 +390,10 @@ export function buildProgram(): Command {
     .option("--noise-db <db>", "override the measured silence threshold, e.g. -30", parseFloat)
     .option("--workdir <dir>", "cache/work directory")
     .option("--whisper-model <name>", "transcription model for this run, e.g. base.en | small.en | medium.en")
+    .option(
+      "--whisper-language <code>",
+      "transcription language code for a multilingual model, e.g. ur | de | auto (whisper defaults to en)",
+    )
     .action(async (input: string, opts) => {
       const cleanup = CleanupLevelSchema.parse(opts.cleanup);
       await produce(input, {
@@ -341,6 +404,11 @@ export function buildProgram(): Command {
         workdir: opts.workdir,
         noiseDb: opts.noiseDb,
         whisperModel: opts.whisperModel,
+        // Same guard as produce's: empty must error, not become a bare `-l`.
+        whisperLanguage:
+          opts.whisperLanguage !== undefined
+            ? z.string().trim().min(1, "--whisper-language needs a code, e.g. ur").parse(opts.whisperLanguage)
+            : undefined,
       });
     });
 

package/src/replay-argv.ts

@@ -0,0 +1,78 @@
+/**
+ * What command.json must record: the argv of the parse that ACTUALLY ran
+ * (§129).
+ *
+ * `produce` records its invocation into the workdir so the editor's Render
+ * button can replay it byte for byte. It used to record `process.argv`,
+ * which is the truth for exactly one entry point — a directly typed
+ * `ossclip produce …`. The wizard has always BUILT a produce argv and
+ * re-entered `program.parseAsync(["node", "ossclip", ...argv])`, and the
+ * bare-path route does the same; in both, process.argv still holds the
+ * ORIGINAL invocation — no `produce` literal, none of the wizard's answers —
+ * so every re-entered run recorded a command that replays as
+ * `ossclip <path> --llm …` and dies at commander's front door with
+ * "error: unknown option '--llm'" (§129's field artifact). The re-entry
+ * sites in program.ts stash the argv they are about to parse here; the
+ * recording prefers the stash and falls back to process.argv, which keeps
+ * the direct path byte-identical to what it always wrote.
+ */
+
+let stashed: string[] | null = null;
+
+/**
+ * Called by every parseAsync re-entry in program.ts, immediately before the
+ * parse, with the argv minus its ["node", "ossclip"] prefix. Copied so a
+ * caller reusing its array cannot retroactively edit the record.
+ */
+export function setReplayArgv(argv: string[]): void {
+  stashed = [...argv];
+}
+
+/**
+ * Consume-on-read (§129): commander 12 keeps option state across parseAsync
+ * calls (see the bare-`produce` refusal in program.ts), and a stash kept
+ * across parses would be the same trap one layer up — a menu choice that
+ * never reaches `produce` must not leave its argv behind for a later
+ * recording in the same process to mistake for its own.
+ */
+export function consumeReplayArgv(): string[] | null {
+  const argv = stashed;
+  stashed = null;
+  return argv;
+}
+
+/**
+ * The args `produce` writes into command.json: the argv of the parse that
+ * ran (stash for a re-entered wizard/bare-path run, process.argv for a
+ * directly typed one), plus the §75/§93g pins. The pins guard on
+ * `includes` so a flag the user actually typed — or a pin recorded by the
+ * run a replay is re-running — is never appended twice.
+ */
+export function recordedProduceArgs(pins: {
+  llm?: string;
+  clipWindow?: string;
+  watermark?: boolean;
+}): string[] {
+  const args = consumeReplayArgv() ?? process.argv.slice(2);
+  if (pins.llm !== undefined && !args.includes("--llm")) {
+    args.push("--llm", pins.llm);
+  }
+  if (pins.clipWindow !== undefined && !args.includes("--clip-window")) {
+    args.push("--clip-window", pins.clipWindow);
+  }
+  // The watermark, pinned like §75 pinned the provider — in BOTH directions
+  // (review, Important): the effective default is config-dependent, so "no
+  // flag in the argv" does not replay identically everywhere. An off-record
+  // left unpinned would silently GAIN a watermark the moment the replay runs
+  // under a config-on (`~/.ossclip/config.json` edited later, or the editor's
+  // Render on another machine) — the exact drift §75 exists to prevent, just
+  // mirrored. So every record carries the RESOLVED state: `--watermark` when
+  // on, `--no-watermark` when off, and a typed flag (already in the argv,
+  // caught by the includes-guard) is never doubled. One flag per command.json
+  // is the price; determinism is the contract, byte-identity of off-records
+  // was only ever a nicety.
+  if (pins.watermark !== undefined && !args.includes("--watermark") && !args.includes("--no-watermark")) {
+    args.push(pins.watermark ? "--watermark" : "--no-watermark");
+  }
+  return args;
+}

package/src/stranded-overrides.ts

@@ -0,0 +1,77 @@
+import { basename } from "node:path";
+
+/**
+ * §131's residue: renaming/adding/removing clips in a folder input re-keys
+ * the content hash, so produce derives a FRESH workdir — correct for every
+ * cache (a stale transcript against a different edit is the bug §131's
+ * manifest hashing exists to prevent), but the OLD workdir's editor edits
+ * (`overrides.json`) are user-owned work that silently stops being found.
+ * The user sees a clean produce and never learns their edits live one
+ * sibling directory over. This module is the pure half of the pointer that
+ * closes that gap: given the sibling directory listing, decide WHICH
+ * directories to point at. All filesystem reads stay in produce.ts so the
+ * cross-folder matching rules below are testable without a disk.
+ */
+
+/**
+ * The `<basename>-<hash8>` naming's basename half, shared with
+ * `deriveWorkdir` (produce.ts) so the sibling scan can never disagree with
+ * the naming scheme it scans for — a drift between the two would make every
+ * pointer silently miss.
+ */
+export function workdirBaseName(identity: string): string {
+  return basename(identity).replace(/\.[^.]+$/, "");
+}
+
+export interface SiblingWorkdirEntry {
+  /** Directory entry name inside the workdir root (not a full path). */
+  name: string;
+  hasOverrides: boolean;
+  /** mtime of the entry's overrides.json — 0 when it has none. */
+  mtimeMs: number;
+}
+
+/** Cap on printed pointers — a folder edited across many re-keys must not flood the run log. */
+export const MAX_STRANDED_POINTERS = 3;
+
+/**
+ * Which sibling workdirs hold stranded editor edits for this folder, newest
+ * edit first. Matching is prefix + exactly-8-lowercase-hex (sha1's own
+ * alphabet), NOT a loose startsWith: `MyClips2-bbbbbbbb` must never match
+ * base `MyClips` (a different folder entirely), and requiring the hash shape
+ * after the `-` is what rules it out — `2-bbbbbbbb` is not 8 hex. The
+ * optional `-16x9` tail mirrors deriveWorkdir's landscape suffix; edits
+ * stranded in either aspect's workdir are still this folder's edits. Same
+ * hash in the other aspect is excluded: that workdir is reachable by
+ * re-running with the other --aspect, not stranded by a re-key.
+ */
+export function strandedOverrideSiblings(p: {
+  base: string;
+  /** This run's 8-hex content hash — its own workdirs are not "previous". */
+  currentHash: string;
+  entries: SiblingWorkdirEntry[];
+}): string[] {
+  const prefix = `${p.base}-`;
+  return p.entries
+    .filter((e) => {
+      if (!e.hasOverrides || !e.name.startsWith(prefix)) return false;
+      const m = /^([0-9a-f]{8})(-16x9)?$/.exec(e.name.slice(prefix.length));
+      return m !== null && m[1] !== p.currentHash;
+    })
+    .sort((a, b) => b.mtimeMs - a.mtimeMs)
+    .slice(0, MAX_STRANDED_POINTERS)
+    .map((e) => e.name);
+}
+
+/**
+ * The printed pointer. Says "for this folder" deliberately loosely — two
+ * different folders sharing a basename under one --workdir root can collide
+ * into this list, and the wording stays honest for that case rather than
+ * claiming a provenance the name alone can't prove (§131 brief).
+ */
+export function strandedPointerLine(path: string): string {
+  return (
+    `▸ previous project for this folder: ${path} ` +
+    `(has editor edits — they don't carry over; open it with: ossclip edit '${path}')`
+  );
+}