vibemovie 0.1.0

package/dist/cli.d.ts

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+import { R as Ratio, T as Template } from './scenes-CKgKppfK.js';
+import '@pooriaarab/vibe-core';
+
+/**
+ * Package version, kept in sync with package.json (dist ships without it).
+ * Lives in its own module so the CLI entry's is-main guard is never
+ * code-split into a shared chunk.
+ */
+declare const VERSION = "0.1.0";
+
+/**
+ * vibemovie CLI — render a session recap from JSON events, or serve MCP.
+ *
+ *   vibemovie render [file.json] [--ratio 16:9|9:16|1:1] [--template documentary|speedrun|meme]
+ *                    [--out recap.html] [--title "my session"]
+ *   vibemovie mcp        start the MCP server on stdio
+ *   vibemovie --version  ·  vibemovie --help
+ *
+ * Events are read from the file argument, or stdin when piped. The recap is
+ * rendered by the local Hyperframes tier — offline, zero keys.
+ */
+
+declare class CliError extends Error {
+}
+interface CliArgs {
+    command: 'render' | 'mcp' | 'help' | 'version';
+    /** Positional JSON file for `render` (absent → read stdin). */
+    file?: string;
+    ratio: Ratio;
+    template: Template;
+    out: string;
+    title?: string;
+}
+/**
+ * Parse argv (already sliced past node + script). Throws CliError on unknown
+ * flags, missing values, or invalid enum values.
+ */
+declare function parseArgs(argv: readonly string[]): CliArgs;
+declare function main(argv: readonly string[]): Promise<void>;
+
+export { type CliArgs, CliError, VERSION, main, parseArgs };

package/dist/cli.js

