video-editing 1.3.1

package/dist/chunk-CU3NBKB4.js

@@ -0,0 +1,307 @@
+#!/usr/bin/env node
+
+// src/job.ts
+import { existsSync, mkdirSync as mkdirSync2, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join, parse as parsePath, resolve as resolvePath } from "path";
+
+// src/ffmpeg.ts
+import { spawn, spawnSync } from "child_process";
+import { createWriteStream, mkdirSync } from "fs";
+import { dirname } from "path";
+function shquote(value) {
+  if (value.length === 0) return "''";
+  if (/^[A-Za-z0-9_@%+=:,./-]+$/.test(value)) return value;
+  return "'" + value.replace(/'/g, `'"'"'`) + "'";
+}
+function shown(cmd) {
+  return cmd.map(shquote).join(" ");
+}
+var CommandError = class extends Error {
+  constructor(message, code, result) {
+    super(message);
+    this.code = code;
+    this.result = result;
+    this.name = "CommandError";
+  }
+  code;
+  result;
+};
+function run(cmd, opts = {}) {
+  const { capture = false, stdoutPath, cwd, check = true, echo = true } = opts;
+  if (echo) process.stderr.write(`+ ${shown(cmd)}
+`);
+  return new Promise((resolve, reject) => {
+    const [bin, ...args] = cmd;
+    if (!bin) {
+      reject(new Error("empty command"));
+      return;
+    }
+    let fileStream;
+    const outChunks = [];
+    const errChunks = [];
+    const stdio = ["ignore", "pipe", "pipe"];
+    if (!capture && !stdoutPath) {
+      stdio[1] = "inherit";
+      stdio[2] = "inherit";
+    }
+    if (stdoutPath) {
+      mkdirSync(dirname(stdoutPath), { recursive: true });
+      fileStream = createWriteStream(stdoutPath, { encoding: "utf8" });
+    }
+    const child = spawn(bin, args, { cwd, stdio });
+    child.stdout?.on("data", (d) => {
+      if (fileStream) fileStream.write(d);
+      else if (capture) outChunks.push(d);
+    });
+    child.stderr?.on("data", (d) => {
+      if (fileStream) fileStream.write(d);
+      else if (capture) errChunks.push(d);
+    });
+    child.on("error", (err) => reject(err));
+    child.on("close", (code) => {
+      if (fileStream) fileStream.end();
+      const result = {
+        code: code ?? -1,
+        stdout: Buffer.concat(outChunks).toString("utf8"),
+        stderr: Buffer.concat(errChunks).toString("utf8")
+      };
+      if (check && result.code !== 0) {
+        if (capture) {
+          if (result.stdout) process.stderr.write(result.stdout + "\n");
+          if (result.stderr) process.stderr.write(result.stderr + "\n");
+        }
+        reject(new CommandError(`command failed with exit ${result.code}: ${shown(cmd)}`, result.code, result));
+        return;
+      }
+      resolve(result);
+    });
+  });
+}
+function runSync(cmd, opts = {}) {
+  const { check = true, echo = true } = opts;
+  if (echo) process.stderr.write(`+ ${shown(cmd)}
+`);
+  const [bin, ...args] = cmd;
+  const proc = spawnSync(bin, args, { encoding: "utf8", maxBuffer: 256 * 1024 * 1024 });
+  const result = { code: proc.status ?? -1, stdout: proc.stdout ?? "", stderr: proc.stderr ?? "" };
+  if (check && result.code !== 0) {
+    throw new CommandError(`command failed with exit ${result.code}: ${shown(cmd)}`, result.code, result);
+  }
+  return result;
+}
+var FFPROBE_ENTRIES = "stream=index,codec_type,codec_name,width,height,r_frame_rate,avg_frame_rate,duration,color_transfer:stream_side_data=rotation:format=duration,size,format_name";
+async function ffprobe(path) {
+  const res = await run(
+    ["ffprobe", "-v", "error", "-show_entries", FFPROBE_ENTRIES, "-of", "json", path],
+    { capture: true }
+  );
+  try {
+    return JSON.parse(res.stdout || "{}");
+  } catch (e) {
+    throw new Error(`ffprobe returned invalid JSON for ${path}: ${e.message}`);
+  }
+}
+function videoStream(probe) {
+  for (const s of probe.streams ?? []) {
+    if (s.codec_type === "video") return s;
+  }
+  throw new Error("no video stream found");
+}
+async function mediaDuration(path) {
+  const probe = await ffprobe(path);
+  const d = probe.format?.duration;
+  const n = d ? Number(d) : 0;
+  return Number.isFinite(n) ? n : 0;
+}
+function requireFfmpeg() {
+  for (const bin of ["ffmpeg", "ffprobe"]) {
+    const r = spawnSync(bin, ["-version"], { encoding: "utf8" });
+    if (r.error) {
+      throw new Error("ffmpeg and ffprobe must be on PATH");
+    }
+  }
+}
+
+// src/probe.ts
+function rotationDegrees(stream) {
+  for (const sideData of stream.side_data_list ?? []) {
+    if (sideData && "rotation" in sideData) {
+      const v = Number(sideData.rotation);
+      return Number.isFinite(v) ? Math.trunc(v) : 0;
+    }
+  }
+  const tags = stream.tags ?? {};
+  if ("rotate" in tags) {
+    const v = Number(tags.rotate);
+    return Number.isFinite(v) ? Math.trunc(v) : 0;
+  }
+  return 0;
+}
+function displayedDimensions(stream) {
+  const width = Math.trunc(Number(stream.width ?? 0)) || 0;
+  const height = Math.trunc(Number(stream.height ?? 0)) || 0;
+  const rotation = rotationDegrees(stream);
+  if (Math.abs(rotation) % 180 === 90) {
+    return [height, width, rotation];
+  }
+  return [width, height, rotation];
+}
+
+// src/util.ts
+function slugify(value) {
+  let slug = value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  slug = slug.replace(/-{2,}/g, "-");
+  return slug || "job";
+}
+function isoNow() {
+  return (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "+00:00");
+}
+function pyRound(x, ndigits = 0) {
+  if (!Number.isFinite(x)) return x;
+  const m = Math.pow(10, ndigits);
+  const scaled = x * m;
+  const floor = Math.floor(scaled);
+  const diff = scaled - floor;
+  const EPS = 1e-9;
+  let rounded;
+  if (Math.abs(diff - 0.5) < EPS) {
+    rounded = floor % 2 === 0 ? floor : floor + 1;
+  } else {
+    rounded = Math.round(scaled);
+  }
+  return rounded / m;
+}
+function pyFixed(x, prec) {
+  if (!Number.isFinite(x)) return String(x);
+  const neg = x < 0 || Object.is(x, -0);
+  const a = Math.abs(x);
+  const m = Math.pow(10, prec);
+  const scaled = a * m;
+  const floor = Math.floor(scaled);
+  const diff = scaled - floor;
+  const EPS = 1e-9;
+  let rounded;
+  if (Math.abs(diff - 0.5) < EPS) {
+    rounded = floor % 2 === 0 ? floor : floor + 1;
+  } else {
+    rounded = Math.round(scaled);
+  }
+  let s = (rounded / m).toFixed(prec);
+  if (neg && Number(s) !== 0) s = "-" + s;
+  return s;
+}
+function pyFixedPad(x, width, prec) {
+  const body = pyFixed(x, prec);
+  if (body.length >= width) return body;
+  const neg = body.startsWith("-");
+  if (neg) {
+    return "-" + body.slice(1).padStart(width - 1, "0");
+  }
+  return body.padStart(width, "0");
+}
+function pySpacePad(x, width, prec) {
+  return pyFixed(x, prec).padStart(width, " ");
+}
+
+// src/job.ts
+var DEFAULT_EDIT_ROOT = join(homedir(), "Downloads", "edit");
+var VIDEO_EXTS = /* @__PURE__ */ new Set([".mp4", ".MP4", ".mov", ".MOV", ".mkv", ".MKV", ".avi", ".AVI", ".m4v"]);
+function defaultJobDir(source) {
+  return join(DEFAULT_EDIT_ROOT, `job_${slugify(parsePath(source).name)}`);
+}
+function sourceJsonPath(jobDir) {
+  return join(jobDir, "source.json");
+}
+function transcriptPath(jobDir, stem) {
+  return join(jobDir, "transcripts", `${stem}.json`);
+}
+function ensureDirs(jobDir) {
+  for (const name of ["transcripts", "qc", "logs", "prompts"]) {
+    mkdirSync2(join(jobDir, name), { recursive: true });
+  }
+}
+async function initJob(source, jobDir, opts = {}) {
+  const src = resolvePath(source);
+  if (!existsSync(src)) throw new Error(`source not found: ${src}`);
+  const ext = parsePath(src).ext;
+  if (!VIDEO_EXTS.has(ext)) process.stderr.write(`warning: unusual video extension: ${ext}
+`);
+  const dir = resolvePath(jobDir ?? defaultJobDir(src));
+  if (existsSync(sourceJsonPath(dir)) && !opts.force) {
+    ensureDirs(dir);
+    return dir;
+  }
+  mkdirSync2(dir, { recursive: true });
+  ensureDirs(dir);
+  const probe = await ffprobe(src);
+  const stream = videoStream(probe);
+  const [displayW, displayH, rotation] = displayedDimensions(stream);
+  const payload = {
+    created: isoNow(),
+    source: src,
+    stem: parsePath(src).name,
+    job_dir: dir,
+    duration_s: Number(probe.format?.duration ?? 0) || 0,
+    stored_width: Math.trunc(Number(stream.width ?? 0)) || 0,
+    stored_height: Math.trunc(Number(stream.height ?? 0)) || 0,
+    display_width: displayW,
+    display_height: displayH,
+    rotation,
+    probe
+  };
+  writeFileSync(sourceJsonPath(dir), JSON.stringify(payload, null, 2) + "\n", "utf8");
+  return dir;
+}
+function loadJob(jobDir) {
+  const path = sourceJsonPath(jobDir);
+  if (!existsSync(path)) throw new Error(`job has no source.json: ${jobDir}`);
+  return JSON.parse(readFileSync(path, "utf8"));
+}
+function sourceFromJob(jobDir) {
+  const job = loadJob(jobDir);
+  const source = job.source;
+  if (!existsSync(source)) throw new Error(`source listed in job does not exist: ${source}`);
+  return resolvePath(source);
+}
+async function resolveJob(args, opts = {}) {
+  let source = args.source ? resolvePath(args.source) : null;
+  let jobDir = args.jobDir ? resolvePath(args.jobDir) : null;
+  if (source) {
+    jobDir = await initJob(source, jobDir, { force: opts.forceJob });
+  } else if (jobDir) {
+    source = sourceFromJob(jobDir);
+  } else {
+    throw new Error("provide --source or --job-dir");
+  }
+  return { jobDir, source, stem: parsePath(source).name };
+}
+
+export {
+  shown,
+  CommandError,
+  run,
+  runSync,
+  ffprobe,
+  videoStream,
+  mediaDuration,
+  requireFfmpeg,
+  slugify,
+  isoNow,
+  pyRound,
+  pyFixed,
+  pyFixedPad,
+  pySpacePad,
+  rotationDegrees,
+  displayedDimensions,
+  DEFAULT_EDIT_ROOT,
+  VIDEO_EXTS,
+  defaultJobDir,
+  sourceJsonPath,
+  transcriptPath,
+  ensureDirs,
+  initJob,
+  loadJob,
+  sourceFromJob,
+  resolveJob
+};