shorts-maker 0.3.0

package/src/pipeline/pipeline.ts

@@ -0,0 +1,217 @@
+// Split a video into consecutive parts titled from its name, with random hashtags.
+
+import { join, basename } from "node:path";
+import { mkdir } from "node:fs/promises";
+import { probe, silenceCutPoints, cutClip } from "./media.ts";
+import { buildParts, duration, type Part } from "./parts.ts";
+import { overlayText, type OverlayPosition } from "./overlay.ts";
+import { packagedHashtags, userHashtags } from "../paths.ts";
+
+function slug(text: string, maxlen = 50): string {
+  return (
+    text
+      .replace(/[^\p{L}\p{N}\s-]/gu, "")
+      .trim()
+      .toLowerCase()
+      .replace(/[\s_-]+/g, "-")
+      .slice(0, maxlen)
+      .replace(/^-+|-+$/g, "") || "part"
+  );
+}
+
+function fmtTs(seconds: number): string {
+  const s = Math.floor(seconds);
+  const h = Math.floor(s / 3600);
+  const m = Math.floor((s % 3600) / 60);
+  const sec = s % 60;
+  const pad = (n: number) => String(n).padStart(2, "0");
+  return h ? `${pad(h)}:${pad(m)}:${pad(sec)}` : `${pad(m)}:${pad(sec)}`;
+}
+
+function cleanTitle(stem: string): string {
+  let t = stem.replace(/_/g, " ");
+  t = t.replace(/\b(full episode|full|episode|hd|fhd|1080p|720p|4k|official)\b/gi, "");
+  return t.replace(/\s{2,}/g, " ").replace(/^[\s.-]+|[\s.-]+$/g, "") || stem;
+}
+
+/** Strip leading `#`, drop blanks/dupes (case-insensitive). Shared by file + UI pools. */
+function normalizeTags(tags: string[]): string[] {
+  const seen = new Set<string>();
+  const out: string[] = [];
+  for (const raw of tags) {
+    const tag = raw.trim().replace(/^#+/, "").trim();
+    if (!tag || seen.has(tag.toLowerCase())) continue;
+    seen.add(tag.toLowerCase());
+    out.push(tag);
+  }
+  return out;
+}
+
+export async function hashtagPool(): Promise<string[]> {
+  // A hashtags.txt in the user's folder overrides the packaged default list.
+  const userFile = Bun.file(userHashtags);
+  const file = (await userFile.exists()) ? userFile : Bun.file(packagedHashtags);
+  if (!(await file.exists())) return [];
+  const lines = (await file.text())
+    .split("\n")
+    .map((l) => l.trim())
+    .filter((l) => l && !l.startsWith("#"));
+  return normalizeTags(lines);
+}
+
+function sample<T>(arr: T[], k: number): T[] {
+  const copy = [...arr];
+  for (let i = copy.length - 1; i > 0; i--) {
+    const j = Math.floor(Math.random() * (i + 1));
+    [copy[i], copy[j]] = [copy[j]!, copy[i]!];
+  }
+  return copy.slice(0, k);
+}
+
+function titleOf(p: Part, total: number): string {
+  const label = p.index === total ? "final part" : `part-${p.index}`;
+  return `${p.title} ${label}`;
+}
+
+/** Paste-ready caption: title line, then all hashtags on one space-separated line. */
+function caption(p: Part, total: number): string {
+  const tags = p.hashtags.map((t) => `#${t}`).join(" ");
+  return tags ? `${titleOf(p, total)}\n\n${tags}` : titleOf(p, total);
+}
+
+export interface PublishInfo {
+  /** Lifecycle of the publish so a page refresh (or restart) reflects reality. */
+  status: "pending" | "done" | "error";
+  /** Platform post id — present once `done`. */
+  id?: string;
+  url?: string;
+  /** Failure message — present when `error`. */
+  error?: string;
+  /** Upload progress while `pending`: bytes transferred so far, and the total. */
+  sent?: number;
+  total?: number;
+  /** Id of this post's "All parts" index comment, so it can be edited as parts land. */
+  indexCommentId?: string;
+  /** When this state was last set (ms epoch). */
+  at: number;
+}
+
+export interface PartRow {
+  file: string;
+  caption: string;
+  part: number;
+  start: number;
+  end: number;
+  title: string;
+  hashtags: string[];
+  /** Clip file size in bytes. */
+  size?: number;
+  /** Where this part has been published, keyed by platform (e.g. "facebook"). */
+  published?: Record<string, PublishInfo>;
+}
+
+export interface Manifest {
+  source: string;
+  parts: PartRow[];
+}
+
+export interface RunOptions {
+  video: string;
+  outDir: string;
+  title?: string;
+  partLen?: number;
+  numHashtags?: number;
+  /** Override the hashtag pool (e.g. edited in the web UI). Falls back to hashtags.txt. */
+  hashtags?: string[];
+  /**
+   * Burn a "PART 2" badge into the first seconds of every clip. Off by default: it forces
+   * a re-encode of each part, where a plain cut is a near-instant stream copy.
+   */
+  overlay?: OverlayPosition;
+  /** Called with every progress line, for live streaming. Always also logged to stdout. */
+  onLog?: (line: string) => void;
+  /** Aborts the run (kills the active ffmpeg child) — used when the job is deleted. */
+  signal?: AbortSignal;
+}
+
+export async function run(opts: RunOptions): Promise<Manifest> {
+  const { video, signal } = opts;
+  const stop = () => {
+    if (signal?.aborted) throw new Error("Cancelled.");
+  };
+  const partLen = opts.partLen ?? 900;
+  const numHashtags = opts.numHashtags ?? 8;
+  const log = (line: string) => {
+    console.log(line);
+    opts.onLog?.(line);
+  };
+
+  if (!(await Bun.file(video).exists())) {
+    throw new Error(`No such file: ${video}`);
+  }
+  const partsDir = join(opts.outDir, "parts");
+  await mkdir(partsDir, { recursive: true });
+
+  const stem = basename(video).replace(/\.[^.]+$/, "");
+  const baseTitle = opts.title || cleanTitle(stem);
+  const info = await probe(video, signal);
+  log(`▶ ${basename(video)}  ·  "${baseTitle}"`);
+  log(
+    `  ${info.width}x${info.height} ` +
+      `(${info.isVertical ? "vertical 9:16 ✓" : "horizontal"}), ${fmtTs(info.duration)}`,
+  );
+
+  log("① Finding pauses…");
+  const cuts = await silenceCutPoints(video, signal);
+  const parts = buildParts(cuts, info.duration, partLen);
+  log(`  ↳ ${parts.length} parts`);
+
+  const pool = opts.hashtags?.length ? normalizeTags(opts.hashtags) : await hashtagPool();
+  const k = Math.min(numHashtags, pool.length);
+  for (const p of parts) {
+    p.title = baseTitle;
+    p.hashtags = pool.length ? sample(pool, k) : [];
+  }
+
+  // Re-encoding for the badge is orders of magnitude slower than a stream copy — say so,
+  // so a run that suddenly takes minutes per part doesn't look like a hang.
+  log(opts.overlay ? `② Cutting + burning in part badges (${opts.overlay})…` : "② Cutting…");
+  const rows: PartRow[] = [];
+  for (const p of parts) {
+    stop(); // bail promptly if the job was deleted between clips
+    const name = `${String(p.index).padStart(2, "0")}_${slug(baseTitle)}`;
+    const title = titleOf(p, parts.length);
+    const cap = caption(p, parts.length);
+    const outPath = join(partsDir, `${name}.mp4`);
+    const overlay = opts.overlay
+      ? {
+          text: overlayText(p.index, parts.length),
+          position: opts.overlay,
+          width: info.width,
+          height: info.height,
+        }
+      : undefined;
+    await cutClip(video, outPath, p.start, p.end, signal, overlay);
+    const size = Bun.file(outPath).size;
+    await Bun.write(
+      join(partsDir, `${name}.txt`),
+      `${cap}\n\n[source ${fmtTs(p.start)}–${fmtTs(p.end)} · ${duration(p).toFixed(0)}s]\n`,
+    );
+    log(`  [${p.index}/${parts.length}] ${fmtTs(p.start)}–${fmtTs(p.end)}  ${title}`);
+    rows.push({
+      file: `${name}.mp4`,
+      caption: cap,
+      part: p.index,
+      start: Number(p.start.toFixed(2)),
+      end: Number(p.end.toFixed(2)),
+      title,
+      hashtags: p.hashtags,
+      size,
+    });
+  }
+
+  const manifest: Manifest = { source: basename(video), parts: rows };
+  await Bun.write(join(opts.outDir, "manifest.json"), JSON.stringify(manifest, null, 2));
+  log(`\n✓ ${parts.length} parts + captions ready`);
+  return manifest;
+}