@@ -0,0 +1,192 @@
+#!/usr/bin/env node
+import {
+  VERSION
+} from "./chunk-HI6AAJID.js";
+import {
+  RATIOS,
+  TEMPLATES,
+  renderMovie
+} from "./chunk-JTRTKTPK.js";
+
+// src/cli.ts
+import { readFile } from "fs/promises";
+import { pathToFileURL } from "url";
+var CliError = class extends Error {
+};
+var HELP = `vibemovie \u2014 your agent coding session as a short recap video
+
+Usage:
+  vibemovie render [file.json] [options]   render a recap (file or stdin)
+  vibemovie mcp                            start the MCP server (stdio)
+  vibemovie --version                      print version
+  vibemovie --help                         show this help
+
+Options:
+  --ratio 16:9|9:16|1:1                    player aspect ratio (default 16:9)
+  --template documentary|speedrun|meme     caption tone + pacing (default documentary)
+  --out <path>                             output HTML file (default ./vibe-recap.html)
+  --title <name>                           session name on the title card
+
+Input: a JSON array of events (or { "events": [...] }). Each event:
+  { "kind": "task-done", "ts": 1720000000000, "payload": { "label": "..." } }
+
+The recap is rendered on-device by the Hyperframes tier: offline, zero keys.
+`;
+function takeValue(argv, i, flag, inline) {
+  if (inline !== void 0) {
+    if (inline.length === 0) throw new CliError(`${flag} needs a value`);
+    return { value: inline, next: i };
+  }
+  const v = argv[i + 1];
+  if (v === void 0 || v.startsWith("--")) throw new CliError(`${flag} needs a value`);
+  return { value: v, next: i + 1 };
+}
+function parseArgs(argv) {
+  if (argv.length === 0) {
+    return { command: "help", ratio: "16:9", template: "documentary", out: "./vibe-recap.html" };
+  }
+  const args = { command: "render", ratio: "16:9", template: "documentary", out: "./vibe-recap.html" };
+  let sawCommand = false;
+  let sawFile = false;
+  for (let i = 0; i < argv.length; i++) {
+    const tok = argv[i];
+    if (tok === "--help" || tok === "-h") {
+      args.command = "help";
+      continue;
+    }
+    if (tok === "--version" || tok === "-V" || tok === "-v") {
+      args.command = "version";
+      continue;
+    }
+    if (!sawCommand && !tok.startsWith("-")) {
+      if (tok === "render" || tok === "mcp") {
+        args.command = tok;
+        sawCommand = true;
+        continue;
+      }
+      if (tok === "help") {
+        args.command = "help";
+        sawCommand = true;
+        continue;
+      }
+      throw new CliError(`unknown command: ${tok}`);
+    }
+    if (tok.startsWith("--")) {
+      const eq = tok.indexOf("=");
+      const flag = eq === -1 ? tok : tok.slice(0, eq);
+      if (flag !== "--ratio" && flag !== "--template" && flag !== "--out" && flag !== "--title") {
+        throw new CliError(`unknown flag: ${flag}`);
+      }
+      const inline = eq === -1 ? void 0 : tok.slice(eq + 1);
+      const { value, next } = takeValue(argv, i, flag, inline);
+      i = next;
+      if (flag === "--ratio") {
+        if (!RATIOS.includes(value)) {
+          throw new CliError(`invalid --ratio "${value}" (expected ${RATIOS.join("|")})`);
+        }
+        args.ratio = value;
+      } else if (flag === "--template") {
+        if (!TEMPLATES.includes(value)) {
+          throw new CliError(`invalid --template "${value}" (expected ${TEMPLATES.join("|")})`);
+        }
+        args.template = value;
+      } else if (flag === "--out") {
+        args.out = value;
+      } else if (flag === "--title") {
+        args.title = value;
+      } else {
+        throw new CliError(`unknown flag: ${flag}`);
+      }
+      continue;
+    }
+    if (tok.startsWith("-") && tok !== "-") {
+      throw new CliError(`unknown flag: ${tok}`);
+    }
+    if (!sawFile) {
+      args.file = tok;
+      sawFile = true;
+    } else {
+      throw new CliError(`unexpected argument: ${tok}`);
+    }
+  }
+  if (args.command === "mcp" && (args.file !== void 0 || sawFile)) {
+    throw new CliError("mcp takes no input file");
+  }
+  return args;
+}
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+async function readInput(file) {
+  if (file !== void 0 && file !== "-") {
+    try {
+      return await readFile(file, "utf8");
+    } catch {
+      throw new CliError(`cannot read ${file}`);
+    }
+  }
+  if (process.stdin.isTTY) {
+    throw new CliError("no input \u2014 pass a JSON file or pipe events on stdin (try --help)");
+  }
+  return readStdin();
+}
+function parseEvents(json) {
+  let data;
+  try {
+    data = JSON.parse(json);
+  } catch {
+    throw new CliError("input is not valid JSON");
+  }
+  const events = Array.isArray(data) ? data : typeof data === "object" && data !== null && Array.isArray(data.events) ? data.events : null;
+  if (events === null) {
+    throw new CliError('expected a JSON array of events (or { "events": [...] })');
+  }
+  return events;
+}
+async function main(argv) {
+  const args = parseArgs(argv);
+  if (args.command === "help") {
+    process.stdout.write(HELP);
+    return;
+  }
+  if (args.command === "version") {
+    process.stdout.write(`${VERSION}
+`);
+    return;
+  }
+  if (args.command === "mcp") {
+    const { startMcpServer } = await import("./mcp.js");
+    await startMcpServer();
+    return;
+  }
+  const input = await readInput(args.file);
+  const events = parseEvents(input);
+  const result = await renderMovie(events, {
+    ratio: args.ratio,
+    template: args.template,
+    out: args.out,
+    ...args.title !== void 0 ? { title: args.title } : {}
+  });
+  process.stdout.write(`\u2713 recap rendered \u2192 ${result.path}
+`);
+  process.stdout.write("  hyperframes \xB7 offline \xB7 zero keys\n");
+}
+var invokedAsScript = typeof process.argv[1] === "string" && import.meta.url === pathToFileURL(process.argv[1]).href;
+if (invokedAsScript) {
+  main(process.argv.slice(2)).catch((err) => {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`vibemovie: ${msg}
+`);
+    process.exitCode = 1;
+  });
+}
+export {
+  CliError,
+  VERSION,
+  main,
+  parseArgs
+};

package/dist/index.d.ts

