reelme 0.2.0

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "reelme",
+  "version": "0.2.0",
+  "description": "Turn your repo into launch videos for social platforms. Local Remotion rendering, zero cloud.",
+  "type": "module",
+  "bin": {
+    "reelme": "src/cli.mjs"
+  },
+  "files": [
+    "src",
+    "template",
+    "!template/out",
+    "!template/src/__tests__",
+    "!template/eslint.config.mjs",
+    "!template/vitest.config.ts",
+    "!template/public/logo.png"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "launch-video",
+    "remotion",
+    "video",
+    "social",
+    "readme",
+    "devtools"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/RubenGlez/reelme.git"
+  },
+  "license": "MIT"
+}

package/src/cache.mjs

@@ -0,0 +1,148 @@
+// Cache and scaffold management. The Remotion project never lives in the
+// user's repo: it is scaffolded from the bundled template into
+// ~/.reelme/cache/<project-hash>/ and reused across renders.
+
+import { createHash } from "node:crypto";
+import {
+  cpSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync,
+  rmSync,
+} from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawnSync } from "node:child_process";
+
+export const CACHE_ROOT = join(homedir(), ".reelme", "cache");
+
+const PKG_ROOT = join(dirname(fileURLToPath(import.meta.url)), "..");
+export const TEMPLATE_DIR = join(PKG_ROOT, "template");
+
+const CLI_VERSION = JSON.parse(
+  readFileSync(join(PKG_ROOT, "package.json"), "utf8")
+).version;
+
+// Not copied into the cache scaffold (mirrors the old SKILL.md rsync excludes).
+const SCAFFOLD_EXCLUDES = new Set([
+  "node_modules",
+  "out",
+  "__tests__",
+  ".gitignore",
+  "eslint.config.mjs",
+  "vitest.config.ts",
+  "logo.png", // template sample; users provide their own logo
+]);
+
+export function fail(message) {
+  console.error(`reelme: ${message}`);
+  process.exit(1);
+}
+
+export function loadPlatforms() {
+  return JSON.parse(
+    readFileSync(join(TEMPLATE_DIR, "src", "platforms.json"), "utf8")
+  );
+}
+
+export function readBrief(repoRoot) {
+  const briefPath = join(repoRoot, "reelme.json");
+  if (!existsSync(briefPath)) {
+    fail(
+      `no reelme.json found in ${repoRoot}. Run the /reelme skill to create one.`
+    );
+  }
+  let brief;
+  try {
+    brief = JSON.parse(readFileSync(briefPath, "utf8"));
+  } catch (e) {
+    fail(`reelme.json is not valid JSON: ${e.message}`);
+  }
+  if (brief.schemaVersion !== 2) {
+    fail(
+      `reelme.json has schemaVersion ${brief.schemaVersion ?? "(none)"}; this CLI requires schemaVersion 2. ` +
+        `Briefs with a top-level "scenes" array or a "format" field are v1 — re-run the /reelme skill to migrate.`
+    );
+  }
+  const platforms = loadPlatforms();
+  const ids = brief.project?.platforms;
+  if (!Array.isArray(ids) || ids.length === 0) {
+    fail(
+      `project.platforms is missing or empty. Pick at least one of: ${Object.keys(platforms).join(", ")}.`
+    );
+  }
+  const unknown = ids.filter((id) => !platforms[id]);
+  if (unknown.length > 0) {
+    fail(
+      `unknown platform(s): ${unknown.join(", ")}. Valid platforms: ${Object.keys(platforms).join(", ")}.`
+    );
+  }
+  if (!Array.isArray(brief.cuts?.main) || brief.cuts.main.length === 0) {
+    fail(`cuts.main is missing or empty — the main cut is required.`);
+  }
+  return brief;
+}
+
+export function projectCacheDir(repoRoot) {
+  const hash = createHash("sha256").update(repoRoot).digest("hex").slice(0, 12);
+  return join(CACHE_ROOT, hash);
+}
+
+function run(command, args, cwd) {
+  const result = spawnSync(command, args, { cwd, stdio: "inherit" });
+  if (result.error) fail(`failed to run ${command}: ${result.error.message}`);
+  if (result.status !== 0) {
+    fail(`${command} ${args.join(" ")} exited with status ${result.status}`);
+  }
+}
+
+// Scaffolds (or reuses) the cache project and syncs the user's brief into it.
+// Returns the cache directory. Re-renders never reinstall; a CLI version bump
+// rebuilds the scaffold so template fixes reach every user on next render.
+export function ensureScaffold(repoRoot) {
+  const cacheDir = projectCacheDir(repoRoot);
+  const versionMarker = join(cacheDir, ".reelme-template-version");
+
+  const stale =
+    existsSync(versionMarker) &&
+    readFileSync(versionMarker, "utf8").trim() !== CLI_VERSION;
+  if (stale) {
+    console.log(
+      `reelme: template updated (CLI ${CLI_VERSION}) — rebuilding the cache scaffold.`
+    );
+    rmSync(cacheDir, { recursive: true, force: true });
+  }
+
+  if (!existsSync(join(cacheDir, "package.json"))) {
+    console.log(`reelme: scaffolding Remotion project in ${cacheDir}`);
+    mkdirSync(cacheDir, { recursive: true });
+    cpSync(TEMPLATE_DIR, cacheDir, {
+      recursive: true,
+      filter: (src) => !SCAFFOLD_EXCLUDES.has(basename(src)),
+    });
+    writeFileSync(versionMarker, `${CLI_VERSION}\n`);
+  }
+
+  // The user's brief always wins over the template sample.
+  cpSync(join(repoRoot, "reelme.json"), join(cacheDir, "src", "brief.json"));
+
+  if (!existsSync(join(cacheDir, "node_modules"))) {
+    console.log("reelme: installing render dependencies (first run only)…");
+    run("pnpm", ["install"], cacheDir);
+    // esbuild needs its post-install script; pnpm-workspace.yaml persists the approval.
+    run("pnpm", ["approve-builds", "--all"], cacheDir);
+  }
+
+  return cacheDir;
+}
+
+export function cleanCache() {
+  if (!existsSync(CACHE_ROOT)) {
+    console.log("reelme: cache is already empty.");
+    return;
+  }
+  rmSync(CACHE_ROOT, { recursive: true, force: true });
+  console.log(`reelme: removed ${CACHE_ROOT}`);
+}

