rikrok 0.5.0

package/src/lib/llm.mjs

@@ -0,0 +1,258 @@
+// Script generation through any OpenAI-compatible chat endpoint (Ollama, LM Studio, oMLX, ...).
+// Strict JSON out; one retry; deterministic fallback so a reel ALWAYS ships.
+import { LLM_URL, LLM_MODEL, LLM_KEY, LLM_EXTRA, SCRIPT_BACKEND, authHeaders } from "./config.mjs";
+import { claudeChat, claudeAvailable } from "./script-claude.mjs";
+
+const SYSTEM = `You write scripts for 30-45 second vertical recap reels about finished coding sessions.
+Fixed daily-news / sports-recap grammar. Brisk, neutral news-anchor tone. No hooks, no teasing, no hype words.
+State the outcome up front. Keep total narration 75-110 words.
+Respond with ONLY a JSON object, no markdown fences, matching exactly:
+{
+  "headline": "ProjectName: one-line outcome (max 60 chars)",
+  "done_count": <int, meaningful things completed>,
+  "open_count": <int, things still open>,
+  "plays": [
+    { "caption": "short declarative caption, max 52 chars",
+      "narration": "1-2 spoken sentences for this beat",
+      "visual": { "type": "files" | "commits" | "commands" | "text", "lines": ["up to 4 short lines of supporting evidence"] } }
+  ],
+  "status": { "caption": "outcome summary, max 52 chars", "narration": "1-2 spoken sentences stating concretely WHAT was achieved and WHERE it now lives (deployed, committed, live URL, file)", "achieved": ["max 4 concrete artifacts: things that now exist/work, each naming the thing (e.g. 'Feed live at app.example.com', '7 commits on build branch')"], "open": ["max 3 short items still unresolved"] },
+  "next_step": { "caption": "THE single next action, max 60 chars", "narration": "1 spoken sentence stating the next step" },
+  "headline_narration": "1-2 spoken sentences opening the reel with the outcome",
+  "flow": null | {
+    "title": "what moves, max 44 chars (e.g. 'Signup submit, guarded')",
+    "narration": "1-2 spoken sentences walking the viewer along the arrows in order",
+    "nodes": [ { "id": "a", "label": "max 24 chars, a noun (Sign up button, POST /signup, users table)", "kind": "ui" | "api" | "data" | "service" | "job" | "external" } ],
+    "edges": [ { "from": "a", "to": "b", "label": "verb, max 16 chars (submits, writes, calls, returns)" } ],
+    "changed": ["ids of the 1 or 2 nodes this session actually added or altered; the rest are context"]
+  }
+}
+Rules: 2-4 plays, each about one real thing that happened (feature built, bug fixed, decision made).
+Evidence lines must come from the provided session data (file names, commit lines, commands, urls_mentioned) — never invent.
+Be informative over punchy: the viewer wants to know WHAT was achieved and WHERE it is.
+If urls_mentioned contains a live/deployed URL, it belongs in status.achieved.
+flow: include it whenever the session built or changed how something moves: a user action (tap, submit, click) reaching a handler, hook, API route, database, queue, cron, webhook or redirect. Most sessions that edited a component, handler, route or model have one; prefer a small 2-4 node flow over null. Nodes and edges in the order things happen, starting from the user's action when there is one, each backed by the session evidence. Only when nothing moved (pure docs, config, research) is flow null.
+If previous_next_step is present, say early in headline_narration or status.narration whether that step was done this session, still open, or replaced.
+Captions, achieved items and evidence lines are ON-SCREEN TEXT: write URLs and paths literally (e.g. "app.example.com").
+Narration is SPOKEN: no file paths or code symbols; a domain may be spoken with the dots said aloud ("app dot example dot com").`;
+
+function deepMerge(a, b) {
+  const out = { ...a };
+  for (const [k, v] of Object.entries(b || {})) {
+    out[k] = v && typeof v === "object" && !Array.isArray(v) && out[k] && typeof out[k] === "object" ? deepMerge(out[k], v) : v;
+  }
+  return out;
+}
+
+// Reasoning models that ignore RIKROK_LLM_EXTRA (Ollama drops chat_template_kwargs) leak
+// their thinking into the content; strip it before looking for JSON.
+export function stripThinking(t) {
+  return String(t).replace(/<think>[\s\S]*?<\/think>/g, "").replace(/^[\s\S]*?<\/think>/, "").trim();
+}
+
+// One chat completion. RIKROK_LLM_EXTRA is deep-merged into the request body so
+// server-specific fields (chat_template_kwargs, think, reasoning_effort) stay possible.
+export async function chat(messages, { temperature = 0.4, max_tokens = 1600, timeoutMs = 180_000 } = {}) {
+  if (!LLM_MODEL) throw new Error("RIKROK_LLM_MODEL is not set");
+  const body = deepMerge({ model: LLM_MODEL, messages, temperature, max_tokens }, LLM_EXTRA);
+  const resp = await fetch(`${LLM_URL}/v1/chat/completions`, {
+    method: "POST",
+    headers: { ...authHeaders(LLM_KEY), "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+    signal: AbortSignal.timeout(timeoutMs),
+  });
+  if (!resp.ok) throw new Error(`LLM HTTP ${resp.status} from ${LLM_URL}`);
+  const j = await resp.json();
+  return stripThinking(j.choices?.[0]?.message?.content || "");
+}
+
+let resolvedBackend = null;
+// "claude" | "local" | "none", decided once per process.
+export async function scriptBackend() {
+  if (resolvedBackend) return resolvedBackend;
+  if (SCRIPT_BACKEND === "claude") resolvedBackend = "claude";
+  else if (SCRIPT_BACKEND === "local") resolvedBackend = LLM_MODEL ? "local" : "none";
+  else resolvedBackend = LLM_MODEL ? "local" : (await claudeAvailable()) ? "claude" : "none";
+  return resolvedBackend;
+}
+
+let warnedNoModel = false;
+export async function generateScript(evidence, projectName) {
+  const backend = await scriptBackend();
+  if (backend === "none") {
+    if (!warnedNoModel) console.error("[llm] no script writer: set RIKROK_LLM_MODEL for a local model, or install Claude Code for RIKROK_SCRIPT=claude. Reels use the template script.");
+    warnedNoModel = true;
+    return { script: fallbackScript(evidence, projectName), source: "fallback" };
+  }
+  const user = `Project: ${projectName}\nSession evidence (JSON):\n${JSON.stringify(evidence, null, 1)}\n\nWrite the reel script JSON now.`;
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      const messages = [{ role: "system", content: SYSTEM }, { role: "user", content: user }];
+      const text = backend === "claude" ? await claudeChat(messages) : await chat(messages, { temperature: attempt === 0 ? 0.4 : 0.1 });
+      const script = extractJson(text);
+      const valid = validateScript(script);
+      if (valid.ok) return { script: normalise(script, projectName), source: backend === "claude" ? "claude" : "llm" };
+      console.error(`[llm] attempt ${attempt + 1} invalid: ${valid.error}`);
+    } catch (err) {
+      console.error(`[llm] attempt ${attempt + 1} failed: ${err.message}`);
+    }
+  }
+  return { script: fallbackScript(evidence, projectName), source: "fallback" };
+}
+
+export function extractJson(text) {
+  text = text.replace(/^[\s\S]*?(?=\{)/, "").trim();
+  // trim trailing junk after the last closing brace
+  const last = text.lastIndexOf("}");
+  if (last >= 0) text = text.slice(0, last + 1);
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+
+export function validateScript(s) {
+  if (!s || typeof s !== "object") return { ok: false, error: "not an object" };
+  if (typeof s.headline !== "string" || !s.headline) return { ok: false, error: "headline" };
+  if (!Array.isArray(s.plays) || s.plays.length < 1 || s.plays.length > 6)
+    return { ok: false, error: "plays" };
+  for (const p of s.plays) {
+    if (typeof p.caption !== "string" || typeof p.narration !== "string")
+      return { ok: false, error: "play fields" };
+    if (!p.visual || !Array.isArray(p.visual.lines)) return { ok: false, error: "play visual" };
+  }
+  if (!s.status || typeof s.status.narration !== "string") return { ok: false, error: "status" };
+  if (!s.next_step || typeof s.next_step.caption !== "string" || typeof s.next_step.narration !== "string")
+    return { ok: false, error: "next_step" };
+  if (typeof s.headline_narration !== "string") return { ok: false, error: "headline_narration" };
+  if (s.flow != null) {
+    const v = validateFlow(s.flow);
+    if (!v.ok) {
+      console.error(`[llm] flow dropped: ${v.error}`);
+      s.flow = null;
+    }
+  }
+  return { ok: true };
+}
+
+const FLOW_KINDS = ["ui", "api", "data", "service", "job", "external"];
+export function validateFlow(f) {
+  if (!f || typeof f !== "object") return { ok: false, error: "not an object" };
+  if (!Array.isArray(f.nodes) || f.nodes.length < 2 || f.nodes.length > 6) return { ok: false, error: "nodes" };
+  if (!Array.isArray(f.edges) || f.edges.length < 1 || f.edges.length > 7) return { ok: false, error: "edges" };
+  const ids = new Set();
+  for (const n of f.nodes) {
+    if (!n || typeof n.id !== "string" || typeof n.label !== "string" || ids.has(n.id)) return { ok: false, error: "node" };
+    ids.add(n.id);
+  }
+  for (const e of f.edges) if (!e || !ids.has(e.from) || !ids.has(e.to) || e.from === e.to) return { ok: false, error: "edge" };
+  if (typeof f.narration !== "string" || !f.narration.trim()) return { ok: false, error: "narration" };
+  return { ok: true };
+}
+
+// Models sometimes write the spoken form of a URL into on-screen text. Undo it.
+export function unspeakUrl(x) {
+  const t = String(x);
+  if (!/\s(dot|slash)\s/i.test(t)) return t;
+  return t.replace(/\s+dot\s+/gi, ".").replace(/\s+slash\s+/gi, "/").replace(/\s+colon\s+/gi, ":");
+}
+
+export function normalise(s, projectName) {
+  // Prepend the project name unless the headline already leads with it
+  // (compare ignoring case and punctuation: "My App" matches "my-app").
+  const canon = (x) => String(x).toLowerCase().replace(/[^a-z0-9]/g, "");
+  if (projectName && !canon(s.headline).startsWith(canon(projectName))) {
+    s.headline = `${projectName}: ${s.headline}`;
+  }
+  s.plays = s.plays.slice(0, 4).map((p) => ({
+    caption: String(p.caption).slice(0, 60),
+    narration: String(p.narration),
+    visual: {
+      type: ["files", "commits", "commands", "text"].includes(p.visual?.type) ? p.visual.type : "text",
+      lines: (p.visual?.lines || []).slice(0, 4).map((l) => unspeakUrl(l).slice(0, 70)),
+    },
+  }));
+  s.headline = String(s.headline).slice(0, 70);
+  s.done_count = Number.isFinite(+s.done_count) ? Math.max(0, Math.round(+s.done_count)) : s.plays.length;
+  s.open_count = Number.isFinite(+s.open_count) ? Math.max(0, Math.round(+s.open_count)) : 0;
+  s.status.achieved = (s.status.achieved || s.status.done || []).slice(0, 4).map((x) => unspeakUrl(x).slice(0, 60));
+  s.status.open = (s.status.open || []).slice(0, 3).map((x) => unspeakUrl(x).slice(0, 55));
+  s.status.caption = String(s.status.caption || "Where it stands").slice(0, 60);
+  s.next_step.caption = String(s.next_step.caption).slice(0, 70);
+  if (s.flow) {
+    const f = s.flow;
+    s.flow = {
+      title: String(f.title || "How it moves").slice(0, 44),
+      narration: String(f.narration),
+      nodes: f.nodes.slice(0, 6).map((n) => ({ id: String(n.id), label: String(n.label).slice(0, 24), kind: FLOW_KINDS.includes(n.kind) ? n.kind : "service" })),
+      edges: f.edges.slice(0, 7).map((e) => ({ from: String(e.from), to: String(e.to), label: String(e.label || "").slice(0, 16) })),
+      changed: (Array.isArray(f.changed) ? f.changed : []).map(String).filter((id) => f.nodes.some((n) => String(n.id) === id)),
+    };
+  } else s.flow = null;
+  return s;
+}
+
+// Deterministic template from raw metadata — used when the LLM is down or invalid twice.
+export function fallbackScript(ev, projectName) {
+  const commits = ev.git_commits || [];
+  const files = ev.files_touched || [];
+  const doneTodos = (ev.todos || []).filter((t) => t.status === "completed");
+  const openTodos = (ev.todos || []).filter((t) => t.status !== "completed");
+  const mins = ev.duration_minutes || 0;
+
+  const plays = [];
+  if (commits.length) {
+    plays.push({
+      caption: `${commits.length} commit${commits.length > 1 ? "s" : ""} landed`,
+      narration: `The session landed ${commits.length} ${commits.length > 1 ? "commits" : "commit"}.`,
+      visual: { type: "commits", lines: commits.slice(0, 4).map((c) => c.slice(0, 70)) },
+    });
+  }
+  if (files.length) {
+    plays.push({
+      caption: `${files.length} file${files.length > 1 ? "s" : ""} changed`,
+      narration: `Work touched ${files.length} ${files.length > 1 ? "files" : "file"} across the project.`,
+      visual: { type: "files", lines: files.slice(0, 4).map((f) => f.split("/").slice(-2).join("/")) },
+    });
+  }
+  if (ev.commands_run?.length) {
+    plays.push({
+      caption: `${ev.tool_uses} tool calls this session`,
+      narration: `${ev.tool_uses} tool calls ran, including builds and checks.`,
+      visual: { type: "commands", lines: ev.commands_run.slice(-4).map((c) => String(c).slice(0, 70)) },
+    });
+  }
+  if (plays.length === 0) {
+    plays.push({
+      caption: `${ev.assistant_turns} working turns`,
+      narration: `The assistant worked through ${ev.assistant_turns} turns this session.`,
+      visual: { type: "text", lines: (ev.user_prompts || []).slice(0, 3).map((p) => p.slice(0, 70)) },
+    });
+  }
+
+  const openLine = openTodos[0]?.content || "Review the session output";
+  const achieved = [
+    ...doneTodos.slice(0, 2).map((t) => t.content.slice(0, 60)),
+    ...(commits.length ? [`${commits.length} commit${commits.length > 1 ? "s" : ""} landed`] : []),
+    ...(ev.urls_mentioned || []).slice(0, 1).map((u) => `Live: ${u.replace(/^https?:\/\//, "").slice(0, 50)}`),
+  ].slice(0, 4);
+  return {
+    headline: `${projectName}: session recap`,
+    done_count: doneTodos.length || commits.length || plays.length,
+    open_count: openTodos.length,
+    plays: plays.slice(0, 4),
+    status: {
+      caption: `${doneTodos.length || commits.length} done, ${openTodos.length} open`,
+      narration: `Overall, ${doneTodos.length || commits.length} items are done and ${openTodos.length} remain open.`,
+      achieved,
+      open: openTodos.slice(0, 3).map((t) => t.content.slice(0, 55)),
+    },
+    next_step: {
+      caption: openLine.slice(0, 70),
+      narration: `Next step: ${openLine}.`,
+    },
+    headline_narration: `${projectName}. A ${mins || "short"}-minute session wrapped up. Here's the recap.`,
+    flow: null,
+  };
+}

package/src/lib/narrate.mjs

@@ -0,0 +1,148 @@
+// Narration: one WAV per beat through the configured voice, loudness-normalised,
+// optionally transcribed back and re-taken when words go missing (RIKROK_STT_URL),
+// then joined with breath gaps. Measured durations drive the render timing.
+import path from "node:path";
+import fs from "node:fs";
+import { execFileSync } from "node:child_process";
+import { VOICE_FX } from "./config.mjs";
+import { transcribeWords, sttEnabled } from "./stt.mjs";
+import { resolveVoice } from "../voices/index.mjs";
+import { silentVoice } from "../voices/none.mjs";
+import { applyFx } from "../voices/fx.mjs";
+
+const GAP_SECONDS = 0.35; // breath between beats
+const TAIL_PAD = 0.25; // silence after each beat so the last phoneme is never clipped
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+export function wavDuration(p) {
+  const out = execFileSync("ffprobe", ["-i", p, "-show_entries", "format=duration", "-v", "quiet", "-of", "csv=p=0"]).toString().trim();
+  return parseFloat(out) || 0;
+}
+
+export function normalizeVolume(p) {
+  const out = p.replace(/\.wav$/, "_norm.wav");
+  execFileSync("ffmpeg", ["-y", "-i", p, "-af", "loudnorm=I=-23:TP=-1.5:LRA=11", "-ar", "24000", "-ac", "1", out], { stdio: "ignore" });
+  fs.renameSync(out, p);
+}
+
+const norm = (w) => String(w).toLowerCase().replace(/[^a-z0-9']/g, "");
+const SPELL = { 0: "zero", 1: "one", 2: "two", 3: "three", 4: "four", 5: "five", 6: "six", 7: "seven", 8: "eight", 9: "nine", 10: "ten", 11: "eleven", 12: "twelve", 13: "thirteen", 14: "fourteen", 15: "fifteen", 16: "sixteen", 17: "seventeen", 18: "eighteen", 19: "nineteen", 20: "twenty", 30: "thirty", 40: "forty", 50: "fifty", 60: "sixty", 70: "seventy", 80: "eighty", 90: "ninety", 100: "hundred" };
+const UNSPELL = Object.fromEntries(Object.entries(SPELL).map(([k, v]) => [v, k]));
+
+// Compare script words to heard words. Returns {coverage, tailOk, missing}.
+export function compareWords(text, heard) {
+  const want = text.split(/\s+/).map(norm).filter(Boolean);
+  const got = new Set(heard.map((w) => norm(w.w)).filter(Boolean));
+  const ok = (w) => got.has(w) || (SPELL[+w] && got.has(SPELL[+w])) || (UNSPELL[w] && got.has(UNSPELL[w])) || [...got].some((g) => g.length > 3 && (g.startsWith(w) || w.startsWith(g)));
+  const hits = want.filter(ok).length;
+  const coverage = want.length ? hits / want.length : 1;
+  const tail = want.slice(-3);
+  const tailOk = tail.filter(ok).length >= Math.min(2, tail.length);
+  return { coverage, tailOk, missing: want.filter((w) => !ok(w)) };
+}
+
+async function synthOnce(voice, text, outPath, attempt) {
+  // Deterministic engines give identical (bad) audio for identical text; nudge it per attempt.
+  const variants = [text, text.replace(/\s+$/, "") + " ", text.replace(/[.!?]$/, "") + "."];
+  const t = variants[Math.min(attempt, variants.length - 1)];
+  let res;
+  for (let wait = 0; wait < 8; wait++) {
+    res = await voice.synth(t, outPath);
+    // A shared local inference box under memory pressure answers 500; wait it out.
+    if (res.ok || !/memory ceiling|Cannot load|exceed/i.test(res.error || "")) break;
+    console.log(`[narrate] voice backend under memory pressure, waiting 60s (${wait + 1}/8)`);
+    await sleep(60_000);
+  }
+  if (res.ok && !res.silent) {
+    normalizeVolume(outPath);
+    applyFx(outPath, VOICE_FX);
+  }
+  return res;
+}
+
+async function qaLoop(voice, text, p, i, qa) {
+  let best = null;
+  for (let attempt = 0; attempt < 3; attempt++) {
+    if (attempt > 0) {
+      const r = await synthOnce(voice, text, p, attempt);
+      if (!r.ok) break;
+    }
+    let heard = [];
+    for (let t = 0; t < 3 && heard.length === 0; t++) {
+      heard = await transcribeWords(p);
+      if (heard.length === 0) await sleep(5000);
+    }
+    if (heard.length === 0) {
+      console.log(`[narrate] beat ${i}: transcriber returned nothing, keeping audio unverified`);
+      qa.push({ beat: i, unverified: true, attempts: attempt + 1 });
+      best = null;
+      break;
+    }
+    const r = compareWords(text, heard);
+    const score = r.coverage + (r.tailOk ? 0.5 : 0);
+    if (!best || score > best.score) {
+      best = { ...r, attempt, score };
+      fs.copyFileSync(p, p + ".best");
+    }
+    if (r.coverage >= 0.92 && r.tailOk) break;
+    console.log(`[narrate] beat ${i} attempt ${attempt + 1}: coverage ${(r.coverage * 100).toFixed(0)}% tail=${r.tailOk} missing=[${r.missing.slice(0, 6).join(",")}], retaking`);
+  }
+  if (best) {
+    fs.copyFileSync(p + ".best", p);
+    fs.unlinkSync(p + ".best");
+    qa.push({ beat: i, coverage: +best.coverage.toFixed(2), tailOk: best.tailOk, attempts: best.attempt + 1, missing: best.missing.slice(0, 8) });
+  } else {
+    try {
+      fs.unlinkSync(p + ".best");
+    } catch {}
+  }
+}
+
+// texts: one narration string per beat.
+// Returns { audioPath, beats: [{start, duration}], totalDuration, qa, voice, silent }.
+export async function narrateBeats(texts, workDir, opts = {}) {
+  const voice = opts.voice || (await resolveVoice());
+  const silent = voice.name === "none";
+  const qaOn = sttEnabled() && !silent;
+  const parts = [];
+  const qa = [];
+  let anySilent = silent;
+  for (let i = 0; i < texts.length; i++) {
+    const p = path.join(workDir, `beat-${i}.wav`);
+    let res = await synthOnce(voice, texts[i], p, 0);
+    if (!res.ok) {
+      console.error(`[narrate] beat ${i}: ${voice.name} failed (${res.error}); using silence for this beat`);
+      res = await silentVoice().synth(texts[i], p);
+      if (!res.ok) throw new Error(`narration failed: ${res.error}`);
+      qa.push({ beat: i, silent: true });
+      anySilent = true;
+    } else if (qaOn) {
+      await qaLoop(voice, texts[i], p, i, qa);
+    }
+    parts.push({ path: p, duration: wavDuration(p) + TAIL_PAD });
+  }
+
+  // Concat: resample, pad each beat (tail pad + breath gap), join.
+  const audioPath = path.join(workDir, "narration.wav");
+  const inputs = [];
+  const filters = [];
+  for (let i = 0; i < parts.length; i++) {
+    inputs.push("-i", parts[i].path);
+    filters.push(`[${i}:a]aresample=24000,aformat=channel_layouts=mono[a${i}]`);
+  }
+  const padded = parts.map((_, i) => `[a${i}]apad=pad_dur=${(TAIL_PAD + (i < parts.length - 1 ? GAP_SECONDS : 0)).toFixed(2)}[p${i}]`).join(";");
+  const concatIn = parts.map((_, i) => `[p${i}]`).join("");
+  const filter = `${filters.join(";")};${padded};${concatIn}concat=n=${parts.length}:v=0:a=1[out]`;
+  execFileSync("ffmpeg", ["-y", ...inputs, "-filter_complex", filter, "-map", "[out]", audioPath], { stdio: "ignore" });
+
+  const beats = [];
+  let t = 0;
+  for (let i = 0; i < parts.length; i++) {
+    const gap = i < parts.length - 1 ? GAP_SECONDS : 0;
+    beats.push({ start: t, duration: parts[i].duration + gap });
+    t += parts[i].duration + gap;
+  }
+  const totalDuration = wavDuration(audioPath);
+  for (const p of parts) fs.unlinkSync(p.path);
+  return { audioPath, beats, totalDuration, qa, voice: voice.name, silent: anySilent };
+}

package/src/lib/palette.mjs

@@ -0,0 +1,27 @@
+// One fixed, deterministic accent colour per project, chosen to read on a black
+// canvas so a project is identifiable by colour alone while scrolling.
+export const ACCENTS = [
+  "#69C9D0", // cyan (brand)
+  "#EE1D52", // red (brand)
+  "#F5D547", // yellow
+  "#7CFC9A", // mint
+  "#FF8C42", // orange
+  "#B98CFF", // lavender
+  "#4DA3FF", // sky
+  "#FF6BC1", // pink
+  "#A8E34D", // lime
+  "#FFB86B", // apricot
+  "#5EEAD4", // teal
+  "#E0E0E0", // silver
+];
+
+export function accentFor(projectName) {
+  // FNV-1a spreads short similar names far better than djb2 mod n
+  let h = 0x811c9dc5;
+  const s = String(projectName).toLowerCase();
+  for (let i = 0; i < s.length; i++) {
+    h ^= s.charCodeAt(i);
+    h = Math.imul(h, 0x01000193) >>> 0;
+  }
+  return ACCENTS[h % ACCENTS.length];
+}

package/src/lib/paths.mjs

@@ -0,0 +1,29 @@
+// Where Rik Rok keeps its data (reels, state, render bundle, logs).
+// Default ~/.rikrok, override with RIKROK_HOME. Package-relative dirs resolve from this file.
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+export const PKG_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..");
+export const PKG = JSON.parse(fs.readFileSync(path.join(PKG_ROOT, "package.json"), "utf-8"));
+export const PKG_VERSION = PKG.version;
+export const REMOTION_DIR = path.join(PKG_ROOT, "remotion");
+export const PUBLIC_DIR = path.join(PKG_ROOT, "server", "public");
+export const BIN = path.join(PKG_ROOT, "bin", "rikrok.mjs");
+
+export function expandHome(p) {
+  return String(p).replace(/^~(?=$|\/)/, os.homedir());
+}
+
+export const RIKROK_HOME = path.resolve(expandHome(process.env.RIKROK_HOME || "~/.rikrok"));
+export const REELS_DIR = path.join(RIKROK_HOME, "reels");
+export const WORK_DIR = path.join(RIKROK_HOME, "work");
+export const BUNDLE_DIR = path.join(RIKROK_HOME, "bundle");
+export const LOG_DIR = path.join(RIKROK_HOME, "logs");
+export const STATE_FILE = path.join(RIKROK_HOME, "state.json");
+export const CONFIG_FILE = path.join(RIKROK_HOME, "config.json");
+
+export function ensureDirs() {
+  for (const d of [RIKROK_HOME, REELS_DIR, WORK_DIR, LOG_DIR]) fs.mkdirSync(d, { recursive: true });
+}

package/src/lib/pipeline.mjs

@@ -0,0 +1,180 @@
+// One session slice -> one reel. Steps: parse -> evidence -> script -> narration -> render -> sidecar.
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawn } from "node:child_process";
+import { REELS_DIR, WORK_DIR, PKG_ROOT, HANDLE, FLOW_BEAT } from "./config.mjs";
+import { sourceById } from "../sources/index.mjs";
+import { condense } from "./evidence.mjs";
+import { gitCommitsFor, gitDiffStat } from "./gitinfo.mjs";
+import { generateScript } from "./llm.mjs";
+import { narrateBeats } from "./narrate.mjs";
+import { accentFor } from "./palette.mjs";
+
+export const FPS = 30;
+export const MIN_BEAT_SEC = 2.2; // a card must be readable even if its narration is short
+export const TAIL_SEC = 1.2; // final card holds past the end of audio
+
+export function shortPath(cwd) {
+  if (!cwd) return null;
+  const h = os.homedir();
+  return cwd === h || cwd.startsWith(h + "/") ? "~" + cwd.slice(h.length) : cwd;
+}
+
+// Beat order is the fixed grammar: headline -> plays -> (flow) -> status -> next step.
+export const hasFlow = (script) => Boolean(FLOW_BEAT && script.flow);
+
+export function beatDefsFor(script) {
+  return [
+    { kind: "headline", caption: script.headline },
+    ...script.plays.map((p) => ({ kind: "play", caption: p.caption, visual: p.visual })),
+    ...(hasFlow(script) ? [{ kind: "flow", caption: script.flow.title, flow: { nodes: script.flow.nodes, edges: script.flow.edges, changed: script.flow.changed } }] : []),
+    { kind: "status", caption: script.status.caption, achieved: script.status.achieved, open: script.status.open },
+    { kind: "next", caption: script.next_step.caption },
+  ];
+}
+
+export function narrationTextsFor(script) {
+  return [script.headline_narration, ...script.plays.map((p) => p.narration), ...(hasFlow(script) ? [script.flow.narration] : []), script.status.narration, script.next_step.narration];
+}
+
+// The most recent earlier reel for the same session (or, failing that, the same project),
+// so the script can say whether last time's next step happened.
+export function previousRecap(sessionId, projectName, reelsDir = REELS_DIR) {
+  let best = null;
+  try {
+    for (const f of fs.readdirSync(reelsDir)) {
+      if (!f.endsWith(".json")) continue;
+      let d;
+      try {
+        d = JSON.parse(fs.readFileSync(path.join(reelsDir, f), "utf-8"));
+      } catch {
+        continue;
+      }
+      if (!d.next_step || !d.createdAt) continue;
+      const sameSession = d.sessionId === sessionId, sameProject = d.project === projectName;
+      if (!sameSession && !sameProject) continue;
+      const rank = sameSession ? 2 : 1;
+      if (!best || rank > best.rank || (rank === best.rank && d.createdAt > best.createdAt)) best = { rank, createdAt: d.createdAt, next_step: d.next_step, headline: d.headline };
+    }
+  } catch {}
+  return best;
+}
+
+// Distribute frames per measured narration timing; pad short beats to stay readable,
+// and let the final card hold to the end of audio plus a settle tail. Pure.
+export function buildBeats(beatDefs, beatTimes, totalDuration) {
+  const beats = beatDefs.map((b, i) => {
+    const start = Math.round(beatTimes[i].start * FPS);
+    let end = i < beatDefs.length - 1 ? Math.round((beatTimes[i + 1]?.start ?? totalDuration) * FPS) : Math.round((totalDuration + TAIL_SEC) * FPS);
+    if (end - start < MIN_BEAT_SEC * FPS) end = start + Math.round(MIN_BEAT_SEC * FPS);
+    return { ...b, startFrame: start, durationFrames: end - start };
+  });
+  for (let i = 0; i < beats.length - 1; i++) {
+    beats[i].durationFrames = Math.max(Math.round(MIN_BEAT_SEC * FPS), beats[i + 1].startFrame - beats[i].startFrame);
+  }
+  const last = beats[beats.length - 1];
+  return { beats, totalFrames: last.startFrame + last.durationFrames };
+}
+
+// Remotion input props for a reel. Pure, so tests can check the shape without rendering.
+export function buildProps({ script, projectName, accent, where, durationMin, beatTimes, totalDuration }) {
+  const { beats, totalFrames } = buildBeats(beatDefsFor(script), beatTimes, totalDuration);
+  const props = {
+    projectName,
+    accent,
+    headline: script.headline,
+    where,
+    scoreBug: { durationMin, done: script.done_count, open: script.open_count },
+    beats,
+    totalFrames,
+  };
+  if (HANDLE) props.handle = HANDLE;
+  return props;
+}
+
+// sessionFile: { source, path, sessionId, projectDir }. opts: { outPath, projectName, voice }.
+export async function buildReel(sessionFile, fromLine = 0, opts = {}) {
+  const src = sourceById(sessionFile.source || "claude");
+  const { path: filePath, sessionId, projectDir } = sessionFile;
+  const act = await src.parseSession(filePath, fromLine);
+  const projectName = opts.projectName || src.projectName(act, projectDir);
+  const accent = accentFor(projectName);
+
+  const gitCommits = act.firstTs ? gitCommitsFor(act.cwd, act.firstTs, act.lastTs) : [];
+  const evidence = condense(act, gitCommits);
+  const shortstat = act.firstTs ? gitDiffStat(act.cwd, act.firstTs) : null;
+  if (shortstat) evidence.diff_shortstat = shortstat;
+  const prev = previousRecap(sessionId, projectName);
+  if (prev) evidence.previous_next_step = prev.next_step;
+
+  console.log(`[pipeline] ${projectName}/${sessionId.slice(0, 8)}: generating script...`);
+  const { script, source } = await generateScript(evidence, projectName);
+  console.log(`[pipeline] script source: ${source}${hasFlow(script) ? `, flow: ${script.flow.nodes.map((n) => n.label).join(" > ")}` : ", no flow"}`);
+
+  const id = `${Date.now()}-${projectName.replace(/[^a-zA-Z0-9_-]/g, "_")}-${sessionId.slice(0, 8)}`;
+  const workDir = path.join(WORK_DIR, id);
+  fs.mkdirSync(workDir, { recursive: true });
+
+  const texts = narrationTextsFor(script);
+  console.log(`[pipeline] narrating ${texts.length} beats...`);
+  const narration = await narrateBeats(texts, workDir, { voice: opts.voice });
+
+  const branch = act.gitBranch && act.gitBranch !== "HEAD" ? act.gitBranch : null;
+  const cwdShort = shortPath(act.cwd);
+  const where = cwdShort ? `${cwdShort}${branch ? ` · ${branch}` : ""}` : null;
+  const durationMin = Math.max(1, Math.round(act.activeMs / 60000));
+  const props = buildProps({ script, projectName, accent, where, durationMin, beatTimes: narration.beats, totalDuration: narration.totalDuration });
+
+  const outPath = opts.outPath || path.join(REELS_DIR, `${id}.mp4`);
+  fs.mkdirSync(path.dirname(outPath), { recursive: true });
+  fs.writeFileSync(path.join(workDir, "job.json"), JSON.stringify({ id, props, audioPath: narration.audioPath, outPath }, null, 2));
+
+  console.log(`[pipeline] rendering...`);
+  await runRender(workDir);
+
+  const sidecar = {
+    id,
+    source: src.id,
+    project: projectName,
+    sessionId,
+    createdAt: new Date().toISOString(),
+    durationSec: Math.round(props.totalFrames / FPS),
+    headline: script.headline,
+    next_step: script.next_step.caption,
+    accentColor: accent,
+    watched: false,
+    sourcePath: act.cwd || null,
+    where,
+    achieved: script.status.achieved || [],
+    open: script.status.open || [],
+    commits: gitCommits.slice(0, 8),
+    urls: act.urls.slice(0, 5),
+    scriptSource: source,
+    voice: narration.voice,
+    silent: narration.silent,
+    audioQA: narration.qa,
+    sessionFile: filePath,
+    resumeHint: src.resumeHint(sessionId),
+    flow: hasFlow(script) ? script.flow : null,
+    previousNextStep: prev ? prev.next_step : null,
+    coveredLines: { from: fromLine, to: act.totalLines },
+  };
+  fs.writeFileSync(outPath.replace(/\.mp4$/, ".json"), JSON.stringify(sidecar, null, 2));
+  fs.rmSync(workDir, { recursive: true, force: true });
+  console.log(`[pipeline] done: ${outPath}`);
+  return { id, totalLines: act.totalLines, outPath, sidecar };
+}
+
+// Render in a child process at low priority so a render never starves live work.
+function runRender(workDir) {
+  const job = path.join(PKG_ROOT, "src", "lib", "render-job.mjs");
+  const useNice = process.platform !== "win32";
+  return new Promise((resolve, reject) => {
+    const proc = useNice
+      ? spawn("nice", ["-n", "19", process.execPath, job, workDir], { stdio: ["ignore", "inherit", "inherit"] })
+      : spawn(process.execPath, [job, workDir], { stdio: ["ignore", "inherit", "inherit"] });
+    proc.on("close", (code) => (code === 0 ? resolve() : reject(new Error(`render exited ${code}`))));
+    proc.on("error", reject);
+  });
+}