demo-this-pr 0.1.0

package/dist/demoPlan.js

@@ -0,0 +1,159 @@
+import { readFile } from "node:fs/promises";
+export async function buildDemoPlan(input) {
+    if (input.demoPlanPath) {
+        return readDemoPlan(input.demoPlanPath);
+    }
+    const parsedSteps = input.demoSteps.map(parseDemoStep);
+    const steps = parsedSteps.length > 0 ? parsedSteps : defaultSteps(input.demoUrl);
+    return {
+        title: input.feature,
+        baseUrl: input.demoUrl,
+        why: input.why,
+        steps
+    };
+}
+export async function readDemoPlan(path) {
+    const parsed = JSON.parse(await readFile(path, "utf8"));
+    if (!isRecord(parsed)) {
+        throw new Error("Demo plan must be a JSON object.");
+    }
+    const title = readString(parsed.title, "title") ?? "PR demo";
+    const baseUrl = readString(parsed.baseUrl, "baseUrl");
+    const why = readString(parsed.why, "why");
+    const rawSteps = Array.isArray(parsed.steps) ? parsed.steps : [];
+    const steps = rawSteps.map((step, index) => normalizeDemoStep(step, index));
+    if (steps.length === 0) {
+        throw new Error("Demo plan must include at least one step.");
+    }
+    return { title, baseUrl, why, steps };
+}
+export function parseDemoStep(step) {
+    const [kind, ...rest] = step.split(":");
+    const payload = rest.join(":").trim();
+    if (!kind || !payload) {
+        throw new Error(`Invalid demo step "${step}". Expected kind:payload.`);
+    }
+    if (kind === "goto") {
+        return { caption: `Open ${payload}`, goto: payload, screenshot: "open" };
+    }
+    if (kind === "click") {
+        return { caption: `Click ${payload}`, click: payload };
+    }
+    if (kind === "fill") {
+        const [selector, ...valueParts] = payload.split(":");
+        const value = valueParts.join(":");
+        if (!selector || !value) {
+            throw new Error(`Invalid fill step "${step}". Expected fill:selector:value.`);
+        }
+        return { caption: `Fill ${selector}`, fill: { selector, value } };
+    }
+    if (kind === "press") {
+        const [selector, ...keyParts] = payload.split(":");
+        const key = keyParts.join(":");
+        if (!selector || !key) {
+            throw new Error(`Invalid press step "${step}". Expected press:selector:key.`);
+        }
+        return { caption: `Press ${key}`, press: { selector, key } };
+    }
+    if (kind === "expect") {
+        return { caption: `Verify ${payload}`, expectText: payload, screenshot: "verify" };
+    }
+    if (kind === "screenshot") {
+        return { caption: `Capture ${payload}`, screenshot: payload };
+    }
+    if (kind === "wait") {
+        const waitMs = Number(payload);
+        if (!Number.isFinite(waitMs) || waitMs < 0) {
+            throw new Error(`Invalid wait step "${step}". Wait must be a non-negative number.`);
+        }
+        return { caption: `Wait ${waitMs}ms`, waitMs };
+    }
+    throw new Error(`Unknown demo step kind "${kind}".`);
+}
+function defaultSteps(demoUrl) {
+    if (!demoUrl) {
+        return [
+            {
+                caption: "Demo URL not configured",
+                screenshot: "demo-not-run"
+            }
+        ];
+    }
+    return [
+        {
+            caption: "Open the feature entry point",
+            goto: "/",
+            screenshot: "entry-point"
+        }
+    ];
+}
+function normalizeDemoStep(value, index) {
+    if (!isRecord(value)) {
+        throw new Error(`Demo step ${index + 1} must be an object.`);
+    }
+    const step = {};
+    const caption = readString(value.caption, `steps[${index}].caption`);
+    if (caption) {
+        step.caption = caption;
+    }
+    const goto = readString(value.goto, `steps[${index}].goto`);
+    if (goto) {
+        step.goto = goto;
+    }
+    const click = readString(value.click, `steps[${index}].click`);
+    if (click) {
+        step.click = click;
+    }
+    if (value.fill !== undefined) {
+        if (!isRecord(value.fill)) {
+            throw new Error(`steps[${index}].fill must be an object.`);
+        }
+        const selector = readString(value.fill.selector, `steps[${index}].fill.selector`);
+        const fillValue = readString(value.fill.value, `steps[${index}].fill.value`);
+        if (!selector || fillValue === undefined) {
+            throw new Error(`steps[${index}].fill requires selector and value.`);
+        }
+        step.fill = { selector, value: fillValue };
+    }
+    if (value.press !== undefined) {
+        if (!isRecord(value.press)) {
+            throw new Error(`steps[${index}].press must be an object.`);
+        }
+        const selector = readString(value.press.selector, `steps[${index}].press.selector`);
+        const key = readString(value.press.key, `steps[${index}].press.key`);
+        if (!selector || !key) {
+            throw new Error(`steps[${index}].press requires selector and key.`);
+        }
+        step.press = { selector, key };
+    }
+    const expectText = readString(value.expectText, `steps[${index}].expectText`);
+    if (expectText) {
+        step.expectText = expectText;
+    }
+    const screenshot = readString(value.screenshot, `steps[${index}].screenshot`);
+    if (screenshot) {
+        step.screenshot = screenshot;
+    }
+    if (value.waitMs !== undefined) {
+        if (typeof value.waitMs !== "number" || !Number.isFinite(value.waitMs) || value.waitMs < 0) {
+            throw new Error(`steps[${index}].waitMs must be a non-negative number.`);
+        }
+        step.waitMs = value.waitMs;
+    }
+    if (!step.goto && !step.click && !step.fill && !step.press && !step.expectText && !step.screenshot && step.waitMs === undefined) {
+        throw new Error(`Demo step ${index + 1} has no action.`);
+    }
+    return step;
+}
+function readString(value, key) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== "string") {
+        throw new Error(`${key} must be a string.`);
+    }
+    return value;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/git.d.ts