package/src/cli.mjs

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+// reelme — thin CLI owning the mechanics (ADR 0003): scaffold in a global
+// cache, render per-platform variants, open Studio, clean up. The agent
+// skill owns the intelligence and writes reelme.json; this CLI never asks
+// questions.
+
+import { spawnSync } from "node:child_process";
+import { ensureScaffold, cleanCache, fail } from "./cache.mjs";
+import { render } from "./render.mjs";
+
+const USAGE = `reelme — launch videos for your repo, rendered locally
+
+Usage: npx reelme <command>
+
+Commands:
+  render   Render every platform in reelme.json to ./reelme-out/
+  studio   Open Remotion Studio against the cached project (preview/tweak)
+  clean    Remove the reelme cache (~/.reelme/cache)
+
+The brief (reelme.json) lives at your repo root — create it with the
+/reelme agent skill: npx skills add RubenGlez/reelme
+`;
+
+function studio(repoRoot) {
+  const cacheDir = ensureScaffold(repoRoot);
+  console.log("reelme: opening Remotion Studio (Ctrl+C to stop)…");
+  const result = spawnSync("pnpm", ["exec", "remotion", "studio"], {
+    cwd: cacheDir,
+    stdio: "inherit",
+  });
+  if (result.error) fail(`failed to open Studio: ${result.error.message}`);
+}
+
+const command = process.argv[2];
+const repoRoot = process.cwd();
+
+switch (command) {
+  case "render":
+    render(repoRoot);
+    break;
+  case "studio":
+    studio(repoRoot);
+    break;
+  case "clean":
+    cleanCache();
+    break;
+  case "--help":
+  case "-h":
+  case "help":
+  case undefined:
+    console.log(USAGE);
+    break;
+  default:
+    console.error(`reelme: unknown command "${command}"\n`);
+    console.log(USAGE);
+    process.exit(1);
+}

package/src/render.mjs

@@ -0,0 +1,47 @@
+// The render command: one output file per selected platform, plus a teaser
+// variant per social platform when the brief has a teaser cut. Outputs land
+// in <repo>/reelme-out/; the heavy Remotion project stays in the cache.
+
+import { cpSync, mkdirSync } from "node:fs";
+import { basename, join } from "node:path";
+import { spawnSync } from "node:child_process";
+import { ensureScaffold, loadPlatforms, readBrief, fail } from "./cache.mjs";
+
+function renderComposition(cacheDir, compositionId, outFile, codec) {
+  const args = ["exec", "remotion", "render", compositionId, join("out", outFile)];
+  if (codec === "gif") args.push("--codec=gif");
+  console.log(`reelme: rendering ${compositionId} → reelme-out/${outFile}`);
+  const result = spawnSync("pnpm", args, { cwd: cacheDir, stdio: "inherit" });
+  if (result.error || result.status !== 0) {
+    fail(`render failed for platform composition "${compositionId}".`);
+  }
+}
+
+export function render(repoRoot) {
+  const brief = readBrief(repoRoot);
+  const platforms = loadPlatforms();
+  const cacheDir = ensureScaffold(repoRoot);
+  const outDir = join(repoRoot, "reelme-out");
+  mkdirSync(outDir, { recursive: true });
+
+  for (const id of brief.project.platforms) {
+    const preset = platforms[id];
+    const outFile = basename(preset.output.file);
+    renderComposition(cacheDir, `Reel-${id}`, outFile, preset.output.codec);
+    cpSync(join(cacheDir, "out", outFile), join(outDir, outFile));
+  }
+
+  const hasTeaser = Array.isArray(brief.cuts.teaser) && brief.cuts.teaser.length > 0;
+  if (hasTeaser) {
+    const socialIds = brief.project.platforms.filter(
+      (id) => platforms[id].output.codec !== "gif"
+    );
+    for (const id of socialIds) {
+      const outFile = `${id}-teaser.mp4`;
+      renderComposition(cacheDir, `Reel-${id}-teaser`, outFile, "h264");
+      cpSync(join(cacheDir, "out", outFile), join(outDir, outFile));
+    }
+  }
+
+  console.log(`reelme: done — outputs in ${outDir}`);
+}

package/template/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "reelme-video",
+  "version": "1.0.0",
+  "private": true,
+  "scripts": {
+    "start": "npx remotion studio",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@remotion/cli": "4.0.290",
+    "@remotion/google-fonts": "4.0.290",
+    "chroma-js": "^3.1.2",
+    "lucide-react": "^0.511.0",
+    "remotion": "4.0.290"
+  },
+  "devDependencies": {
+    "@types/chroma-js": "^2.4.4",
+    "@types/react": "^18.3.0",
+    "@typescript-eslint/eslint-plugin": "^8.0.0",
+    "@typescript-eslint/parser": "^8.0.0",
+    "eslint": "^9.0.0",
+    "react": "^18.3.0",
+    "react-dom": "^18.3.0",
+    "typescript": "^5.4.0",
+    "vitest": "^4.1.0"
+  }
+}