video-editing 1.3.1

package/dist/index.js

@@ -0,0 +1,300 @@
+#!/usr/bin/env node
+import {
+  CAPABILITIES,
+  COMPOSE_AUDIO_SRC,
+  COMPOSE_ENTRY,
+  COMPOSE_HEIGHT,
+  COMPOSE_VIDEO_SRC,
+  COMPOSE_WIDTH,
+  DEFAULT_DESILENCE,
+  PRESETS,
+  agentizePrompt,
+  artifactPaths,
+  autoGradeForClip,
+  checkCapabilities,
+  compileTimeline,
+  composeCounts,
+  composeHtml,
+  computeEnvelope,
+  configDir,
+  configEnvPath,
+  cutBoundaries,
+  decideGradeFilter,
+  desilenceEdl,
+  detectSilences,
+  diagnosticsPath,
+  duplicatedPhrase,
+  duplicatedPhrases,
+  duplicatedSpans,
+  edlPath,
+  ensureTranscribed,
+  ensureVerticalMaster,
+  findPhrase,
+  fuzzySuggestions,
+  gatherCompileCtx,
+  generateQcImages,
+  getPreset,
+  learnedEditingGuardrails,
+  loadApiKey,
+  loadTimeline,
+  loadWords,
+  loadWordsBySource,
+  normalizePhrase,
+  normalizeToken,
+  packTranscripts,
+  parseSilenceDetect,
+  parseTimeline,
+  planPath,
+  readEdl,
+  render,
+  resolvePhrase,
+  screenTakes,
+  sha256File,
+  silenceDetectArgs,
+  statusPayload,
+  straddlingGap,
+  tightenRange,
+  tightenRanges,
+  timelineFromEdl,
+  timelineHash,
+  timelineJsonPath,
+  timelineV2Schema,
+  timelineView,
+  transcribeOne,
+  transcriptFileForSource,
+  updateCaptionsBlock,
+  usesFromDoc,
+  validateTimeline,
+  verify,
+  wordStream,
+  writeAgentManifest,
+  writeBoundaries,
+  writeCompileArtifacts,
+  writeCoverage,
+  writeSilencePrompt,
+  writeTranscriptArtifacts,
+  writeVideoEditingPrompt,
+  writeWarningsFromReview,
+  writeWordDump
+} from "./chunk-63HIQBDT.js";
+import {
+  CommandError,
+  DEFAULT_EDIT_ROOT,
+  VIDEO_EXTS,
+  defaultJobDir,
+  displayedDimensions,
+  ffprobe,
+  initJob,
+  isoNow,
+  loadJob,
+  mediaDuration,
+  pyFixed,
+  pyFixedPad,
+  pyRound,
+  pySpacePad,
+  requireFfmpeg,
+  resolveJob,
+  rotationDegrees,
+  run,
+  runSync,
+  shown,
+  slugify,
+  sourceFromJob,
+  transcriptPath,
+  videoStream
+} from "./chunk-CU3NBKB4.js";
+
+// src/transcribe-batch.ts
+import { existsSync, mkdirSync, readdirSync, statSync } from "fs";
+import { basename, extname, join } from "path";
+import pLimit from "p-limit";
+var VIDEO_EXTS2 = /* @__PURE__ */ new Set([
+  ".mp4",
+  ".MP4",
+  ".mov",
+  ".MOV",
+  ".mkv",
+  ".MKV",
+  ".avi",
+  ".AVI",
+  ".m4v"
+]);
+function findVideos(videosDir) {
+  const entries = readdirSync(videosDir).map((name) => join(videosDir, name)).filter((p) => {
+    let isFile;
+    try {
+      isFile = statSync(p).isFile();
+    } catch {
+      return false;
+    }
+    return isFile && VIDEO_EXTS2.has(extname(p));
+  });
+  entries.sort();
+  return entries;
+}
+function stemOf(p) {
+  return basename(p, extname(p));
+}
+async function transcribeBatch(videosDir, opts = {}) {
+  const { workers = 4, language, numSpeakers, apiKey } = opts;
+  if (!existsSync(videosDir) || !statSync(videosDir).isDirectory()) {
+    throw new Error(`not a directory: ${videosDir}`);
+  }
+  const editDir = opts.editDir ?? join(videosDir, "edit");
+  mkdirSync(join(editDir, "transcripts"), { recursive: true });
+  const videos = findVideos(videosDir);
+  if (videos.length === 0) {
+    throw new Error(`no videos found in ${videosDir}`);
+  }
+  const alreadyCached = videos.filter(
+    (v) => existsSync(join(editDir, "transcripts", `${stemOf(v)}.json`))
+  );
+  const cachedSet = new Set(alreadyCached);
+  const pending = videos.filter((v) => !cachedSet.has(v));
+  console.error(
+    `found ${videos.length} videos (${alreadyCached.length} cached, ${pending.length} to transcribe)`
+  );
+  if (pending.length === 0) {
+    console.error("nothing to do");
+    return { videos, cached: alreadyCached, transcribed: [], errors: [] };
+  }
+  console.error(`transcribing ${pending.length} files with ${workers} parallel workers`);
+  const t0 = Date.now();
+  const errors = [];
+  const transcribed = [];
+  const limit = pLimit(workers);
+  await Promise.all(
+    pending.map(
+      (v) => limit(async () => {
+        try {
+          const out = await transcribeOne(v, {
+            editDir,
+            language,
+            numSpeakers,
+            apiKey,
+            verbose: false
+          });
+          transcribed.push(out);
+          console.error(`  + ${stemOf(v)}  ->  ${basename(out)}`);
+        } catch (e) {
+          const message = String(e instanceof Error ? e.message : e);
+          errors.push({ video: v, message });
+          console.error(`  x ${stemOf(v)}  FAILED: ${message}`);
+        }
+      })
+    )
+  );
+  const dt = (Date.now() - t0) / 1e3;
+  console.error(`
+done in ${dt.toFixed(1)}s`);
+  if (errors.length) {
+    console.error(`${errors.length} failures:`);
+    for (const { video, message } of errors) {
+      console.error(`  ${basename(video)}: ${message}`);
+    }
+  }
+  return { videos, cached: alreadyCached, transcribed, errors };
+}
+export {
+  CAPABILITIES,
+  COMPOSE_AUDIO_SRC,
+  COMPOSE_ENTRY,
+  COMPOSE_HEIGHT,
+  COMPOSE_VIDEO_SRC,
+  COMPOSE_WIDTH,
+  CommandError,
+  DEFAULT_DESILENCE,
+  DEFAULT_EDIT_ROOT,
+  PRESETS,
+  VIDEO_EXTS,
+  agentizePrompt,
+  artifactPaths,
+  autoGradeForClip,
+  checkCapabilities,
+  compileTimeline,
+  composeCounts,
+  composeHtml,
+  computeEnvelope,
+  configDir,
+  configEnvPath,
+  cutBoundaries,
+  decideGradeFilter,
+  defaultJobDir,
+  desilenceEdl,
+  detectSilences,
+  diagnosticsPath,
+  displayedDimensions,
+  duplicatedPhrase,
+  duplicatedPhrases,
+  duplicatedSpans,
+  edlPath,
+  ensureTranscribed,
+  ensureVerticalMaster,
+  ffprobe,
+  findPhrase,
+  fuzzySuggestions,
+  gatherCompileCtx,
+  generateQcImages,
+  getPreset,
+  initJob,
+  isoNow,
+  learnedEditingGuardrails,
+  loadApiKey,
+  loadJob,
+  loadTimeline,
+  loadWords,
+  loadWordsBySource,
+  mediaDuration,
+  normalizePhrase,
+  normalizeToken,
+  packTranscripts,
+  parseSilenceDetect,
+  parseTimeline,
+  planPath,
+  pyFixed,
+  pyFixedPad,
+  pyRound,
+  pySpacePad,
+  readEdl,
+  render,
+  requireFfmpeg,
+  resolveJob,
+  resolvePhrase,
+  rotationDegrees,
+  run,
+  runSync,
+  screenTakes,
+  sha256File,
+  shown,
+  silenceDetectArgs,
+  slugify,
+  sourceFromJob,
+  statusPayload,
+  straddlingGap,
+  tightenRange,
+  tightenRanges,
+  timelineFromEdl,
+  timelineHash,
+  timelineJsonPath,
+  timelineV2Schema,
+  timelineView,
+  transcribeBatch,
+  transcribeOne,
+  transcriptFileForSource,
+  transcriptPath,
+  updateCaptionsBlock,
+  usesFromDoc,
+  validateTimeline,
+  verify,
+  videoStream,
+  wordStream,
+  writeAgentManifest,
+  writeBoundaries,
+  writeCompileArtifacts,
+  writeCoverage,
+  writeSilencePrompt,
+  writeTranscriptArtifacts,
+  writeVideoEditingPrompt,
+  writeWarningsFromReview,
+  writeWordDump
+};

