demo-dev 0.0.1-alpha.0

package/src/cli.ts

@@ -0,0 +1,337 @@
+import { join } from "node:path";
+import { defineCommand, runMain } from "citty";
+import * as p from "@clack/prompts";
+import { buildDiffContext } from "./lib/git.js";
+import { writeJson } from "./lib/fs.js";
+import { buildDemoPlan } from "./planner/index.js";
+import { capturePlanContinuous } from "./capture/continuous-capture.js";
+import { buildVoiceScript } from "./voice/script.js";
+import { synthesizeVoice } from "./voice/tts.js";
+import { buildVisualPlan } from "./render/visual-plan.js";
+import { composeVideo } from "./render/ffmpeg-compose.js";
+import { upsertPrComment } from "./github/comment.js";
+import { buildExecutablePlan, runPipeline } from "./orchestrate.js";
+import { bootstrapAuth } from "./auth/bootstrap.js";
+import { listAvailableProviders } from "./ai/provider.js";
+import { applyProjectEnvironment, getProjectConfigField, loadProjectConfig } from "./config/project.js";
+import { initProject } from "./setup/init.js";
+import { runDoctor } from "./setup/doctor.js";
+
+// ---------------------------------------------------------------------------
+// Shared args & helpers
+// ---------------------------------------------------------------------------
+
+const sharedArgs = {
+  "base-url": { type: "string" as const, description: "Base URL of the web app" },
+  "base-ref": { type: "string" as const, description: "Git base ref", default: "origin/main" },
+  "output-dir": { type: "string" as const, description: "Output directory", default: "artifacts" },
+  config: { type: "string" as const, description: "Path to demo.dev.config.json" },
+} as const;
+
+const resolveConfig = async (args: Record<string, unknown>) => {
+  const { path: configPath, config: projectConfig } = await loadProjectConfig(args.config as string | undefined);
+  applyProjectEnvironment(projectConfig);
+  return {
+    configPath,
+    projectConfig,
+    baseRef: (args["base-ref"] as string) ?? projectConfig.baseRef ?? "origin/main",
+    outputDir: (args["output-dir"] as string) ?? projectConfig.outputDir ?? "artifacts",
+    baseUrl: (args["base-url"] as string) ?? projectConfig.baseUrl,
+  };
+};
+
+const requireBaseUrl = (baseUrl: string | undefined, command: string) => {
+  if (!baseUrl) {
+    p.log.error(`${command} requires --base-url or baseUrl in demo.dev.config.json`);
+    process.exit(1);
+  }
+  return baseUrl;
+};
+
+// ---------------------------------------------------------------------------
+// Commands
+// ---------------------------------------------------------------------------
+
+const init = defineCommand({
+  meta: { name: "init", description: "Initialize demo.dev config in a project" },
+  args: {
+    ...sharedArgs,
+    force: { type: "boolean", description: "Overwrite existing config" },
+  },
+  async run({ args }) {
+    const { projectConfig, baseUrl, baseRef, outputDir } = await resolveConfig(args);
+    const s = p.spinner();
+    s.start("Creating config");
+    const result = await initProject({
+      force: args.force,
+      existingConfig: { ...projectConfig, baseUrl, baseRef, outputDir },
+    });
+    s.stop("Config created");
+    p.log.success(`Config → ${result.configPath}`);
+    p.log.success(`Workflow → ${result.workflowPath}`);
+  },
+});
+
+const doctor = defineCommand({
+  meta: { name: "doctor", description: "Check environment and config" },
+  args: sharedArgs,
+  async run({ args }) {
+    const { configPath, projectConfig, baseUrl, baseRef, outputDir } = await resolveConfig(args);
+    const result = await runDoctor({ configPath, config: { ...projectConfig, baseUrl, baseRef, outputDir } });
+    if (!result.ok) process.exitCode = 1;
+  },
+});
+
+const config = defineCommand({
+  meta: { name: "config", description: "Show resolved project config" },
+  args: {
+    ...sharedArgs,
+    field: { type: "string", description: "Get a single config field" },
+  },
+  async run({ args }) {
+    const { configPath, projectConfig } = await resolveConfig(args);
+    if (args.field) {
+      console.log(getProjectConfigField(projectConfig, args.field) ?? "");
+      return;
+    }
+    console.log(JSON.stringify({
+      path: configPath,
+      ...projectConfig,
+      readyUrl: projectConfig.readyUrl ?? projectConfig.baseUrl,
+    }, null, 2));
+  },
+});
+
+const providers = defineCommand({
+  meta: { name: "providers", description: "List available AI/TTS providers" },
+  async run() {
+    const list = await listAvailableProviders();
+    console.log(JSON.stringify(list, null, 2));
+  },
+});
+
+const plan = defineCommand({
+  meta: { name: "plan", description: "Generate a demo plan from the current diff" },
+  args: sharedArgs,
+  async run({ args }) {
+    const { projectConfig, baseRef, outputDir } = await resolveConfig(args);
+    const s = p.spinner();
+    s.start("Analyzing diff");
+    const context = await buildDiffContext(baseRef);
+    s.stop("Diff analyzed");
+    s.start("Planning demo scenes");
+    const demoPlan = await buildDemoPlan(context, projectConfig);
+    s.stop(`Planned ${demoPlan.scenes.length} scenes`);
+    await writeJson(join(outputDir, "demo-context.json"), context);
+    await writeJson(join(outputDir, "demo-plan.json"), demoPlan);
+    p.log.success(`Plan → ${join(outputDir, "demo-plan.json")}`);
+  },
+});
+
+const probe = defineCommand({
+  meta: { name: "probe", description: "Plan + probe pages to refine the demo" },
+  args: sharedArgs,
+  async run({ args }) {
+    const { projectConfig, baseRef, outputDir, baseUrl } = await resolveConfig(args);
+    const resolvedUrl = requireBaseUrl(baseUrl, "probe");
+    const s = p.spinner();
+    s.start("Building executable plan");
+    const result = await buildExecutablePlan({ baseRef, baseUrl: resolvedUrl, outputDir, projectConfig });
+    s.stop(`Refined ${result.plan.scenes.length} scenes`);
+    p.log.success(`Plan → ${join(outputDir, "demo-plan.json")}`);
+  },
+});
+
+const auth = defineCommand({
+  meta: { name: "auth", description: "Bootstrap browser auth (login + save session)" },
+  args: {
+    ...sharedArgs,
+    email: { type: "string", description: "Login email" },
+    password: { type: "string", description: "Login password" },
+    "storage-state": { type: "string", description: "Path to save storage state" },
+  },
+  async run({ args }) {
+    const { projectConfig, baseUrl, outputDir } = await resolveConfig(args);
+    const resolvedUrl = requireBaseUrl(baseUrl, "auth");
+    const email = args.email ?? process.env.DEMO_LOGIN_EMAIL;
+    const password = args.password ?? process.env.DEMO_LOGIN_PASSWORD;
+    const storageStatePath = args["storage-state"]
+      ?? projectConfig.saveStorageStatePath
+      ?? process.env.DEMO_SAVE_STORAGE_STATE
+      ?? join(outputDir, "storage-state.json");
+
+    if (!email || !password) {
+      p.log.error("Requires --email and --password, or DEMO_LOGIN_EMAIL / DEMO_LOGIN_PASSWORD env vars");
+      process.exit(1);
+    }
+
+    const s = p.spinner();
+    s.start("Logging in");
+    const result = await bootstrapAuth({
+      baseUrl: resolvedUrl, email, password,
+      outputPath: storageStatePath,
+      auth: projectConfig.auth,
+    });
+    s.stop("Logged in");
+    p.log.success(`Session → ${result.storageStatePath}`);
+  },
+});
+
+const capture = defineCommand({
+  meta: { name: "capture", description: "Continuous browser capture with screencast + ghost-cursor" },
+  args: sharedArgs,
+  async run({ args }) {
+    const { projectConfig, baseRef, outputDir, baseUrl } = await resolveConfig(args);
+    const resolvedUrl = requireBaseUrl(baseUrl, "capture");
+    const s = p.spinner();
+    s.start("Building plan");
+    const { plan: demoPlan } = await buildExecutablePlan({ baseRef, baseUrl: resolvedUrl, outputDir, projectConfig });
+    s.stop(`${demoPlan.scenes.length} scenes planned`);
+    s.start("Recording (screencast + ghost-cursor)");
+    const result = await capturePlanContinuous(demoPlan, { baseUrl: resolvedUrl, outputDir: join(outputDir, "captures") });
+    s.stop(`Recorded ${(result.totalDurationMs / 1000).toFixed(1)}s`);
+    await writeJson(join(outputDir, "continuous-capture.json"), {
+      videoPath: result.videoPath,
+      sceneMarkers: result.sceneMarkers,
+      interactions: result.interactions,
+      totalDurationMs: result.totalDurationMs,
+      viewport: result.viewport,
+      cursorSamples: result.cursorLog.length,
+    });
+    p.log.success(`Video → ${result.videoPath}`);
+  },
+});
+
+const voice = defineCommand({
+  meta: { name: "voice", description: "Generate TTS narration from the demo plan" },
+  args: sharedArgs,
+  async run({ args }) {
+    const { projectConfig, baseRef, outputDir } = await resolveConfig(args);
+    const s = p.spinner();
+    s.start("Generating plan");
+    const context = await buildDiffContext(baseRef);
+    const demoPlan = await buildDemoPlan(context, projectConfig);
+    s.stop(`${demoPlan.scenes.length} scenes`);
+    s.start("Synthesizing voice");
+    const lines = await synthesizeVoice(buildVoiceScript(demoPlan), { outputDir: join(outputDir, "audio") });
+    s.stop(`${lines.filter(l => l.audioPath).length} audio files generated`);
+    await writeJson(join(outputDir, "voice-script.json"), lines);
+    p.log.success(`Voice → ${join(outputDir, "voice-script.json")}`);
+  },
+});
+
+const render = defineCommand({
+  meta: { name: "render", description: "Capture + voice + FFmpeg compose → mp4" },
+  args: {
+    ...sharedArgs,
+    out: { type: "string", description: "Output video path" },
+  },
+  async run({ args }) {
+    const { projectConfig, baseRef, outputDir, baseUrl } = await resolveConfig(args);
+    const resolvedUrl = requireBaseUrl(baseUrl, "render");
+    const s = p.spinner();
+
+    s.start("Building plan");
+    const { plan: demoPlan } = await buildExecutablePlan({ baseRef, baseUrl: resolvedUrl, outputDir, projectConfig });
+    s.stop(`${demoPlan.scenes.length} scenes`);
+
+    s.start("Recording");
+    const captureResult = await capturePlanContinuous(demoPlan, { baseUrl: resolvedUrl, outputDir: join(outputDir, "captures") });
+    s.stop(`Recorded ${(captureResult.totalDurationMs / 1000).toFixed(1)}s`);
+
+    s.start("Generating voice");
+    const voicedLines = await synthesizeVoice(buildVoiceScript(demoPlan), { outputDir: join(outputDir, "audio") });
+    s.stop(`${voicedLines.filter(l => l.audioPath).length} audio tracks`);
+
+    const visualPlan = buildVisualPlan(captureResult);
+    const bgmPath = process.env.DEMO_BGM_PATH;
+    const bgmVolume = process.env.DEMO_BGM_VOLUME ? Number(process.env.DEMO_BGM_VOLUME) : undefined;
+    const out = args.out ?? join(outputDir, "pr-demo.mp4");
+
+    s.start("Composing video");
+    const videoPath = await composeVideo({
+      videoPath: captureResult.videoPath, outputPath: out, visualPlan, capture: captureResult,
+      voiceLines: voicedLines,
+      bgm: bgmPath ? { path: bgmPath, volume: bgmVolume } : undefined,
+      title: demoPlan.title,
+    });
+    s.stop("Video composed");
+    p.log.success(`Video → ${videoPath}`);
+  },
+});
+
+const comment = defineCommand({
+  meta: { name: "comment", description: "Post demo artifacts as a PR comment" },
+  args: {
+    ...sharedArgs,
+    "pr-number": { type: "string", description: "PR number to comment on" },
+  },
+  async run({ args }) {
+    const { outputDir } = await resolveConfig(args);
+    if (args["pr-number"]) process.env.DEMO_PR_NUMBER = args["pr-number"];
+    const s = p.spinner();
+    s.start("Posting PR comment");
+    await upsertPrComment({ outputDir });
+    s.stop("Comment posted");
+  },
+});
+
+const demo = defineCommand({
+  meta: { name: "demo", description: "Full pipeline: plan → capture → voice → render → mp4" },
+  args: {
+    ...sharedArgs,
+    prompt: { type: "string", description: "Natural language prompt describing the demo (skips diff-based planning)" },
+    quality: { type: "enum", options: ["draft", "standard", "high"], description: "Video quality preset", default: "standard" },
+    frame: { type: "boolean", description: "Wrap in a Screen Studio–style browser frame with gradient background" },
+  },
+  async run({ args }) {
+    const { projectConfig, baseRef, outputDir, baseUrl } = await resolveConfig(args);
+    const resolvedUrl = requireBaseUrl(baseUrl, "demo");
+
+    p.intro("demo.dev");
+
+    if (args.prompt) {
+      p.log.info(`Prompt mode: "${args.prompt}"`);
+    }
+
+    const result = await runPipeline({
+      baseRef, baseUrl: resolvedUrl, outputDir, projectConfig, renderVideo: true,
+      prompt: args.prompt,
+      quality: args.quality as "draft" | "standard" | "high",
+      frame: args.frame,
+    });
+
+    if (result.videoPath) {
+      p.log.success(`Video → ${result.videoPath}`);
+    }
+    p.outro(`Done → ${outputDir}`);
+  },
+});
+
+// ---------------------------------------------------------------------------
+// Root command
+// ---------------------------------------------------------------------------
+
+const main = defineCommand({
+  meta: {
+    name: "demo-dev",
+    version: "0.2.0",
+    description: "Turn pull requests into polished product demos",
+  },
+  subCommands: {
+    demo,
+    init,
+    doctor,
+    config,
+    providers,
+    plan,
+    probe,
+    auth,
+    capture,
+    voice,
+    render,
+    comment,
+  },
+});
+
+runMain(main);

