demo-this-pr 0.1.0

package/dist/auto.js

@@ -0,0 +1,457 @@
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import http from "node:http";
+import https from "node:https";
+import { basename, extname, join } from "node:path";
+import { readGitContext } from "./git.js";
+import { defaultRunOutputDir } from "./runs.js";
+const COMMON_URLS = [
+    "http://127.0.0.1:3000",
+    "http://localhost:3000",
+    "http://127.0.0.1:5173",
+    "http://localhost:5173",
+    "http://127.0.0.1:3001",
+    "http://localhost:3001",
+    "http://127.0.0.1:4173",
+    "http://localhost:4173",
+    "http://127.0.0.1:4321",
+    "http://localhost:4321",
+    "http://127.0.0.1:8080",
+    "http://localhost:8080",
+    "http://127.0.0.1:8000",
+    "http://localhost:8000"
+];
+export async function resolveAutoDemo(cwd, overrides) {
+    const git = await readGitContext(cwd);
+    if (!git.available) {
+        throw new Error(`No Git repository detected at ${cwd}. Run \`demo-this-pr\` from the repository with the local changes, or pass \`demo-this-pr --cwd <repo>\`.`);
+    }
+    const changedPaths = git.changedFiles.map((file) => file.path).filter(Boolean);
+    const notes = [];
+    let devServer;
+    let demoUrl;
+    const devCommand = await inferDevCommand(cwd);
+    if (devCommand) {
+        try {
+            notes.push(`Started dev server with: ${devCommand}`);
+            const started = await startDevServer(cwd, devCommand);
+            devServer = started.process;
+            demoUrl = started.url;
+        }
+        catch (error) {
+            notes.pop();
+            const message = error instanceof Error ? error.message : String(error);
+            notes.push(`Could not start dev server automatically: ${message}`);
+        }
+    }
+    if (!demoUrl) {
+        demoUrl = await findRunningUrl();
+        if (!demoUrl) {
+            throw new Error("No local app detected. Start your app or add a package.json dev script, then run `demo-this-pr` again.");
+        }
+        notes.push(`Using running local app: ${demoUrl}`);
+    }
+    const packageInfo = await readPackageInfo(cwd);
+    const runLabel = labelForRun(git.branch, packageInfo.name, cwd);
+    const startPath = inferStartPath(changedPaths);
+    const featureTitle = titleForAutoRun({
+        gitAvailable: git.available,
+        branch: git.branch,
+        commits: git.commits,
+        changedFiles: git.changedFiles
+    });
+    return {
+        options: {
+            cwd,
+            outputDir: overrides.output ?? defaultRunOutputDir(runLabel),
+            feature: featureTitle,
+            why: "Local pre-PR demo for the current unpushed changes.",
+            base: git.base,
+            flow: [
+                "Open the inferred feature entry point.",
+                "Show the current branch changes in isolated Chromium.",
+                "Record local-only review evidence before commit or PR."
+            ],
+            changes: inferChanges(changedPaths),
+            technologies: inferTechnologies(changedPaths, packageInfo),
+            testCommands: inferTestCommands(cwd, packageInfo),
+            runDemo: true,
+            headed: !overrides.headless,
+            showReport: overrides.open && !overrides.headless,
+            demoUrl,
+            demoSteps: [`goto:${startPath}`, "screenshot:current-changes"],
+            demoPlanPath: undefined
+        },
+        cleanup: async () => cleanupProcess(devServer),
+        notes
+    };
+}
+async function findRunningUrl() {
+    for (const url of COMMON_URLS) {
+        if (await canReach(url, 600)) {
+            return url;
+        }
+    }
+    return undefined;
+}
+async function inferDevCommand(cwd) {
+    const packageInfo = await readPackageInfo(cwd);
+    if (!packageInfo.scripts.dev) {
+        return undefined;
+    }
+    if (existsSync(join(cwd, "pnpm-lock.yaml"))) {
+        return "pnpm dev";
+    }
+    if (existsSync(join(cwd, "yarn.lock"))) {
+        return "yarn dev";
+    }
+    if (existsSync(join(cwd, "bun.lockb")) || existsSync(join(cwd, "bun.lock"))) {
+        return "bun run dev";
+    }
+    return "npm run dev";
+}
+async function startDevServer(cwd, command) {
+    const child = spawn(command, {
+        cwd,
+        detached: process.platform !== "win32",
+        shell: true,
+        stdio: ["ignore", "pipe", "pipe"]
+    });
+    let output = "";
+    child.stdout.on("data", (chunk) => {
+        output += chunk.toString();
+    });
+    child.stderr.on("data", (chunk) => {
+        output += chunk.toString();
+    });
+    const startedAt = Date.now();
+    while (Date.now() - startedAt < 30_000) {
+        const url = extractUrl(output);
+        if (url && (await canReach(url, 900))) {
+            return { process: child, url };
+        }
+        if (child.exitCode !== null) {
+            throw new Error(`Dev server command exited before a URL was reachable: ${command}`);
+        }
+        await sleep(500);
+    }
+    await cleanupProcess(child);
+    throw new Error(`Timed out waiting for dev server URL after running: ${command}`);
+}
+async function cleanupProcess(child) {
+    if (!child || child.killed || child.exitCode !== null) {
+        return;
+    }
+    try {
+        if (process.platform !== "win32" && child.pid) {
+            process.kill(-child.pid, "SIGTERM");
+        }
+        else {
+            child.kill("SIGTERM");
+        }
+    }
+    catch {
+        child.kill("SIGTERM");
+    }
+    await Promise.race([
+        new Promise((resolve) => child.once("exit", () => resolve())),
+        sleep(1500)
+    ]);
+}
+async function readPackageInfo(cwd) {
+    try {
+        const parsed = JSON.parse(await readFile(join(cwd, "package.json"), "utf8"));
+        return {
+            name: parsed.name,
+            scripts: parsed.scripts ?? {},
+            dependencies: parsed.dependencies ?? {},
+            devDependencies: parsed.devDependencies ?? {}
+        };
+    }
+    catch {
+        return { scripts: {}, dependencies: {}, devDependencies: {} };
+    }
+}
+function inferTestCommands(cwd, packageInfo) {
+    const scripts = packageInfo.scripts;
+    const commands = [];
+    const runner = packageManagerCommand(cwd);
+    if (scripts["test:ci"]) {
+        commands.push(`${runner} run test:ci`);
+    }
+    else if (scripts.test) {
+        const testScript = scripts.test;
+        if (/\bvitest\b/u.test(testScript)) {
+            commands.push(`${runner} test -- --run`);
+        }
+        else if (/\bjest\b/u.test(testScript)) {
+            commands.push(`${runner} test -- --watch=false`);
+        }
+        else if (!/\bwatch\b/u.test(testScript)) {
+            commands.push(`${runner} test`);
+        }
+    }
+    if (scripts.typecheck) {
+        commands.push(`${runner} run typecheck`);
+    }
+    if (scripts.lint) {
+        commands.push(`${runner} run lint`);
+    }
+    return commands.slice(0, 3);
+}
+function packageManagerCommand(cwd) {
+    if (existsSync(join(cwd, "pnpm-lock.yaml"))) {
+        return "pnpm";
+    }
+    if (existsSync(join(cwd, "yarn.lock"))) {
+        return "yarn";
+    }
+    if (existsSync(join(cwd, "bun.lockb")) || existsSync(join(cwd, "bun.lock"))) {
+        return "bun";
+    }
+    return "npm";
+}
+function inferStartPath(paths) {
+    for (const path of paths) {
+        const nextAppMatch = path.match(/(?:^|\/)app\/(.+?)\/page\.(?:t|j)sx?$/u);
+        if (nextAppMatch?.[1]) {
+            return routeFromSegments(nextAppMatch[1]);
+        }
+        const pagesMatch = path.match(/(?:^|\/)pages\/(.+?)\.(?:t|j)sx?$/u);
+        if (pagesMatch?.[1]) {
+            return routeFromSegments(pagesMatch[1].replace(/\/index$/u, ""));
+        }
+        const svelteMatch = path.match(/(?:^|\/)src\/routes\/(.+?)\/\+page\.svelte$/u);
+        if (svelteMatch?.[1]) {
+            return routeFromSegments(svelteMatch[1]);
+        }
+    }
+    return "/";
+}
+function routeFromSegments(value) {
+    const route = value
+        .split("/")
+        .filter((part) => part && !part.startsWith("("))
+        .map((part) => part.replace(/^\[\.{3}(.+)\]$/u, "$1").replace(/^\[(.+)\]$/u, "$1"))
+        .join("/");
+    return route ? `/${route}` : "/";
+}
+function inferChanges(paths) {
+    if (paths.length === 0) {
+        return ["Current working tree changes are shown in the local demo."];
+    }
+    return summarizeByDirectory(paths).map((summary) => `Changes under ${summary}.`);
+}
+function inferTechnologies(paths, packageInfo) {
+    const technologies = new Set();
+    const deps = { ...packageInfo.dependencies, ...packageInfo.devDependencies };
+    for (const name of ["next", "react", "vite", "vue", "svelte", "astro", "nuxt", "remix", "@playwright/test", "typescript", "tailwindcss"]) {
+        if (deps[name]) {
+            technologies.add(name);
+        }
+    }
+    const extensions = new Set(paths.map((path) => extname(path)).filter(Boolean));
+    for (const extension of extensions) {
+        if (extension === ".tsx" || extension === ".ts")
+            technologies.add("TypeScript");
+        if (extension === ".jsx" || extension === ".js")
+            technologies.add("JavaScript");
+        if (extension === ".css" || extension === ".scss")
+            technologies.add("CSS");
+    }
+    return [...technologies].slice(0, 8);
+}
+function summarizeByDirectory(paths) {
+    const buckets = new Map();
+    for (const path of paths) {
+        const parts = path.split("/");
+        const key = parts.length > 1 ? parts.slice(0, 2).join("/") : basename(path);
+        buckets.set(key, (buckets.get(key) ?? 0) + 1);
+    }
+    return [...buckets.entries()]
+        .sort((first, second) => second[1] - first[1])
+        .slice(0, 5)
+        .map(([path, count]) => `${path}${count > 1 ? ` (${count} files)` : ""}`);
+}
+function labelForRun(branch, packageName, cwd) {
+    if (isMeaningfulLabel(branch)) {
+        return branch;
+    }
+    if (isMeaningfulLabel(packageName)) {
+        return packageName;
+    }
+    return basename(cwd) || "current-changes";
+}
+export function titleForAutoRun(input) {
+    if (input.gitAvailable === false) {
+        return "Git context unavailable";
+    }
+    return subjectFromChangedFiles(input.changedFiles)
+        ?? commitSubject(input.commits[0])
+        ?? subjectFromBranch(input.branch)
+        ?? "No local changes detected";
+}
+function commitSubject(commit) {
+    const subject = commit?.replace(/^[a-f0-9]{7,40}\s+/iu, "").trim();
+    return subject || undefined;
+}
+function subjectFromBranch(branch) {
+    if (!isMeaningfulFeatureBranch(branch)) {
+        return undefined;
+    }
+    const normalized = branch.replace(/^refs\/heads\//u, "");
+    const prefixed = normalized.match(/^(feat|feature|fix|bugfix|hotfix|chore|docs|doc|refactor|test|tests|perf|ci|build|style|release)[/_-](.+)$/iu);
+    if (prefixed) {
+        return branchSubject(prefixed[1], prefixed[2]);
+    }
+    return `Update ${humanizeSubject(normalized)}`;
+}
+function subjectFromChangedFiles(files) {
+    const changed = files.filter((file) => file.path);
+    if (changed.length === 0) {
+        return undefined;
+    }
+    const added = changed.filter(isAddedFile);
+    const removed = changed.filter(isRemovedFile);
+    const modified = changed.filter((file) => !isAddedFile(file) && !isRemovedFile(file));
+    const clauses = [];
+    const modifiedTopics = topicsForFiles(modified);
+    if (modifiedTopics.length > 0) {
+        clauses.push(`update ${formatTopicList(modifiedTopics)}`);
+    }
+    const addedTopics = topicsForFiles(added);
+    if (addedTopics.length > 0) {
+        clauses.push(`add ${formatTopicList(addedTopics)}`);
+    }
+    const removedTopics = topicsForFiles(removed);
+    if (removedTopics.length > 0) {
+        clauses.push(`remove ${formatTopicList(removedTopics)}`);
+    }
+    if (clauses.length === 0) {
+        return undefined;
+    }
+    return sentenceCase(formatTopicList(clauses));
+}
+function isAddedFile(file) {
+    const status = file.status.toUpperCase();
+    return status.includes("?") || status.includes("A");
+}
+function isRemovedFile(file) {
+    return file.status.toUpperCase().includes("D");
+}
+function topicsForFiles(files) {
+    const paths = files.map((file) => file.path);
+    const topics = [];
+    if (paths.some((path) => /(^|\/)CLAUDE\.md$/iu.test(path))) {
+        topics.push("CLAUDE.md for operational context");
+    }
+    if (paths.some((path) => /(^|\/)AGENTS\.md$/iu.test(path))) {
+        topics.push("AGENTS.md project memory");
+    }
+    if (paths.some((path) => /(^|\/)README\.md$/iu.test(path))) {
+        topics.push("README documentation");
+    }
+    if (paths.some((path) => /(^|\/)LICENSE$/iu.test(path))) {
+        topics.push("license metadata");
+    }
+    if (paths.some((path) => /\.(?:css|scss|sass|less)$/iu.test(path))) {
+        topics.push("styles");
+    }
+    if (paths.some((path) => /demo-this-pr-logo\.svg$/iu.test(path))) {
+        topics.push("README wordmark");
+    }
+    if (paths.length > 0 && paths.every((path) => /^test\//u.test(path) || /\.test\./u.test(path) || /\.spec\./u.test(path))) {
+        topics.push("test coverage");
+    }
+    if (paths.some((path) => /(^|\/)(package|tsconfig|vite|next|playwright|vitest|jest|eslint|prettier)\b/iu.test(path))) {
+        topics.push("project configuration");
+    }
+    if (!paths.some((path) => /\.(?:css|scss|sass|less)$/iu.test(path)) && paths.some((path) => /\.(?:html|tsx|jsx|vue|svelte)$/iu.test(path))) {
+        topics.push(uiTopic(paths));
+    }
+    if (topics.length === 0) {
+        topics.push(...summarizeByDirectory(paths).map(humanizeDirectorySummary));
+    }
+    return unique(topics).slice(0, 2);
+}
+function uiTopic(paths) {
+    const landing = paths.some((path) => /(^|\/)landing(\/|$)/iu.test(path));
+    return landing ? "landing page" : "UI views";
+}
+function humanizeDirectorySummary(value) {
+    return value
+        .replace(/\s+\(\d+ files\)$/u, "")
+        .replace(/\.[a-z0-9]+$/iu, "")
+        .replace(/[-_/]+/gu, " ")
+        .trim()
+        .toLowerCase() || "local changes";
+}
+function formatTopicList(values) {
+    if (values.length <= 1) {
+        return values[0] ?? "";
+    }
+    return `${values.slice(0, -1).join(", ")} and ${values.at(-1)}`;
+}
+function sentenceCase(value) {
+    return value.charAt(0).toUpperCase() + value.slice(1);
+}
+function unique(values) {
+    return [...new Set(values)];
+}
+function branchSubject(type, value) {
+    const subject = humanizeSubject(value);
+    const normalized = type.toLowerCase();
+    if (normalized === "fix" || normalized === "bugfix" || normalized === "hotfix") {
+        return `Fix ${subject}`;
+    }
+    if (normalized === "docs" || normalized === "doc") {
+        return `Update documentation for ${subject}`;
+    }
+    if (normalized === "test" || normalized === "tests") {
+        return `Update tests for ${subject}`;
+    }
+    if (normalized === "refactor") {
+        return `Refactor ${subject}`;
+    }
+    if (normalized === "release") {
+        return `Prepare ${subject} release`;
+    }
+    return `Update ${subject}`;
+}
+function humanizeSubject(value) {
+    return value
+        .replace(/^[a-z]+\/+/iu, "")
+        .replace(/[_/]+/gu, "-")
+        .split(/-+/u)
+        .filter(Boolean)
+        .join(" ")
+        .toLowerCase() || "review local changes";
+}
+function isMeaningfulLabel(value) {
+    return Boolean(value && value !== "unknown" && value !== "HEAD");
+}
+function isMeaningfulFeatureBranch(value) {
+    return Boolean(isMeaningfulLabel(value) && !/^(main|master|trunk|develop|dev)$/iu.test(value));
+}
+function extractUrl(output) {
+    return output.match(/https?:\/\/(?:localhost|127\.0\.0\.1|\[::1\])(?::\d+)?(?:\/[^\s]*)?/u)?.[0]?.replace(/\/$/u, "");
+}
+function canReach(url, timeoutMs) {
+    return new Promise((resolve) => {
+        const client = url.startsWith("https:") ? https : http;
+        const request = client.request(url, { method: "GET", timeout: timeoutMs }, (response) => {
+            response.resume();
+            resolve((response.statusCode ?? 0) < 500);
+        });
+        request.on("timeout", () => {
+            request.destroy();
+            resolve(false);
+        });
+        request.on("error", () => resolve(false));
+        request.end();
+    });
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,201 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { resolve } from "node:path";
+import pc from "picocolors";
+import { resolveAutoDemo } from "./auto.js";
+import { createPrKit } from "./prKit.js";
+import { parseDemoStep } from "./demoPlan.js";
+import { defaultRunOutputDir } from "./runs.js";
+import { openReportViewer } from "./viewer.js";
+const program = new Command();
+program
+    .name("demo-this-pr")
+    .description("Generate reviewable PR demos from current unpushed changes.")
+    .version("0.1.0")
+    .argument("[repo]", "repository path; defaults to the current working directory")
+    .option("--cwd <path>", "repository path; useful when running from outside the target repo")
+    .option("--headless", "run Chromium without a visible window", false)
+    .option("--no-open", "do not open the generated report viewer")
+    .option("--output <dir>", "output directory; defaults to a unique .demo-this-pr/runs/<run-id> directory")
+    .action(async (repo, options) => {
+    let cleanup;
+    try {
+        const targetCwd = resolve(options.cwd ?? repo ?? process.cwd());
+        const autoDemo = await resolveAutoDemo(targetCwd, {
+            headless: options.headless ?? false,
+            output: options.output,
+            open: options.open ?? true
+        });
+        cleanup = autoDemo.cleanup;
+        await runResolvedKitCommand(autoDemo.options, "Demo", autoDemo.notes);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`${pc.red("demo-this-pr:")} ${message}\n`);
+        process.exitCode = 1;
+    }
+    finally {
+        await cleanup?.();
+    }
+});
+program
+    .command("ci")
+    .description("Run the automatic demo flow for CI and agent runners")
+    .argument("[repo]", "repository path; defaults to the current working directory")
+    .option("--cwd <path>", "repository path; useful when running from outside the target repo")
+    .option("--output <dir>", "output directory", ".demo-this-pr/ci")
+    .option("--headed", "run Chromium with a visible window", false)
+    .action(async (repo, options) => {
+    let cleanup;
+    try {
+        const targetCwd = resolve(options.cwd ?? repo ?? process.cwd());
+        const autoDemo = await resolveAutoDemo(targetCwd, {
+            headless: !(options.headed ?? false),
+            output: options.output,
+            open: false
+        });
+        cleanup = autoDemo.cleanup;
+        await runResolvedKitCommand(autoDemo.options, "CI demo", autoDemo.notes);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`${pc.red("demo-this-pr:")} ${message}\n`);
+        process.exitCode = 1;
+    }
+    finally {
+        await cleanup?.();
+    }
+});
+program
+    .command("demo")
+    .description("Launch a local Chromium demo for the current changes and write the PR kit")
+    .option("--cwd <path>", "working directory", process.cwd())
+    .option("--output <dir>", "output directory; defaults to a unique .demo-this-pr/runs/<run-id> directory")
+    .option("--feature <text>", "feature name or PR title")
+    .option("--why <text>", "reason this change exists")
+    .option("--base <branch>", "base branch for git diff")
+    .option("--flow <step>", "review flow step; repeatable", collect, [])
+    .option("--change <text>", "user-visible change to show in the demo; repeatable", collect, [])
+    .option("--tech <text>", "technology or implementation note to show in the demo; repeatable", collect, [])
+    .option("--test <cmd>", "test command to run and capture; repeatable", collect, [])
+    .option("--url <url>", "local app URL to open in Chromium")
+    .option("--demo-url <url>", "alias for --url")
+    .option("--step <step>", "compact demo step; repeatable", collect, [])
+    .option("--demo-step <step>", "alias for --step; repeatable", collect, [])
+    .option("--demo-plan <path>", "JSON demo plan path")
+    .option("--headless", "run Chromium without a visible window", false)
+    .option("--no-open", "do not open the generated report viewer")
+    .action(async (options) => {
+    const demoUrl = options.url ?? options.demoUrl;
+    if (!demoUrl && !options.demoPlan) {
+        process.stderr.write(`${pc.red("demo-this-pr:")} demo needs --url <local-app-url> or --demo-plan <path>\n`);
+        process.exitCode = 1;
+        return;
+    }
+    await runKitCommand({
+        ...options,
+        demoUrl,
+        demoStep: [...(options.demoStep ?? []), ...(options.step ?? [])],
+        runDemo: true
+    }, "Demo");
+});
+program
+    .command("pr")
+    .description("Create a PR review kit for the current branch")
+    .option("--cwd <path>", "working directory", process.cwd())
+    .option("--output <dir>", "output directory; defaults to a unique .demo-this-pr/runs/<run-id> directory")
+    .option("--feature <text>", "feature name or PR title")
+    .option("--why <text>", "reason this PR exists")
+    .option("--base <branch>", "base branch for git diff")
+    .option("--flow <step>", "review flow step; repeatable", collect, [])
+    .option("--change <text>", "user-visible change to mention in the PR kit; repeatable", collect, [])
+    .option("--tech <text>", "technology or implementation note to mention in the PR kit; repeatable", collect, [])
+    .option("--test <cmd>", "test command to run and capture; repeatable", collect, [])
+    .option("--demo-url <url>", "local app URL used by generated Playwright demo")
+    .option("--demo-step <step>", "compact demo step; repeatable", collect, [])
+    .option("--demo-plan <path>", "JSON demo plan path")
+    .option("--run-demo", "run generated Playwright demo and record video", false)
+    .option("--headless", "run Chromium without a visible window when --run-demo is used", false)
+    .option("--no-open", "do not open the generated report viewer")
+    .action(async (options) => runKitCommand(options, "PR kit"));
+program
+    .command("init-demo")
+    .description("Write a JSON demo plan template")
+    .option("--output <path>", "demo plan path", "demo-this-pr.demo.json")
+    .action(async (options) => {
+    const { writeFile } = await import("node:fs/promises");
+    const template = {
+        title: "Feature demo",
+        baseUrl: "http://localhost:3000",
+        why: "Explain the behavior this PR introduces or protects.",
+        steps: [
+            { caption: "Open the feature entry point", goto: "/" },
+            { caption: "Interact with the changed UI", click: "text=New" },
+            { caption: "Verify the expected state", expectText: "Created", screenshot: "expected-state" }
+        ]
+    };
+    await writeFile(options.output, `${JSON.stringify(template, null, 2)}\n`, "utf8");
+    process.stdout.write(`Demo plan written to ${options.output}\n`);
+});
+program.parseAsync();
+async function runKitCommand(options, label) {
+    try {
+        const demoSteps = options.demoStep ?? [];
+        for (const step of demoSteps) {
+            parseDemoStep(step);
+        }
+        const resolvedOptions = {
+            cwd: options.cwd,
+            outputDir: options.output ?? defaultRunOutputDir(options.feature),
+            feature: options.feature,
+            why: options.why,
+            base: options.base,
+            flow: options.flow ?? [],
+            changes: options.change ?? [],
+            technologies: options.tech ?? [],
+            testCommands: options.test ?? [],
+            runDemo: options.runDemo ?? false,
+            headed: !options.headless,
+            showReport: (options.open ?? true) && !options.headless,
+            demoUrl: options.demoUrl,
+            demoSteps,
+            demoPlanPath: options.demoPlan
+        };
+        await runResolvedKitCommand(resolvedOptions, label);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`${pc.red("demo-this-pr:")} ${message}\n`);
+        process.exitCode = 1;
+    }
+}
+async function runResolvedKitCommand(options, label, notes = []) {
+    const result = await createPrKit(options);
+    printResult(result, label, notes);
+    if (options.showReport && result.demoRun.videoPath) {
+        process.stdout.write(`${pc.dim("note:")} opening report viewer; close the Chromium window to finish\n`);
+        await openReportViewer(result.htmlPath);
+    }
+}
+function printResult(result, label, notes) {
+    process.stdout.write(`${pc.green(`${label} generated`)}\n`);
+    for (const note of notes) {
+        process.stdout.write(`${pc.dim("note:")} ${note}\n`);
+    }
+    process.stdout.write(`Markdown: ${result.markdownPath}\n`);
+    process.stdout.write(`HTML:     ${result.htmlPath}\n`);
+    process.stdout.write(`MCP:      ${result.mcpGuidePath}\n`);
+    process.stdout.write(`Demo:     ${result.demoSpecPath}\n`);
+    if (result.demoRun.attempted && result.demoRun.passed) {
+        process.stdout.write(`${pc.green("Chromium demo passed")}\n`);
+        if (result.demoRun.videoPath) {
+            process.stdout.write(`Video:    ${result.outputDir}/${result.demoRun.videoPath}\n`);
+        }
+    }
+    if (result.demoRun.attempted && !result.demoRun.passed) {
+        process.stdout.write(`${pc.yellow("Demo needs attention:")} ${result.demoRun.error ?? "Playwright failed"}\n`);
+    }
+}
+function collect(value, previous) {
+    return [...previous, value];
+}

package/dist/demoPlan.d.ts

@@ -0,0 +1,10 @@
+import type { DemoPlan, DemoStep } from "./types.js";
+export declare function buildDemoPlan(input: {
+    feature: string;
+    why: string;
+    demoUrl?: string;
+    demoSteps: string[];
+    demoPlanPath?: string;
+}): Promise<DemoPlan>;
+export declare function readDemoPlan(path: string): Promise<DemoPlan>;
+export declare function parseDemoStep(step: string): DemoStep;