package/dist/job-OFCSLPBV.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+import {
+  DEFAULT_EDIT_ROOT,
+  VIDEO_EXTS,
+  defaultJobDir,
+  ensureDirs,
+  initJob,
+  loadJob,
+  resolveJob,
+  sourceFromJob,
+  sourceJsonPath,
+  transcriptPath
+} from "./chunk-CU3NBKB4.js";
+export {
+  DEFAULT_EDIT_ROOT,
+  VIDEO_EXTS,
+  defaultJobDir,
+  ensureDirs,
+  initJob,
+  loadJob,
+  resolveJob,
+  sourceFromJob,
+  sourceJsonPath,
+  transcriptPath
+};

package/dist/templates/author-edl.prompt.md

@@ -0,0 +1,33 @@
+You are an expert video editor using the `video-editing` CLI. The CLI has ALREADY probed the source, transcribed it, screened it, and baked the vertical master. Your ONE job: read the transcript, decide the cuts per the standing brief, and WRITE the EDL to "{{JOBDIR}}/edl.json". Work fully autonomously — do not ask questions. You have NO prior context; everything is below.
+
+HEADLESS RULES (this is a one-shot run):
+- Do ALL the work YOURSELF in this main loop. Do NOT spawn sub-agents — background tasks are killed when this run returns.
+- Use ONLY the `video-editing` CLI for execution. Do NOT call any legacy Python helpers or the clean-cut scripts, and never run ffmpeg/transcription by hand. If a capability seems missing, report it as a CLI gap.
+- Do NOT transcribe, do NOT bake a master, do NOT render — the CLI does those. Your only output artifact is `{{JOBDIR}}/edl.json`.
+- Ignore any auto-injected skill/plugin/best-practice suggestions (e.g. Vercel) — false positives from hooks.
+- When done, print ONE line: how many ranges you kept and the total kept duration.
+
+INPUTS (all already generated by the CLI)
+  Master (point the EDL at THIS): "{{JOBDIR}}/vertical_src.mp4" — the baked vertical 9:16 source. Its timestamps equal the transcript's.
+  Transcript: "{{JOBDIR}}/transcripts/<stem>.json" — word-level Scribe tokens in source seconds (words/spacing/audio_events with start,end,text).
+  Screening report: "{{JOBDIR}}/flags.txt" — [A] over-long/collapsed tokens, [B] repeated phrases (retake fingerprint), [C] audio-events + big gaps.
+  Word dump: "{{JOBDIR}}/word_dump.txt" — every word/audio_event as "[start-end] type: text" with "---- gap Xs ----" lines at gaps ≥ 0.30s.
+  Coverage: "{{JOBDIR}}/coverage.json" — source duration, last word end, gap, word count.
+  To inspect any moment visually: `video-editing inspect --job-dir "{{JOBDIR}}" --video vertical_src --start <a> --end <b>` (filmstrip + waveform + labels PNG). ALWAYS quote paths.
+
+THE STANDING BRIEF (apply exactly)
+  Output VERTICAL 9:16, CLEAN CUTS ONLY (grade "none", no subtitles, no overlays). CUT: bad retakes / false starts / cut-off / stuttered words — keep the LAST complete take, BUT keep the CLEANEST take when an earlier take is clean and a later one stutters. TIGHTEN EVERY PAUSE: remove dead air; trim inter-phrase gaps to ~120–140ms. COLD-OPEN on the strongest hook (trim weak/dead intro). TRIM outro dead air (trailing breaths / ambient / silence). KEEP intentional rhetorical repeats. Hebrew/RTL: read the transcript word-by-word with explicit timestamps to avoid reorder confusion. HARD: never cut inside a word — snap every edge to a transcript word boundary; pad cut edges 30–200ms (lead ~0.05s, trail ~0.08s; tighter ~0.03–0.05s at retake joins, staying inside the silence); the renderer adds 30ms audio fades so tight pads are safe.
+
+STEPS
+1. SCREEN first (Scribe hides retakes in over-long/dropped tokens): read "{{JOBDIR}}/flags.txt" — resolve every [A], judge every [B] (retake vs intentional). Confirm coverage from "{{JOBDIR}}/coverage.json" (last word ends within ~2s of media duration).
+2. READ the full word-level transcript via "{{JOBDIR}}/word_dump.txt". Then THINK HARD and list, with EXACT timestamps: every bad retake/false-start/stutter (and which take to KEEP), every silence/dead-air (head/inter-phrase/outro), the cold-open point (strongest hook), and the intentional repeats to KEEP. When transcript text and audio seem to disagree, run `video-editing inspect` on that window and read the PNG before deciding.
+3. WRITE "{{JOBDIR}}/edl.json":
+   {"version":1, "sources":{"SRC":"{{JOBDIR}}/vertical_src.mp4"}, "grade":"none", "ranges":[ {"source":"SRC","start":N,"end":N,"beat":"...","quote":"...","reason":"..."}, ... ], "overlays":[], "total_duration_s":N}
+   Each range = a KEEP segment with tightened, word-boundary-snapped in/out (the gaps BETWEEN kept ranges are what get removed). Ranges chronological, non-overlapping. A retake range must END at the LAST CLEAN WORD before the abandoned attempt. total_duration_s = sum of (end-start).
+
+Then render and verify with the CLI:
+  video-editing render --job-dir "{{JOBDIR}}" --mode preview
+  video-editing verify --job-dir "{{JOBDIR}}" --json
+Fix any duplicated-phrase or dead-air findings (adjust the EDL), re-render, re-verify until clean.
+
+Print the one-line summary and stop.