@@ -0,0 +1,68 @@
+import { R as Ratio, S as Scene, B as BuildOptions, a as RawEvent } from './scenes-CKgKppfK.js';
+export { D as DiffData, E as EndData, M as MergeData, b as SceneKind, c as TaskRow, d as TasksData, T as Template, e as TermLine, f as TerminalData, g as TitleData, h as Transition, i as buildScenes } from './scenes-CKgKppfK.js';
+import { VibeEvent } from '@pooriaarab/vibe-core';
+export { VibeEvent } from '@pooriaarab/vibe-core';
+
+/**
+ * hyperframes.ts — pure scene-list → self-contained animated HTML renderer.
+ *
+ * The output is a single .html file with all CSS + JS inline: no CDN, no fonts,
+ * no network calls, no external URLs of any kind. Playback is driven entirely by
+ * scene timing (every animation is a pure function of the local scene clock), so
+ * scrubbing to any timestamp lands on the exact in-between state — and rendering
+ * is deterministic: the same scenes always produce byte-identical HTML.
+ *
+ * The scene engine (timeline, transitions, scrubber, per-scene animators) is
+ * adapted from docs/prototype.html.
+ */
+
+interface RenderOptions {
+    /** Player aspect ratio. Default '16:9'. */
+    ratio?: Ratio;
+    /** Document <title>. Default: the session name from the title scene. */
+    title?: string;
+}
+/**
+ * Render a scene list into a self-contained animated HTML document.
+ * PURE and deterministic: identical input → identical output string.
+ */
+declare function renderHyperframes(scenes: readonly Scene[], opts?: RenderOptions): string;
+
+/**
+ * @pooriaarab/vibemovie — your agent coding session as a short recap video.
+ *
+ * v0 ships the Hyperframes tier of the vibe-core video cascade: a recap "movie"
+ * is a self-contained animated HTML page rendered 100% on-device — no gen-video
+ * model, no API key, no network. The cascade seam is real: gen-video providers
+ * (Sora, Wavespeed, …) can later be registered as tier-1/2 providers without
+ * touching this API; the consent ledger gates their egress.
+ *
+ * ```ts
+ * import { renderMovie } from '@pooriaarab/vibemovie';
+ * const { html, path } = await renderMovie(events, { ratio: '9:16', out: 'recap.html' });
+ * ```
+ */
+
+interface RenderMovieOptions extends BuildOptions, RenderOptions {
+    /** When set, the HTML is also written to this path. */
+    out?: string;
+}
+interface RenderMovieResult {
+    /** The self-contained recap HTML (always returned, whether or not `out` was set). */
+    html: string;
+    /** Absolute or relative path the HTML was written to — only when `opts.out` was set. */
+    path?: string;
+}
+/**
+ * Compile events → scenes → a self-contained animated HTML recap.
+ *
+ * Rendering goes through the vibe-core cascade with egress disabled and an
+ * in-memory consent ledger, so it always resolves to the local Hyperframes
+ * runner — this call works offline with zero keys. (The cascade is the seam
+ * for future gen-video tiers; they are not registered in v0.)
+ *
+ * When `opts.out` is set the HTML is also written to disk (the only IO here).
+ */
+declare function renderMovie(events: readonly (VibeEvent | RawEvent)[], opts?: RenderMovieOptions): Promise<RenderMovieResult>;
+
+export { BuildOptions, Ratio, RawEvent, type RenderMovieOptions, type RenderMovieResult, type RenderOptions, Scene, renderHyperframes, renderMovie };

package/dist/index.js

@@ -0,0 +1,10 @@
+import {
+  buildScenes,
+  renderHyperframes,
+  renderMovie
+} from "./chunk-JTRTKTPK.js";
+export {
+  buildScenes,
+  renderHyperframes,
+  renderMovie
+};

package/dist/mcp.d.ts

@@ -0,0 +1,13 @@
+/**
+ * vibemovie MCP server (stdio) — lets an agent render a session recap.
+ *
+ * Exposes one tool, `render`: { events, ratio?, template?, out? } → the recap
+ * HTML (or the output path when `out` is given). Rendering is the local
+ * Hyperframes tier, so the tool works offline with zero keys.
+ *
+ * Uses the SDK's low-level Server with a plain JSON Schema for input — no
+ * schema-library dependency beyond the SDK itself.
+ */
+declare function startMcpServer(): Promise<void>;
+
+export { startMcpServer };

package/dist/mcp.js