package/src/config/project.ts

@@ -0,0 +1,183 @@
+import { access, readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import type { ActionTarget } from "../types.js";
+
+export interface ProjectAuthConfig {
+  loginPath?: string;
+  emailTarget?: ActionTarget;
+  passwordTarget?: ActionTarget;
+  submitTarget?: ActionTarget;
+  successUrlPattern?: string;
+  postSubmitWaitMs?: number;
+}
+
+export interface ProjectConfig {
+  projectName?: string;
+  baseUrl?: string;
+  readyUrl?: string;
+  devCommand?: string;
+  baseRef?: string;
+  outputDir?: string;
+  storageStatePath?: string;
+  saveStorageStatePath?: string;
+  preferredRoutes?: string[];
+  featureHints?: string[];
+  authRequiredRoutes?: string[];
+  auth?: ProjectAuthConfig;
+}
+
+const DEFAULT_CONFIG_PATHS = ["demo.dev.config.json", ".demo-dev.json"];
+
+const fileExists = async (path: string) => {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+const isRecord = (value: unknown): value is Record<string, unknown> => {
+  return typeof value === "object" && value !== null;
+};
+
+const readStringArray = (value: unknown): string[] | undefined => {
+  if (!Array.isArray(value)) return undefined;
+  const items = value.filter((item): item is string => typeof item === "string");
+  return items.length > 0 ? items : undefined;
+};
+
+const readTarget = (value: unknown): ActionTarget | undefined => {
+  if (!isRecord(value) || typeof value.strategy !== "string") return undefined;
+
+  switch (value.strategy) {
+    case "label":
+    case "text":
+    case "placeholder":
+      if (typeof value.value === "string") {
+        return {
+          strategy: value.strategy,
+          value: value.value,
+          exact: typeof value.exact === "boolean" ? value.exact : undefined,
+        };
+      }
+      return undefined;
+    case "testId":
+    case "css":
+      if (typeof value.value === "string") {
+        return { strategy: value.strategy, value: value.value };
+      }
+      return undefined;
+    case "role":
+      if (typeof value.role === "string") {
+        return {
+          strategy: "role",
+          role: value.role,
+          name: typeof value.name === "string" ? value.name : undefined,
+          exact: typeof value.exact === "boolean" ? value.exact : undefined,
+        };
+      }
+      return undefined;
+    default:
+      return undefined;
+  }
+};
+
+const normalizeAuthConfig = (value: unknown): ProjectAuthConfig | undefined => {
+  if (!isRecord(value)) return undefined;
+
+  return {
+    loginPath: typeof value.loginPath === "string" ? value.loginPath : undefined,
+    emailTarget: readTarget(value.emailTarget),
+    passwordTarget: readTarget(value.passwordTarget),
+    submitTarget: readTarget(value.submitTarget),
+    successUrlPattern: typeof value.successUrlPattern === "string" ? value.successUrlPattern : undefined,
+    postSubmitWaitMs: typeof value.postSubmitWaitMs === "number" ? value.postSubmitWaitMs : undefined,
+  };
+};
+
+const normalizeProjectConfig = (value: unknown): ProjectConfig => {
+  if (!isRecord(value)) return {};
+
+  return {
+    projectName: typeof value.projectName === "string" ? value.projectName : undefined,
+    baseUrl: typeof value.baseUrl === "string" ? value.baseUrl : undefined,
+    readyUrl: typeof value.readyUrl === "string" ? value.readyUrl : undefined,
+    devCommand: typeof value.devCommand === "string" ? value.devCommand : undefined,
+    baseRef: typeof value.baseRef === "string" ? value.baseRef : undefined,
+    outputDir: typeof value.outputDir === "string" ? value.outputDir : undefined,
+    storageStatePath: typeof value.storageStatePath === "string" ? value.storageStatePath : undefined,
+    saveStorageStatePath: typeof value.saveStorageStatePath === "string" ? value.saveStorageStatePath : undefined,
+    preferredRoutes: readStringArray(value.preferredRoutes),
+    featureHints: readStringArray(value.featureHints),
+    authRequiredRoutes: readStringArray(value.authRequiredRoutes),
+    auth: normalizeAuthConfig(value.auth),
+  };
+};
+
+export const loadProjectConfig = async (configPath?: string): Promise<{ path?: string; config: ProjectConfig }> => {
+  const explicitPath = configPath ?? process.env.DEMO_CONFIG;
+  const candidatePaths = explicitPath ? [explicitPath] : DEFAULT_CONFIG_PATHS;
+
+  for (const candidate of candidatePaths) {
+    const absolutePath = resolve(candidate);
+    if (!(await fileExists(absolutePath))) continue;
+
+    const parsed = JSON.parse(await readFile(absolutePath, "utf8")) as unknown;
+    return {
+      path: absolutePath,
+      config: normalizeProjectConfig(parsed),
+    };
+  }
+
+  return { config: {} };
+};
+
+export const applyProjectEnvironment = (config: ProjectConfig) => {
+  if (!process.env.DEMO_STORAGE_STATE && config.storageStatePath) {
+    process.env.DEMO_STORAGE_STATE = config.storageStatePath;
+  }
+
+  if (!process.env.DEMO_SAVE_STORAGE_STATE && config.saveStorageStatePath) {
+    process.env.DEMO_SAVE_STORAGE_STATE = config.saveStorageStatePath;
+  }
+};
+
+export const getProjectConfigField = (config: ProjectConfig, field: string): string | undefined => {
+  switch (field) {
+    case "projectName":
+      return config.projectName;
+    case "baseUrl":
+      return config.baseUrl;
+    case "readyUrl":
+      return config.readyUrl ?? config.baseUrl;
+    case "devCommand":
+      return config.devCommand;
+    case "baseRef":
+      return config.baseRef;
+    case "outputDir":
+      return config.outputDir;
+    case "storageStatePath":
+      return config.storageStatePath;
+    case "saveStorageStatePath":
+      return config.saveStorageStatePath;
+    case "preferredRoutes":
+      return config.preferredRoutes ? JSON.stringify(config.preferredRoutes) : undefined;
+    case "featureHints":
+      return config.featureHints ? JSON.stringify(config.featureHints) : undefined;
+    case "authRequiredRoutes":
+      return config.authRequiredRoutes ? JSON.stringify(config.authRequiredRoutes) : undefined;
+    case "auth.loginPath":
+      return config.auth?.loginPath;
+    default:
+      return undefined;
+  }
+};
+
+export const summarizeProjectHints = (config: ProjectConfig) => {
+  return {
+    preferredRoutes: config.preferredRoutes ?? [],
+    featureHints: config.featureHints ?? [],
+    authRequiredRoutes: config.authRequiredRoutes ?? [],
+  };
+};

package/src/github/comment.ts

@@ -0,0 +1,134 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import type { DemoPlan } from "../types.js";
+
+const COMMENT_MARKER = "<!-- demo-dev-pr-comment -->";
+
+interface PullRequestPayload {
+  pull_request?: { number?: number };
+}
+
+const readJson = async <T>(path: string): Promise<T> => JSON.parse(await readFile(path, "utf8")) as T;
+
+const getRequiredEnv = (name: string) => {
+  const value = process.env[name];
+  if (!value) throw new Error(`Missing environment variable: ${name}`);
+  return value;
+};
+
+const getPrNumber = async () => {
+  const direct = process.env.DEMO_PR_NUMBER;
+  if (direct) return Number(direct);
+
+  const eventPath = process.env.GITHUB_EVENT_PATH;
+  if (!eventPath) return undefined;
+  const payload = await readJson<PullRequestPayload>(eventPath);
+  return payload.pull_request?.number;
+};
+
+const buildRunUrl = () => {
+  const serverUrl = process.env.GITHUB_SERVER_URL;
+  const repository = process.env.GITHUB_REPOSITORY;
+  const runId = process.env.GITHUB_RUN_ID;
+  if (!serverUrl || !repository || !runId) return undefined;
+  return `${serverUrl}/${repository}/actions/runs/${runId}`;
+};
+
+const code = (value: string) => `\`${value}\``;
+
+const buildArtifactSummary = (outputDir: string) => {
+  return [
+    `- Video: ${code(join(outputDir, "pr-demo.mp4"))}`,
+    `- Cover: ${code(join(outputDir, "cover.png"))}`,
+    `- Manifest: ${code(join(outputDir, "render-manifest.json"))}`,
+  ].join("\n");
+};
+
+const buildBody = (plan: DemoPlan, outputDir: string) => {
+  const runUrl = buildRunUrl();
+  const sceneLines = plan.scenes.map((scene) => `- **${scene.title}** · ${scene.caption}`).join("\n");
+
+  return [
+    COMMENT_MARKER,
+    "## 🎬 PR Demo generated",
+    "",
+    plan.summary,
+    "",
+    runUrl ? `- Workflow run: ${runUrl}` : undefined,
+    "- Artifacts: download `pr-demo-artifacts` from this workflow run",
+    "",
+    "### Scenes",
+    sceneLines,
+    "",
+    "### Output files",
+    buildArtifactSummary(outputDir),
+    "",
+    "The cover has been exported as `cover.png`, and the video has been exported as `pr-demo.mp4`.",
+  ]
+    .filter(Boolean)
+    .join("\n");
+};
+
+const request = async (path: string, init: RequestInit) => {
+  const token = getRequiredEnv("GITHUB_TOKEN");
+  const apiUrl = process.env.GITHUB_API_URL ?? "https://api.github.com";
+
+  const response = await fetch(`${apiUrl}${path}`, {
+    ...init,
+    headers: {
+      authorization: `Bearer ${token}`,
+      accept: "application/vnd.github+json",
+      "content-type": "application/json",
+      ...(init.headers ?? {}),
+    },
+  });
+
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`GitHub API error: ${response.status} ${errorText}`);
+  }
+
+  return response;
+};
+
+const findExistingCommentId = async (repository: string, prNumber: number) => {
+  const response = await request(`/repos/${repository}/issues/${prNumber}/comments?per_page=100`, {
+    method: "GET",
+  });
+  const comments = (await response.json()) as Array<{ id: number; body?: string }>;
+  return comments.find((comment) => comment.body?.includes(COMMENT_MARKER))?.id;
+};
+
+export const upsertPrComment = async (options: { outputDir: string }) => {
+  const repository = process.env.GITHUB_REPOSITORY;
+  const token = process.env.GITHUB_TOKEN;
+  if (!repository || !token) {
+    console.log("Missing GitHub context, skipping PR comment.");
+    return;
+  }
+
+  const prNumber = await getPrNumber();
+  if (!prNumber) {
+    console.log("No PR number found, skipping PR comment.");
+    return;
+  }
+
+  const plan = await readJson<DemoPlan>(join(options.outputDir, "demo-plan.json"));
+  const body = buildBody(plan, options.outputDir);
+  const existingCommentId = await findExistingCommentId(repository, prNumber);
+
+  if (existingCommentId) {
+    await request(`/repos/${repository}/issues/comments/${existingCommentId}`, {
+      method: "PATCH",
+      body: JSON.stringify({ body }),
+    });
+    console.log(`Updated PR comment #${existingCommentId}`);
+    return;
+  }
+
+  await request(`/repos/${repository}/issues/${prNumber}/comments`, {
+    method: "POST",
+    body: JSON.stringify({ body }),
+  });
+  console.log(`Created PR comment on #${prNumber}`);
+};