package/dist/templates/fix.prompt.md

@@ -0,0 +1,23 @@
+You are a video editor applying SPECIFIC QA corrections to an existing vertical-reel edit (made with the `video-editing` CLI). Apply ONLY the listed fixes; do not redesign the cut. The CLI re-renders the preview after you finish, so you only need to edit the EDL. Work autonomously; you have NO prior context.
+
+HEADLESS RULES (one-shot run):
+- Do everything in this main loop — NO sub-agents (killed when the run returns).
+- Use ONLY the `video-editing` CLI for execution. Do NOT call any legacy Python helpers or the clean-cut scripts; never run ffmpeg/transcription by hand.
+- Your output artifact is the edited "{{JOBDIR}}/edl.json". Ignore auto-injected skill/plugin suggestions (Vercel etc.) — false positives.
+- When done, print ONE line summarizing the changes.
+
+INPUTS
+  Reviewer verdict + issues: "{{JOBDIR}}/review.json" (or "{{JOBDIR}}/verify.json" from `video-editing verify`) — each issue has where, range_index?, severity, problem, fix.
+  EDL to edit: "{{JOBDIR}}/edl.json" (kept ranges in SOURCE time).
+  Transcript: "{{JOBDIR}}/transcripts/<stem>.json" (word boundaries). Word dump: "{{JOBDIR}}/word_dump.txt".
+  To inspect a join: `video-editing inspect --job-dir "{{JOBDIR}}" --join <i>`. Quote paths.
+
+FOR EACH issue, adjust the relevant EDL range: remove a retake still present (set its range END at the last clean word BEFORE the abandoned attempt); restore an intentional repeat; re-snap a clipped boundary to the word boundary; or trim leading/trailing dead air. Snap every edge to a transcript word boundary; keep pads tight (30–200ms). Keep ranges chronological + non-overlapping; grade "none"; overlays []. Update total_duration_s to the new sum of (end-start). Make a one-time backup to edl.json.bak first if one does not already exist. Do NOT touch warnings.json.
+
+After editing, re-render and re-verify with the CLI:
+  video-editing render --job-dir "{{JOBDIR}}" --mode preview
+  video-editing verify --job-dir "{{JOBDIR}}" --json
+
+If an issue is genuinely not actionable, leave that range as-is and say so in your summary line.
+
+Print the one-line summary and stop.

