npm - ossclip - Versions diffs - 0.1.20 → 0.1.22 - Mend

ossclip 0.1.20 → 0.1.22

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (11) hide show

package/README.md +3 -1
package/editor-dist/assets/{index-B44I-xE4.js → index-MLGz89mM.js} +32 -32
package/editor-dist/index.html +1 -1
package/package.json +4 -4
package/src/analyze.ts +230 -0
package/src/edit.ts +63 -3
package/src/interactive/picker.ts +47 -26
package/src/produce.ts +158 -23
package/src/program.ts +25 -8
package/src/ui/animation.ts +421 -0
package/src/analyse.ts +0 -101

package/editor-dist/index.html CHANGED Viewed

@@ -4,7 +4,7 @@
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>ossclip editor</title>
-    <script type="module" crossorigin src="/assets/index-B44I-xE4.js"></script>
+    <script type="module" crossorigin src="/assets/index-MLGz89mM.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-ChRVBVLj.css">
   </head>
   <body>

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "ossclip",
-  "version": "0.1.20",
+  "version": "0.1.22",
   "description": "Local-first CLI video producer: cuts silence and fillers, word-timed captions, face-aware framing, and LLM-planned code-rendered graphics — transcription and rendering never leave your machine",
   "type": "module",
   "license": "MIT",
@@ -36,9 +36,9 @@
     "commander": "^12.1.0",
     "tsx": "^4.19.0",
     "zod": "^3.25.76",