@@ -0,0 +1,2 @@
+import type { GitContext } from "./types.js";
+export declare function readGitContext(cwd: string, requestedBase?: string): Promise<GitContext>;

package/dist/git.js

@@ -0,0 +1,87 @@
+import { resolve } from "node:path";
+import { runShellCommand } from "./shell.js";
+export async function readGitContext(cwd, requestedBase) {
+    const rootResult = await git(cwd, "rev-parse --show-toplevel");
+    if (rootResult.exitCode !== 0) {
+        return emptyGitContext(cwd, requestedBase ?? "main");
+    }
+    const root = rootResult.stdout.trim();
+    const branch = (await git(root, "rev-parse --abbrev-ref HEAD")).stdout.trim() || "unknown";
+    const headSha = (await git(root, "rev-parse --short HEAD")).stdout.trim() || "unknown";
+    const base = requestedBase ?? (await detectBase(root));
+    const range = `${base}...HEAD`;
+    const filesResult = await git(root, `diff --name-status ${range}`);
+    const worktreeResult = await git(root, "status --porcelain");
+    const commitsResult = await git(root, `log --oneline ${base}..HEAD`);
+    return {
+        available: true,
+        root,
+        branch,
+        base,
+        headSha,
+        commits: parseLines(commitsResult.stdout),
+        changedFiles: mergeChangedFiles(parseChangedFiles(filesResult.stdout), parsePorcelainStatus(worktreeResult.stdout))
+    };
+}
+async function detectBase(root) {
+    const originHead = await git(root, "symbolic-ref --quiet --short refs/remotes/origin/HEAD");
+    const detected = originHead.stdout.trim().replace(/^origin\//u, "");
+    if (originHead.exitCode === 0 && detected) {
+        return detected;
+    }
+    const mainExists = await git(root, "rev-parse --verify main");
+    if (mainExists.exitCode === 0) {
+        return "main";
+    }
+    const masterExists = await git(root, "rev-parse --verify master");
+    if (masterExists.exitCode === 0) {
+        return "master";
+    }
+    return "main";
+}
+function parseChangedFiles(output) {
+    return parseLines(output).map((line) => {
+        const [status = "?", ...pathParts] = line.split(/\s+/u);
+        return {
+            status,
+            path: pathParts.join(" ")
+        };
+    });
+}
+function parsePorcelainStatus(output) {
+    return parseLines(output).map((line) => {
+        const status = line.slice(0, 2).trim() || "?";
+        const rawPath = line.slice(3).trim();
+        const path = rawPath.includes(" -> ") ? rawPath.split(" -> ").at(-1) ?? rawPath : rawPath;
+        return { status, path };
+    });
+}
+function mergeChangedFiles(...groups) {
+    const merged = new Map();
+    for (const group of groups) {
+        for (const file of group) {
+            if (!file.path) {
+                continue;
+            }
+            merged.set(file.path, file);
+        }
+    }
+    return [...merged.values()].sort((first, second) => first.path.localeCompare(second.path));
+}
+function parseLines(output) {
+    return output.split("\n").map((line) => line.trim()).filter(Boolean);
+}
+async function git(cwd, args) {
+    return runShellCommand(`git ${args}`, cwd);
+}
+function emptyGitContext(cwd, base) {
+    return {
+        available: false,
+        root: resolve(cwd),
+        branch: "unknown",
+        base,
+        headSha: "unknown",
+        commits: [],
+        changedFiles: []
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { createPrKit } from "./prKit.js";
+export { buildDemoPlan, parseDemoStep, readDemoPlan } from "./demoPlan.js";
+export { readGitContext } from "./git.js";
+export { renderHtmlReport, renderMarkdownReport } from "./report.js";
+export { defaultRunOutputDir } from "./runs.js";
+export { writePlaywrightArtifacts, runPlaywrightDemo } from "./playwright.js";
+export type { CommandResult, DemoPlan, DemoRunResult, DemoStep, GitContext, GitFileChange, PrKitOptions, PrKitResult } from "./types.js";

package/dist/index.js

@@ -0,0 +1,6 @@
+export { createPrKit } from "./prKit.js";
+export { buildDemoPlan, parseDemoStep, readDemoPlan } from "./demoPlan.js";
+export { readGitContext } from "./git.js";
+export { renderHtmlReport, renderMarkdownReport } from "./report.js";
+export { defaultRunOutputDir } from "./runs.js";
+export { writePlaywrightArtifacts, runPlaywrightDemo } from "./playwright.js";

package/dist/playwright.d.ts

@@ -0,0 +1,11 @@
+import type { DemoPlan, DemoRunResult } from "./types.js";
+export declare function writePlaywrightArtifacts(outputDir: string, plan: DemoPlan): Promise<{
+    specPath: string;
+    configPath: string;
+    planPath: string;
+    mcpGuidePath: string;
+    mcpScriptPath: string;
+}>;
+export declare function runPlaywrightDemo(outputDir: string, plan: DemoPlan, options: {
+    headed: boolean;
+}): Promise<DemoRunResult>;