ossclip 0.1.20 → 0.1.21

package/README.md

@@ -28,7 +28,7 @@ ossclip produce input.mp4 -o out.mp4
 ossclip produce podcast.mp4 --produce --clip 60 -o clip.mp4
 
 # Keep your own editor: export the planned cuts as labelled markers, no render, no LLM
-ossclip analyse input.mp4          # writes input.fcpxml — imports into Resolve & Premiere
+ossclip analyze input.mp4 --format premiere-xml   # Premiere Pro; resolve-edl for Resolve, fcpxml for FCP
 
 # Edit what it produced — direct manipulation, in the browser
 ossclip edit "<work directory>"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ossclip",
-  "version": "0.1.20",
+  "version": "0.1.21",
   "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.21",
+    "@ossclip/core": "0.1.21",
+    "@ossclip/scenes": "0.1.21"
   },
   "homepage": "https://github.com/AhsanAyaz/ossclip#readme",
   "bugs": {

package/src/{analyse.ts → analyze.ts}

@@ -4,14 +4,17 @@ import { z } from "zod/v4";
 import {
   ProductionSchema,
   buildFcpxmlMarkers,
+  buildPremiereXmlMarkers,
+  buildResolveMarkerEdl,
+  keptPauses,
   type CleanupLevel,
 } from "@ossclip/core";
 import { produce } from "./produce";
 import type { PhaseTimings } from "./phase-timing";
 
 /**
- * `ossclip analyse` (next-directions §2–3; design doc
- * 2026-08-12-analyse-fcpxml-export-design.md): the analyser without the
+ * `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
@@ -22,16 +25,30 @@ import type { PhaseTimings } from "./phase-timing";
  * 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"]);
+export const ExportFormatSchema = z.enum(["fcpxml", "resolve-edl", "premiere-xml"]);
 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",
+};
+
 /** Same shape as produce's `defaultOutPath`: beside the input, new extension. */
 export function defaultExportPath(input: string, format: ExportFormat): string {
-  return input.replace(/(\.[^.]+)?$/, `.${format}`);
+  return input.replace(/(\.[^.]+)?$/, `.${FORMAT_EXTENSIONS[format]}`);
 }
 
-export interface AnalyseOptions {
+export interface AnalyzeOptions {
   cleanup: CleanupLevel;
   format: ExportFormat;
   out?: string;
@@ -46,10 +63,14 @@ export interface AnalyseOptions {
   sortExplicit?: boolean;
 }
 
-export interface AnalyseResult {
+export interface AnalyzeResult {
   workdir: string;
   outPath: 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;
 }
@@ -61,10 +82,10 @@ export interface AnalyseResult {
  * 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 runAnalyse(
+export async function runAnalyze(
   inputArg: string,
-  opts: AnalyseOptions,
-): Promise<AnalyseResult> {
+  opts: AnalyzeOptions,
+): Promise<AnalyzeResult> {
   const result = await produce(inputArg, {
     cleanup: opts.cleanup,
     transcript: opts.transcript,
@@ -83,18 +104,34 @@ export async function runAnalyse(
   const production = ProductionSchema.parse(
     JSON.parse(await readFile(join(result.workdir, "production.json"), "utf8")),
   );
-  const xml = buildFcpxmlMarkers(production);
+  // §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);
   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));
-  await writeFile(outPath, xml);
+  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} marker${markerCount === 1 ? "" : "s"} — ` +
-      "import into Resolve/Premiere and review before cutting)",
+    `✓ ${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/program.ts

@@ -6,7 +6,7 @@ import { z } from "zod/v4";
 import { CleanupLevelSchema, SceneComponentIdSchema } from "@ossclip/core";
 import { STUDIO_ENTRY } from "@ossclip/renderer";
 import { loadEnvFiles } from "./env";
-import { ExportFormatSchema, runAnalyse } from "./analyse";
+import { ExportFormatSchema, runAnalyze } from "./analyze";
 import { phaseBucketProps } from "./phase-timing";
 import { produce } from "./produce";
 // The one interactive import that is STATIC rather than `await import()`: the
@@ -536,14 +536,22 @@ export function buildProgram(): Command {
     });
 
   program
-    .command("analyse")
-    .alias("analyze")
+    // American spelling is primary (house style, 2026-08-12); the British
+    // alias stays because a command someone has already learned must not
+    // become an "unknown command" over an s/z.
+    .command("analyze")
+    .alias("analyse")
     .description(
-      "analyse a take and export the planned cuts as labelled NLE markers — no render, no LLM " +
+      "analyze a take and export the planned cuts as labelled NLE markers — no render, no LLM " +
         "(FCPXML imports into Resolve and Premiere; review the markers, then cut in your own editor)",
     )
     .argument("<input>", "input video file (or a folder of clips)")
-    .option("--format <format>", "export format: fcpxml", "fcpxml")
+    .option(
+      "--format <format>",
+      "export format: fcpxml (Premiere) | resolve-edl (Resolve coloured timeline markers — " +
+        "its fcpxml import drops markers)",
+      "fcpxml",
+    )
     .option("--out <path>", "export file path (default: <input>.<format>)")
     .option("--cleanup <level>", "exact | light | standard | aggressive", "standard")
     .option("--transcript <path>", "inject a transcript JSON instead of running whisper")
@@ -570,7 +578,7 @@ export function buildProgram(): Command {
       // error naming the flag, never silently export a different file.
       const format = ExportFormatSchema.parse(opts.format);
       try {
-        const result = await runAnalyse(input, {
+        const result = await runAnalyze(input, {
           cleanup,
           format,
           out: opts.out,
@@ -589,16 +597,17 @@ export function buildProgram(): Command {
         });
         // Counts, buckets and names only (§134) — the format is an enum name,
         // never a path; per-phase buckets ride along like produce's.
-        telemetry.record("analyse_completed", {
+        telemetry.record("analyze_completed", {
           format,
           cleanup_level: cleanup,
           source_duration_bucket: durationBucket(result.sourceDurationSec),
           markers: result.markerCount,
+          kept_pauses: result.pauseCount,
           ...phaseBucketProps(result.phaseTimings),
         });
       } catch (err) {
         // Constructor name only, like produce_failed: messages quote paths.
-        telemetry.record("analyse_failed", {
+        telemetry.record("analyze_failed", {
           error_class: err instanceof Error ? err.constructor.name : "NonError",
         });
         throw err;