package/src/index.ts

@@ -0,0 +1,10 @@
+export type * from "./types.js";
+
+export { capturePlanContinuous } from "./capture/continuous-capture.js";
+export { buildPromptPlan } from "./planner/prompt.js";
+export { buildVisualPlan } from "./render/visual-plan.js";
+export { composeVideo } from "./render/ffmpeg-compose.js";
+export { applyProjectEnvironment, loadProjectConfig } from "./config/project.js";
+export { writeJson } from "./lib/fs.js";
+export { buildVoiceScript } from "./voice/script.js";
+export { synthesizeVoice } from "./voice/tts.js";

package/src/lib/data-uri.ts

@@ -0,0 +1,21 @@
+import { readFile } from "node:fs/promises";
+import { extname } from "node:path";
+
+const MIME_TYPES: Record<string, string> = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".webp": "image/webp",
+  ".mp3": "audio/mpeg",
+  ".wav": "audio/wav",
+  ".m4a": "audio/mp4",
+  ".webm": "video/webm",
+  ".mp4": "video/mp4",
+};
+
+export const fileToDataUri = async (path: string) => {
+  const buffer = await readFile(path);
+  const ext = extname(path).toLowerCase();
+  const mimeType = MIME_TYPES[ext] ?? "application/octet-stream";
+  return `data:${mimeType};base64,${buffer.toString("base64")}`;
+};

package/src/lib/fs.ts

@@ -0,0 +1,7 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+
+export const writeJson = async (path: string, value: unknown) => {
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, JSON.stringify(value, null, 2) + "\n", "utf8");
+};