overlay-factory-worker 0.1.0

package/scripts/merge-index.ts

@@ -0,0 +1,74 @@
+/**
+ * Merge the caption batches + card transcriptions into episodes/index.json.
+ *
+ * Batches come from reading the caption screenshots; cards.json from reading the
+ * code-card images. Episodes are matched to cards by normalized code text.
+ *
+ * Usage: npx tsx scripts/merge-index.ts
+ */
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+
+const EPISODES = join(import.meta.dirname, "../episodes");
+
+type Batch = {
+  episode: number | null;
+  name: string;
+  code: string | null;
+  answer: string | null;
+  why: string | null;
+  caption: string | null;
+  sourceScreenshots: string[];
+};
+type Card = { card: string; language: string; code: string };
+
+const load = <T>(f: string): T[] => {
+  const p = join(EPISODES, f);
+  return existsSync(p) ? (JSON.parse(readFileSync(p, "utf8")) as T[]) : [];
+};
+
+// Normalize code for matching: strip whitespace, quotes, and comments so
+// transcription differences between the two passes don't block a match.
+const norm = (s: string | null) =>
+  (s ?? "")
+    .toLowerCase()
+    .replace(/["'`]/g, "")
+    .replace(/\s+/g, "")
+    .replace(/#.*$/gm, "");
+
+const episodes = [
+  ...load<Batch>("batch1.json"),
+  ...load<Batch>("batch2.json"),
+  ...load<Batch>("batch3.json"),
+];
+const cards = load<Card>("cards.json");
+
+const used = new Set<string>();
+const merged = episodes.map((e) => {
+  const key = norm(e.code);
+  let card: string | null = null;
+  if (key.length > 12) {
+    const exact = cards.find((c) => !used.has(c.card) && norm(c.code) === key);
+    const partial =
+      exact ??
+      cards.find(
+        (c) =>
+          !used.has(c.card) &&
+          (norm(c.code).includes(key) || key.includes(norm(c.code))),
+      );
+    if (partial) {
+      card = partial.card;
+      used.add(partial.card);
+    }
+  }
+  return { ...e, card };
+});
+
+const unmatchedCards = cards.filter((c) => !used.has(c.card)).map((c) => c.card);
+
+writeFileSync(join(EPISODES, "index.json"), JSON.stringify(merged, null, 2) + "\n");
+
+console.log(`Merged ${merged.length} episodes from ${episodes.length} batch entries.`);
+console.log(`  matched to cards:   ${merged.filter((e) => e.card).length}`);
+console.log(`  episodes w/o card:  ${merged.filter((e) => !e.card).map((e) => e.name).join(", ") || "none"}`);
+console.log(`  cards w/o episode:  ${unmatchedCards.join(", ") || "none"}`);

package/scripts/new-episode.ts

@@ -0,0 +1,149 @@
+/**
+ * Create the next episode: pick the first unused card (and b-roll), write an
+ * episode JSON plus a ready-to-paste caption file.
+ *
+ * Usage:
+ *   npx tsx scripts/new-episode.ts                  # next unused card
+ *   npx tsx scripts/new-episode.ts IMG_4041         # a specific card
+ */
+import { readFileSync, writeFileSync, readdirSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { execFileSync } from "node:child_process";
+
+const ROOT = join(import.meta.dirname, "..");
+const EPISODES = join(ROOT, "episodes");
+const CARDS = join(ROOT, "public/assets/cards");
+const BROLL = join(ROOT, "public/assets/b-roll");
+
+type IndexEntry = {
+  episode: number | null;
+  name: string;
+  card: string | null; // raw filename, e.g. "IMG_4030.jpg"
+  answer?: string;
+  why?: string;
+  difficulty?: "easy" | "medium" | "hard";
+  caption?: string | null;
+  retired?: string; // set by the quality gates; never pick these
+};
+
+const readJson = <T>(p: string, fallback: T): T =>
+  existsSync(p) ? (JSON.parse(readFileSync(p, "utf8")) as T) : fallback;
+
+const index = readJson<IndexEntry[]>(join(EPISODES, "index.json"), []);
+const used = readJson<{ cards: Record<string, string>; broll: Record<string, string> }>(
+  join(EPISODES, "used.json"),
+  { cards: {}, broll: {} },
+);
+
+// Cards retired by scripts/quality.ts stay on disk but are never picked again.
+const retired = new Set(
+  index
+    .filter((e) => e.retired && e.card)
+    .map((e) => e.card!.replace(/\.(png|jpe?g)$/i, "") + ".png"),
+);
+
+const cardPngs = readdirSync(CARDS)
+  .filter((f) => f.endsWith(".png") && !retired.has(f))
+  .sort();
+const requested = process.argv[2];
+
+const cardPng = requested
+  ? cardPngs.find((f) => f.startsWith(requested.replace(/\.(png|jpe?g)$/i, "")))
+  : cardPngs.find((f) => !used.cards[f]);
+
+if (!cardPng) {
+  console.error(requested ? `No card matching ${requested}` : "All cards used.");
+  process.exit(1);
+}
+
+const stem = cardPng.replace(/\.png$/, "");
+const meta = index.find((e) => e.card?.replace(/\.jpe?g$/i, "") === stem);
+
+// Prefer an unused b-roll clip; otherwise reuse the least-recently-used one.
+const brollFiles = readdirSync(BROLL).filter((f) => /\.(mov|mp4)$/i.test(f)).sort();
+const broll = brollFiles.find((f) => !used.broll[f]) ?? brollFiles[0];
+
+const brollDuration = Number(
+  execFileSync("ffprobe", [
+    "-v", "quiet", "-show_entries", "format=duration",
+    "-of", "default=noprint_wrappers=1:nokey=1",
+    join(BROLL, broll),
+  ]).toString().trim(),
+);
+
+const nextNumber = readdirSync(EPISODES)
+  .map((f) => /^what-prints-(\d+)\.json$/.exec(f)?.[1])
+  .filter(Boolean)
+  .reduce((max, n) => Math.max(max, Number(n)), 0) + 1;
+
+const id = `what-prints-${String(nextNumber).padStart(3, "0")}`;
+const durationSec = Math.min(10, Math.floor(brollDuration));
+
+const episode = {
+  broll: `assets/b-roll/${broll}`,
+  card: `assets/cards/${cardPng}`,
+  titleLine1: "What",
+  titleLine2: "Prints?",
+  difficulty: meta?.difficulty ?? "medium",
+  durationSec,
+  revealAtSec: Math.round(durationSec * 0.4),
+  trimBeforeSec: 0,
+};
+
+writeFileSync(join(EPISODES, `${id}.json`), JSON.stringify(episode, null, 2) + "\n");
+
+const caption =
+  meta?.caption ??
+  [
+    "What does this print?",
+    "",
+    "No IDE.",
+    "No running the code.",
+    "Only vibes.",
+    "",
+    "#python #codingchallenge #debugging #softwareengineering #interviewprep #pythondeveloper #devlife",
+  ].join("\n");
+
+writeFileSync(join(ROOT, "out", `${id}.caption.txt`), caption + "\n");
+
+used.cards[cardPng] = id;
+used.broll[broll] = id;
+writeFileSync(join(EPISODES, "used.json"), JSON.stringify(used, null, 2) + "\n");
+
+console.log(`Created ${id}`);
+console.log(`  card:     ${cardPng}${meta ? ` (${meta.name})` : " (no index metadata)"}`);
+console.log(`  answer:   ${meta?.answer ?? "-"}`);
+console.log(`  b-roll:   ${broll} (${durationSec}s, reveal at ${episode.revealAtSec}s)`);
+// Place the difficulty meter against this clip's footage.
+execFileSync("npx", ["tsx", join(ROOT, "scripts/place-overlay.ts"), join(EPISODES, `${id}.json`)], {
+  stdio: "inherit",
+});
+
+// Nothing under Instagram's own chrome...
+try {
+  execFileSync(
+    "npx",
+    ["tsx", join(ROOT, "scripts/check-safe-area.ts"), join(EPISODES, `${id}.json`)],
+    { stdio: "inherit" },
+  );
+} catch {
+  console.error(`\n${id}: an overlay sits under Instagram's UI (see above).`);
+}
+
+// ...and then check the overlays actually read against this clip. Runs here rather
+// than on request because the one time it mattered, nobody thought to look —
+// a title that vanished into a bright keyboard shipped as episode 002.
+try {
+  execFileSync(
+    "npx",
+    ["tsx", join(ROOT, "scripts/check-legibility.ts"), join(EPISODES, `${id}.json`)],
+    { stdio: "inherit" },
+  );
+} catch {
+  console.error(
+    `\n${id}: overlays don't read against this b-roll. Pick a calmer clip,\n` +
+      `or darken the scrim in src/series/what-prints/Composition.tsx.`,
+  );
+}
+
+console.log(`\nRender:  npx remotion render WhatPrints out/${id}.mp4 --props=episodes/${id}.json`);