-    "@ossclip/scenes": "0.1.20",
-    "@ossclip/renderer": "0.1.20",
-    "@ossclip/core": "0.1.20"
+    "@ossclip/renderer": "0.1.22",
+    "@ossclip/scenes": "0.1.22",
+    "@ossclip/core": "0.1.22"
   },
   "homepage": "https://github.com/AhsanAyaz/ossclip#readme",
   "bugs": {

package/src/analyze.ts ADDED Viewed

@@ -0,0 +1,230 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { z } from "zod/v4";
+import {
+  ProductionSchema,
+  buildFcpxmlMarkers,
+  buildPremiereProject,
+  buildPremiereXmlMarkers,
+  buildResolveMarkerEdl,
+  keptPauses,
+  type CleanupLevel,
+} from "@ossclip/core";
+import { produce } from "./produce";
+import type { PhaseTimings } from "./phase-timing";
+/**
+ * `ossclip analyze` (next-directions §2–3; design doc
+ * 2026-08-12-analyse-fcpxml-export-design.md): the analyzer without the
+ * renderer. §140 measured the render at 85% of wall time on two machines —
+ * this command is the product of skipping it: the same pipeline up to the
+ * cut report (no LLM, no Remotion), plus an export file an editor's own NLE
+ * can review. Markers, not applied cuts, by design — see the exporter.
+ */
+/**
+ * zod enum, not a string: a typo'd `--format fcpxmll` must error naming the
+ * choice, never fall back to a default that silently writes the wrong file
+ * (CLAUDE.md's `--source-fit containn` rule, verbatim).
+ *
+ * `resolve-edl`, not `edl` (§142): it is Resolve's marker-EDL dialect —
+ * markers with colours, for `Timeline → Import → Timeline Markers from EDL`
+ * — not a cut EDL. A future cut EDL gets its own name; "edl" meaning either
+ * would be a permanent ambiguity. It exists because Resolve's FCPXML import
+ * silently drops clip markers (field-verified the day fcpxml shipped);
+ * Premiere reads the fcpxml markers fine.
+ */
+export const ExportFormatSchema = z.enum([
+  "fcpxml",
+  "resolve-edl",
+  "premiere-xml",
+  // The pre-cut project: markers annotate an untouched take; this one applies
+  // the cutlist and carries the render's camera motion as editable keyframes
+  // (plan 2026-08-13). A distinct name, not a flag on premiere-xml — the two
+  // answer different questions ("review my cuts" vs "hand me the edit").
+  "premiere-project",
+]);
+export type ExportFormat = z.infer<typeof ExportFormatSchema>;
+/** The FILE extension per format — "demo.resolve-edl" would import nowhere. */
+const FORMAT_EXTENSIONS: Record<ExportFormat, string> = {
+  fcpxml: "fcpxml",
+  "resolve-edl": "edl",
+  "premiere-xml": "xml",
+  // NOT bare "xml": the marker format above already owns `<input>.xml`, and
+  // an editor who exported markers yesterday and the project today would
+  // silently clobber the file they sent their editor. Distinct default,
+  // same importable extension.
+  "premiere-project": "project.xml",
+};
+/**
+ * The slice of `render-props.json` the project export needs — SELECTIVE on
+ * purpose, and parsed rather than cast (CLAUDE.md): the file is user-visible
+ * and hand-editable, so a truncated or tweaked one must error here with a
+ * field name, not export a project with NaN trims. `srcStart` and the rest
+ * of a caption word are deliberately not asked for: the SRT only needs text
+ * and output-time bounds, and legacy files predate `srcStart` (§137).
+ */
+export const RenderPropsExportSchema = z.object({
+  spans: z.array(
+    z.object({
+      srcIn: z.number(),
+      srcOut: z.number(),
+      outIn: z.number(),
+      outOut: z.number(),
+    }),
+  ),
+  captionLines: z.array(
+    z.object({
+      words: z.array(z.object({ text: z.string() })),
+      start: z.number(),
+      end: z.number(),
+    }),
+  ),
+  zoomPlan: z.array(
+    z.object({
+      startSec: z.number(),
+      endSec: z.number(),
+      from: z.number(),
+      to: z.number(),
+    }),
+  ),
+  // Written only when the camera is OFF (produce's absent-means-default
+  // contract) — absent must read as "motion on".
+  staticCamera: z.boolean().optional(),
+});
+/** Same shape as produce's `defaultOutPath`: beside the input, new extension. */
+export function defaultExportPath(input: string, format: ExportFormat): string {
+  return input.replace(/(\.[^.]+)?$/, `.${FORMAT_EXTENSIONS[format]}`);
+}
+export interface AnalyzeOptions {
+  cleanup: CleanupLevel;
+  format: ExportFormat;
+  out?: string;
+  transcript?: string;
+  workdir?: string;
+  noiseDb?: number;
+  whisperModel?: string;
+  whisperLanguage?: string;
+  blooperMarker?: string;
+  collapseRetakes?: boolean;
+  sort?: "name" | "mtime";
+  sortExplicit?: boolean;
+}
+export interface AnalyzeResult {
+  workdir: string;
+  outPath: string;
+  /** The SRT sidecar — present only for `premiere-project` (two-file format). */
+  srtPath?: string;
+  /** Suggested-cut markers — one per remove segment. */
+  markerCount: number;
+  /** Informational kept-pause markers (§142 round 2) — counted separately
+   * so the CLI and telemetry can say which is which. */
+  pauseCount: number;
+  sourceDurationSec: number;
+  phaseTimings: PhaseTimings;
+}
+/**
+ * The I/O glue: run the existing no-render pipeline, read back the
+ * `production.json` it wrote, hand it to the pure exporter, write the file.
+ * The read-back goes through `ProductionSchema.parse` even though this very
+ * run just wrote it — the file is user-visible and hand-editable, and a
+ * truncated or tweaked one must error here, not export garbage markers.
+ */
+export async function runAnalyze(
+  inputArg: string,
+  opts: AnalyzeOptions,
+): Promise<AnalyzeResult> {
+  const result = await produce(inputArg, {
+    cleanup: opts.cleanup,
+    transcript: opts.transcript,
+    render: false,
+    mezzanine: false,
+    workdir: opts.workdir,
+    noiseDb: opts.noiseDb,
+    whisperModel: opts.whisperModel,
+    whisperLanguage: opts.whisperLanguage,
+    blooperMarker: opts.blooperMarker,
+    collapseRetakes: opts.collapseRetakes,
+    sort: opts.sort,
+    sortExplicit: opts.sortExplicit,
+    cover: false,
+  });
+  const production = ProductionSchema.parse(
+    JSON.parse(await readFile(join(result.workdir, "production.json"), "utf8")),
+  );
+  const markerCount = (production.cutlist ?? []).filter((s) => s.kind === "remove").length;
+  const pauseCount = keptPauses(production).length;
+  const outPath = resolve(opts.out ?? defaultExportPath(resolve(inputArg), opts.format));
+  if (opts.format === "premiere-project") {
+    // The project export reads render-props.json, not just production.json:
+    // spans/captions/zoom are the RENDER's own inputs, so the exported
+    // project is the render, not a re-derivation of it. Same parse rule as
+    // the production read-back above — the file is hand-editable.
+    const props = RenderPropsExportSchema.parse(
+      JSON.parse(await readFile(join(result.workdir, "render-props.json"), "utf8")),
+    );
+    const { xml, srt } = buildPremiereProject({
+      production,
+      spans: props.spans,
+      captionLines: props.captionLines,
+      zoomPlan: props.zoomPlan,
+      staticCamera: props.staticCamera,
+      // The OUTPUT frame — production.render already carries --aspect.
+      frame: { width: production.render.width, height: production.render.height },
+    });
+    // Same basename, .srt — beside the xml so the pair travels together.
+    const srtPath = outPath.replace(/(\.[^.]+)?$/, ".srt");
+    await writeFile(outPath, xml);
+    await writeFile(srtPath, srt);
+    console.log(
+      `✓ premiere-project → ${outPath} + ${srtPath} ` +
+        `(cuts applied, camera motion as Basic Motion keyframes — in Premiere: ` +
+        `File → Import the .xml; then import the .srt onto the timeline for captions)`,
+    );
+    return {
+      workdir: result.workdir,
+      outPath,
+      srtPath,
+      markerCount,
+      pauseCount,
+      sourceDurationSec: result.sourceDurationSec,
+      phaseTimings: result.phaseTimings,
+    };
+  }
+  // §142, learned the hard way in one field-test hour: each NLE gets its OWN
+  // dialect. Premiere rejects modern fcpxml outright, Resolve's fcpxml import
+  // silently drops markers — so fcpxml is for actual Final Cut Pro.
+  const content =
+    opts.format === "resolve-edl"
+      ? buildResolveMarkerEdl(production)
+      : opts.format === "premiere-xml"
+        ? buildPremiereXmlMarkers(production)
+        : buildFcpxmlMarkers(production);
+  await writeFile(outPath, content);
+  const detail =
+    opts.format === "resolve-edl"
+      ? "in Resolve: Media Pool → right-click your timeline → Timelines → Import → Timeline Markers from EDL"
+      : opts.format === "premiere-xml"
+        ? "in Premiere: File → Import, pick the .xml, relink media if offline"
+        : "for Final Cut Pro; Premiere needs --format premiere-xml, Resolve --format resolve-edl";
+  console.log(
+    `✓ ${opts.format} → ${outPath} (${markerCount} cut marker${markerCount === 1 ? "" : "s"}` +
+      `${pauseCount > 0 ? ` + ${pauseCount} kept-pause marker${pauseCount === 1 ? "" : "s"}` : ""} — ${detail})`,
+  );
+  return {
+    workdir: result.workdir,
+    outPath,
+    markerCount,
+    pauseCount,
+    sourceDurationSec: result.sourceDurationSec,
+    phaseTimings: result.phaseTimings,
+  };
+}

package/src/edit.ts CHANGED Viewed

@@ -289,6 +289,20 @@ export async function startEditServer(
             videoFileName: renderProps.videoFileName,
             // Whether the Render button has a recorded invocation to replay.
             canRender: existsSync(commandPath()),
+            defaultOutPath: (() => {
+              try {
+                if (existsSync(commandPath())) {
+                  const cmd = JSON.parse(readFileSync(commandPath(), "utf8")) as { args?: string[] };
+                  if (Array.isArray(cmd.args)) {
+                    const idx = cmd.args.findIndex((a) => a === "-o" || a === "--out");
+                    if (idx !== -1 && cmd.args[idx + 1]) return cmd.args[idx + 1];
+                  }
+                }
+              } catch {
+                // ignore
+              }
+              return undefined;
+            })(),
             // Recents ride along here too, so the top bar's Open picker has
             // a list without a second endpoint.
             recent: await readRecentProjects(opts.recentDir),
@@ -345,6 +359,28 @@ export async function startEditServer(
           return send(200, { ok: true, workdir });
         }
+        if (url.pathname === "/api/pick-save-path" && req.method === "POST") {
+          const chunks: Buffer[] = [];
+          for await (const c of req) chunks.push(c as Buffer);
+          let defaultPath: string | undefined;
+          try {
+            const raw = Buffer.concat(chunks).toString();
+            if (raw.trim()) {
+              const body = JSON.parse(raw) as { defaultPath?: string };
+              if (typeof body.defaultPath === "string") defaultPath = body.defaultPath;
+            }
+          } catch {
+            // ignore
+          }
+          let startLoc = defaultPath;
+          if (!startLoc && workdir) {
+            startLoc = dirname(workdir);
+          }
+          const { pickPath, livePickerDeps } = await import("./interactive/picker");
+          const picked = await pickPath("save", livePickerDeps(), startLoc);
+          return send(200, { path: picked ?? null });
+        }
         if (url.pathname === "/api/fs" && req.method === "GET") {
           // The picker's folder browser (R17 §83): directories only, with
           // "this one is a project" flagged. Local tool on a local loopback
@@ -394,8 +430,6 @@ export async function startEditServer(
         }
         if (url.pathname === "/api/render" && req.method === "POST") {
-          // Replays ONLY the argv `produce` recorded — the request body is
-          // never read, let alone executed.
           if (!workdir) return send(409, { error: "no workdir open" });
           if (renderChild) return send(409, { error: "a render is already running" });
           if (!existsSync(commandPath())) {
@@ -405,6 +439,20 @@ export async function startEditServer(
                 "the terminal so the invocation is recorded, then Render can replay it",
             });
           }
+          const chunks: Buffer[] = [];
+          for await (const c of req) chunks.push(c as Buffer);
+          let customOut: string | undefined;
+          try {
+            const raw = Buffer.concat(chunks).toString();
+            if (raw.trim()) {
+              const body = JSON.parse(raw) as { out?: string };
+              if (typeof body.out === "string" && body.out.trim()) {
+                customOut = body.out.trim();
+              }
+            }
+          } catch {
+            // ignore
+          }
           const parsed = CommandSchema.safeParse(
             JSON.parse(await readFile(commandPath(), "utf8")),
           );
@@ -420,7 +468,19 @@ export async function startEditServer(
           // reconstruct the command that ran. A modern record — and a legacy
           // directly-typed `ossclip produce …` — already starts with it and
           // is untouched.
-          const args = cmd.args[0] === "produce" ? cmd.args : ["produce", ...cmd.args];
+          let args = cmd.args[0] === "produce" ? [...cmd.args] : ["produce", ...cmd.args];
+          if (customOut) {
+            const filteredArgs: string[] = [];
+            for (let i = 0; i < args.length; i++) {
+              if (args[i] === "-o" || args[i] === "--out") {
+                i++;
+              } else {
+                filteredArgs.push(args[i]!);
+              }
+            }
+            filteredArgs.push("--out", customOut);
+            args = filteredArgs;
+          }
           renderLines = [];
           renderExit = null;
           renderStartedAt = Date.now();

package/src/interactive/picker.ts CHANGED Viewed

@@ -13,7 +13,7 @@ import { binOnPath } from "../llm-detect";
  * this shape exists to prevent.
  */
-export type PickMode = "file" | "folder";
+export type PickMode = "file" | "folder" | "save";
 export interface PickerDeps {
   platform: NodeJS.Platform;
@@ -86,14 +86,19 @@ export function pickerCommand(
     // the alternative and is NOT used: its mkv coverage is unconfirmed, and
     // mkv is in VIDEO_EXTENSIONS.
     const types = VIDEO_EXTENSIONS.map((e) => `"${e}"`).join(",");
-    const clause =
-      mode === "folder"
-        ? 'choose folder with prompt "Pick a folder of clips"'
-        : `choose file with prompt "Pick your video" of type {${types}}`;
-    // startDir is always process.cwd(), never user text — but JSON.stringify
-    // still escapes it, because AppleScript string syntax is close enough to
-    // JSON's that this is the cheap correct thing rather than concatenation.
-    const loc = startDir === undefined ? "" : ` default location POSIX file ${JSON.stringify(startDir)}`;
+    let clause = `choose file with prompt "Pick your video" of type {${types}}`;
+    let loc = "";
+    if (mode === "folder") {
+      clause = 'choose folder with prompt "Pick a folder of clips"';
+      loc = startDir === undefined ? "" : ` default location POSIX file ${JSON.stringify(startDir)}`;
+    } else if (mode === "save") {
+      const defaultName = startDir && !startDir.endsWith("/") ? startDir.split("/").pop()! : "video.ossclip.mp4";
+      const dir = startDir && !startDir.endsWith("/") ? startDir.slice(0, startDir.lastIndexOf("/")) : (startDir ?? "");
+      const dirClause = dir ? ` default location POSIX file ${JSON.stringify(dir)}` : "";
+      clause = `choose file name with prompt "Save rendered video as" default name ${JSON.stringify(defaultName)}${dirClause}`;
+    } else {
+      loc = startDir === undefined ? "" : ` default location POSIX file ${JSON.stringify(startDir)}`;
+    }
     return { bin: "osascript", args: ["-e", `POSIX path of (${clause}${loc})`] };
   }
@@ -102,29 +107,34 @@ export function pickerCommand(
     // `powershell -Command` uses by default, and a deadlock here looks
     // exactly like a hung CLI. `powershell` (5.1, in-box) rather than
     // `pwsh`, which is not installed by default.
-    // startDir is honoured here too, under different property names on the
-    // two dialogs. Without it a Windows user standing in D:\shoots\raw opens
-    // at Desktop while darwin, zenity and kdialog all land in the project
-    // folder — the same flag, three platforms agreeing and one not.
+    const defaultName = startDir ? startDir.split(/[\\/]/).pop()! : "video.ossclip.mp4";
+    const dir = startDir ? startDir.slice(0, Math.max(startDir.lastIndexOf("\\"), startDir.lastIndexOf("/"))) : "";
     const start =
       startDir === undefined
         ? ""
         : mode === "folder"
-          ? // FolderBrowserDialog seeds its start folder from SelectedPath —
-            // the same property it hands the answer back in.
-            `$d.SelectedPath = '${psQuote(startDir)}'; `
-          : `$d.InitialDirectory = '${psQuote(startDir)}'; `;
+          ? `$d.SelectedPath = '${psQuote(startDir)}'; `
+          : mode === "save"
+            ? `$d.InitialDirectory = '${psQuote(dir || startDir)}'; `
+            : `$d.InitialDirectory = '${psQuote(startDir)}'; `;
     const script =
       mode === "folder"
         ? "Add-Type -AssemblyName System.Windows.Forms; " +
           "$d = New-Object System.Windows.Forms.FolderBrowserDialog; " +
           start +
           "if ($d.ShowDialog() -eq [System.Windows.Forms.DialogResult]::OK) { $d.SelectedPath }"
-        : "Add-Type -AssemblyName System.Windows.Forms; " +
-          "$d = New-Object System.Windows.Forms.OpenFileDialog; " +
-          `$d.Filter = 'Video|${VIDEO_EXTENSIONS.map((e) => `*.${e}`).join(";")}|All files|*.*'; ` +
-          start +
-          "if ($d.ShowDialog() -eq [System.Windows.Forms.DialogResult]::OK) { $d.FileName }";
+        : mode === "save"
+          ? "Add-Type -AssemblyName System.Windows.Forms; " +
+            "$d = New-Object System.Windows.Forms.SaveFileDialog; " +
+            `$d.FileName = '${psQuote(defaultName)}'; ` +
+            `$d.Filter = 'Video|${VIDEO_EXTENSIONS.map((e) => `*.${e}`).join(";")}|All files|*.*'; ` +
+            start +
+            "if ($d.ShowDialog() -eq [System.Windows.Forms.DialogResult]::OK) { $d.FileName }"
+          : "Add-Type -AssemblyName System.Windows.Forms; " +
+            "$d = New-Object System.Windows.Forms.OpenFileDialog; " +
+            `$d.Filter = 'Video|${VIDEO_EXTENSIONS.map((e) => `*.${e}`).join(";")}|All files|*.*'; ` +
+            start +
+            "if ($d.ShowDialog() -eq [System.Windows.Forms.DialogResult]::OK) { $d.FileName }";
     return { bin: "powershell", args: ["-NoProfile", "-STA", "-Command", script] };
   }
@@ -134,13 +144,18 @@ export function pickerCommand(
   if (d.hasBin("zenity")) {
     const args = [
       "--file-selection",
-      mode === "folder" ? "--title=Pick a folder of clips" : "--title=Pick your video",
+      mode === "folder"
+        ? "--title=Pick a folder of clips"
+        : mode === "save"
+          ? "--title=Save rendered video as"
+          : "--title=Pick your video",
     ];
     if (mode === "folder") args.push("--directory");
+    else if (mode === "save") args.push("--save", "--confirm-overwrite", `--file-filter=Video | ${globs()}`, "--file-filter=All files | *");
     else args.push(`--file-filter=Video | ${globs()}`, "--file-filter=All files | *");
-    // The trailing slash is what makes zenity read this as a starting
-    // DIRECTORY rather than a pre-filled filename.
-    if (startDir !== undefined) args.push(`--filename=${startDir}/`);
+    if (startDir !== undefined) {
+      args.push(mode === "save" ? `--filename=${startDir}` : `--filename=${startDir}/`);
+    }
     return { bin: "zenity", args };
   }
@@ -149,6 +164,12 @@ export function pickerCommand(
     // filter here is an error, not an ignored argument.
     return { bin: "kdialog", args: ["--getexistingdirectory", startDir ?? "."] };
   }
+  if (mode === "save") {
+    return {
+      bin: "kdialog",
+      args: ["--getsavefilename", startDir ?? ".", `Video files(${globs()})`],
+    };
+  }
   return {
     bin: "kdialog",
     args: ["--getopenfilename", startDir ?? ".", `Video files(${globs()})`],