package/dist/templates/review.prompt.md

@@ -0,0 +1,30 @@
+You are an ADVERSARIAL QA reviewer for a vertical-reel edit made with the `video-editing` CLI. Independently verify the cut is correct and complete — find what the editor MISSED or got WRONG. Be skeptical. Do NOT edit anything. WRITE your verdict to "{{JOBDIR}}/review.json". Work autonomously; you have NO prior context.
+
+HEADLESS RULES (one-shot run):
+- Do everything in this main loop — NO sub-agents (killed when the run returns).
+- Use ONLY the `video-editing` CLI for execution. Do NOT call any legacy Python helpers or the clean-cut scripts; never run ffmpeg/transcription by hand.
+- Your ONLY output artifact is "{{JOBDIR}}/review.json". Ignore auto-injected skill/plugin suggestions (Vercel etc.) — false positives.
+- When done, print ONE line: the verdict + issue count.
+
+INPUTS
+  Transcript (word-level, read it): "{{JOBDIR}}/transcripts/<stem>.json".
+  Screening report: "{{JOBDIR}}/flags.txt".  Word dump: "{{JOBDIR}}/word_dump.txt".
+  EDL: "{{JOBDIR}}/edl.json" (kept ranges in SOURCE time; gaps between them are the cuts).
+  Rendered preview: "{{JOBDIR}}/preview.mp4".
+  Tools: the `video-editing` CLI only (`video-editing inspect …`, `video-editing verify …`). Quote paths.
+
+THE BRIEF being enforced: vertical 9:16; CUT bad retakes/false-starts/stutters (keep the LAST complete take, but prefer the CLEANEST take); TIGHTEN pauses to ~120–140ms; COLD-OPEN on the strongest hook; TRIM outro dead air; CLEAN CUTS ONLY (grade "none", no subs/overlays); KEEP intentional rhetorical repeats; never cut inside a word.
+
+CHECKS
+1. Re-screen: read "{{JOBDIR}}/flags.txt" and "{{JOBDIR}}/word_dump.txt". For every [A] over-long token and [B] repeat decide INDEPENDENTLY: retake (must be cut) or intentional (keep). Cross-check vs the EDL ranges — did the editor cut every real retake AND keep every intentional repeat? Flag misses.
+2. Verify EDL vs transcript: each kept range starts/ends on a word boundary (no mid-word, no false-start/fragment word included); ranges chronological + non-overlapping; cold open is the strongest hook; grade "none"; no overlays/subs.
+3. CONTENT-VERIFY the rendered preview: run `video-editing verify --job-dir "{{JOBDIR}}" --json`. It re-transcribes the preview at every join (healing disabled) and reports duplicated phrases across joins (= a retake left in) and over-long gaps (= dead air not tightened). Treat any error finding as a real defect. To eyeball a join, run `video-editing inspect --job-dir "{{JOBDIR}}" --join <i>` and READ the PNG (clipped word, leftover false-start syllable, audio pop, broken frame?).
+4. Coverage: preview STARTS on the hook (no leading dead air) and ENDS on the CTA (no trailing footsteps/ambient/silence)?
+
+WRITE "{{JOBDIR}}/review.json" (use a temp file + rename) as:
+  {"verdict":"clean"|"needs-fixes",
+   "issues":[ {"where":"<timestamp/range>","range_index":<edl ranges[] index if applicable>,"severity":"error"|"warning"|"info","problem":"<what>","fix":"<the concrete EDL change>"} ],
+   "confidence":"<one line>"}
+A real retake left in / an intentional repeat wrongly cut / a clipped word at a join / leading-or-trailing dead air ⇒ "needs-fixes" (severity "error"). Minor taste calls are NOT issues; if none, verdict "clean" with issues [].
+
+Print the one-line summary and stop.

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "video-editing",
+  "version": "1.3.1",
+  "description": "Standalone TypeScript library + CLI for editing talking-head reels: transcribe, screen, cut (EDL), render vertical 9:16, QC, content-verify.",
+  "type": "module",
+  "license": "SEE LICENSE IN LICENSE",
+  "author": "Itay Elgazar",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ItayElgazar/clipready.git"
+  },
+  "homepage": "https://github.com/ItayElgazar/clipready#readme",
+  "keywords": [
+    "video-editing",
+    "video",
+    "cli",
+    "agents",
+    "ai",
+    "talking-head",
+    "reels",
+    "shorts",
+    "captions",
+    "transcription",
+    "ffmpeg",
+    "edl",
+    "clipready"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "bin": {
+    "video-editing": "dist/cli.js"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "skills",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "prepublishOnly": "pnpm build"
+  },
+  "dependencies": {
+    "@napi-rs/canvas": "^0.1.65",
+    "commander": "^12.1.0",
+    "p-limit": "^6.1.0",
+    "zod": "^3"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "tsup": "^8.3.5",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.2",
+    "vitest": "^2.1.8"
+  }
+}