@@ -0,0 +1,80 @@
+import {
+  VERSION
+} from "./chunk-HI6AAJID.js";
+import {
+  RATIOS,
+  TEMPLATES,
+  renderMovie
+} from "./chunk-JTRTKTPK.js";
+
+// src/mcp.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { pathToFileURL } from "url";
+var RENDER_TOOL = {
+  name: "render",
+  description: 'Render an agent coding session as a recap "movie" \u2014 a self-contained animated HTML page (Hyperframes tier: offline, zero keys, no data out). Returns the HTML, or the output path when `out` is set.',
+  inputSchema: {
+    type: "object",
+    properties: {
+      events: {
+        type: "array",
+        items: { type: "object" },
+        description: 'Session events: [{ "kind": "task-done", "ts": 1720000000000, "payload": { "label": "..." } }, ...]. Known kinds: task-done, tests-pass, tests-fail, error, pr-opened, pr-merged, session-end. Payload fields used: label, durationMin, files, additions, deletions, filesChanged, pr, branch, reviewers, passed.'
+      },
+      ratio: { type: "string", enum: [...RATIOS], description: "Player aspect ratio (default 16:9)." },
+      template: { type: "string", enum: [...TEMPLATES], description: "Caption tone + pacing (default documentary)." },
+      title: { type: "string", description: "Session name on the title card." },
+      out: { type: "string", description: "Optional path to write the HTML to." }
+    },
+    required: ["events"]
+  }
+};
+function enumArg(value, name, allowed) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "string" || !allowed.includes(value)) {
+    throw new Error(`render: "${name}" must be one of ${allowed.join(", ")}`);
+  }
+  return value;
+}
+async function startMcpServer() {
+  const server = new Server({ name: "vibemovie", version: VERSION }, { capabilities: { tools: {} } });
+  server.setRequestHandler(ListToolsRequestSchema, () => Promise.resolve({ tools: [RENDER_TOOL] }));
+  server.setRequestHandler(CallToolRequestSchema, async (req) => {
+    if (req.params.name !== "render") {
+      throw new Error(`unknown tool: ${req.params.name}`);
+    }
+    const args = req.params.arguments ?? {};
+    if (!Array.isArray(args["events"])) {
+      throw new Error('render: "events" must be an array of event objects');
+    }
+    const ratio = enumArg(args["ratio"], "ratio", RATIOS);
+    const template = enumArg(args["template"], "template", TEMPLATES);
+    const title = args["title"];
+    const out = args["out"];
+    if (title !== void 0 && typeof title !== "string") throw new Error('render: "title" must be a string');
+    if (out !== void 0 && typeof out !== "string") throw new Error('render: "out" must be a string');
+    const result = await renderMovie(args["events"], {
+      ...ratio !== void 0 ? { ratio } : {},
+      ...template !== void 0 ? { template } : {},
+      ...title !== void 0 ? { title } : {},
+      ...out !== void 0 ? { out } : {}
+    });
+    const text = result.path !== void 0 ? `vibemovie recap written to ${result.path} (hyperframes \xB7 offline \xB7 zero keys)` : result.html;
+    return { content: [{ type: "text", text }] };
+  });
+  await server.connect(new StdioServerTransport());
+}
+var invokedAsScript = typeof process.argv[1] === "string" && import.meta.url === pathToFileURL(process.argv[1]).href;
+if (invokedAsScript) {
+  startMcpServer().catch((err) => {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`vibemovie mcp: ${msg}
+`);
+    process.exitCode = 1;
+  });
+}
+export {
+  startMcpServer
+};

package/dist/scenes-CKgKppfK.d.ts

@@ -0,0 +1,118 @@
+import { VibeEvent } from '@pooriaarab/vibe-core';
+
+/**
+ * scenes.ts — pure events → scene-list compiler.
+ *
+ * Takes normalized `VibeEvent`s (from vibe-core) or loose `RawEvent`s (anything a
+ * harness/logger might emit) and compiles them into an ordered, fully-described
+ * scene list for the Hyperframes renderer. No IO, no randomness, no clock — the
+ * same events always produce the same scenes, which makes this unit-testable and
+ * the rendered HTML deterministic.
+ */
+
+type Ratio = '16:9' | '9:16' | '1:1';
+type Template = 'documentary' | 'speedrun' | 'meme';
+type Transition = 'fade' | 'slide' | 'scale' | 'rise';
+type SceneKind = 'title' | 'tasks' | 'diff' | 'terminal' | 'merge' | 'end';
+/**
+ * A loosely-shaped event from any source: a harness transcript export, a JSON
+ * log, a hand-written fixture. Any field may be missing; known aliases
+ * (`type`/`timestamp`) are normalized.
+ */
+interface RawEvent {
+    kind?: string;
+    type?: string;
+    ts?: number;
+    timestamp?: number | string;
+    agent?: string;
+    cwd?: string;
+    payload?: Record<string, unknown>;
+}
+interface BuildOptions {
+    /** Accepted for API symmetry with the renderer; layout is a render-time concern. */
+    ratio?: Ratio;
+    /** Caption tone + pacing. Default 'documentary'. */
+    template?: Template;
+    /** Session name for the title card. Default: basename of the events' cwd. */
+    title?: string;
+}
+interface TitleData {
+    sessionName: string;
+    /** Total session length in whole minutes, counted up during the title scene. */
+    totalMinutes: number;
+    subtitle: string;
+}
+interface TaskRow {
+    label: string;
+    durationMin?: number;
+}
+interface TasksData {
+    /** Real number of completed tasks (may exceed `tasks.length`). */
+    total: number;
+    /** Rows actually shown (capped at MAX_TASK_ROWS). */
+    tasks: TaskRow[];
+}
+interface DiffData {
+    filesChanged: number;
+    additions: number;
+    deletions: number;
+    /** Up to 4 representative file paths. */
+    files: string[];
+}
+interface TermLine {
+    text: string;
+    cls: 'ok' | '';
+}
+interface TerminalData {
+    lines: TermLine[];
+}
+interface MergeData {
+    pr: number | null;
+    branch: string;
+    reviewers: number | null;
+    merged: boolean;
+}
+interface EndData {
+    tagline: string;
+}
+interface SceneBase {
+    /** DOM id in the rendered page, `scene-<kind>`. */
+    id: string;
+    transition: Transition;
+    /** Milliseconds on the timeline. */
+    duration: number;
+    /** Narrator caption shown while the scene is live. */
+    caption: string;
+}
+type Scene = (SceneBase & {
+    kind: 'title';
+    data: TitleData;
+}) | (SceneBase & {
+    kind: 'tasks';
+    data: TasksData;
+}) | (SceneBase & {
+    kind: 'diff';
+    data: DiffData;
+}) | (SceneBase & {
+    kind: 'terminal';
+    data: TerminalData;
+}) | (SceneBase & {
+    kind: 'merge';
+    data: MergeData;
+}) | (SceneBase & {
+    kind: 'end';
+    data: EndData;
+});
+/**
+ * Compile events into an ordered scene list.
+ *
+ * Always emits a title card and an end card; the middle scenes appear only when
+ * the events carry the data for them (tasks → task ticks, file/diff stats →
+ * animated diff, notable command events → terminal moment, PR event → merge
+ * celebration). Empty input yields `[title, end]`.
+ *
+ * PURE: no IO, no clock, no randomness.
+ */
+declare function buildScenes(events: readonly (VibeEvent | RawEvent)[], opts?: BuildOptions): Scene[];
+
+export { type BuildOptions as B, type DiffData as D, type EndData as E, type MergeData as M, type Ratio as R, type Scene as S, type Template as T, type RawEvent as a, type SceneKind as b, type TaskRow as c, type TasksData as d, type TermLine as e, type TerminalData as f, type TitleData as g, type Transition as h, buildScenes as i };

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "vibemovie",
+  "version": "0.1.0",
+  "description": "Your agent coding session as a short recap video — Hyperframes (HTML/CSS/JS) with zero gen-video keys, or your own video model. For Claude Code, Codex, Gemini, and other agentic CLIs. Local-first.",
+  "type": "module",
+  "license": "MIT",
+  "author": "Pooria Arab",
+  "bin": {
+    "vibemovie": "./dist/cli.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts src/cli.ts src/mcp.ts --format esm --dts --clean",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "@pooriaarab/vibe-core": "^0.1.0",
+    "@modelcontextprotocol/sdk": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.4.0",
+    "vitest": "^1.6.0"
+  },
+  "homepage": "https://github.com/pooriaarab/vibemovie#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pooriaarab/vibemovie.git"
+  },
+  "bugs": {
+    "url": "https://github.com/pooriaarab/vibemovie/issues"
+  },
+  "keywords": [
+    "vibe-suite",
+    "vibemovie",
+    "claude-code",
+    "codex",
+    "agentic",
+    "cli",
+    "mcp",
+    "video",
+    "hyperframes",
+    "local-first"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}