@dailephd/my-dev-kit-lab 0.2.0

package/dist/src/commands/renderExperimentReportCommand.js

@@ -0,0 +1,131 @@
+import { access } from "node:fs/promises";
+import path from "node:path";
+import { captureReportScreenshot, SCREENSHOT_SKIP_WARNING } from "../screenshot/index.js";
+import { buildExperimentReportInput, getExperimentReportArtifactPaths, writeExperimentReportArtifacts } from "../report/index.js";
+export function parseRenderExperimentReportArgs(argv) {
+    let experimentDir = "";
+    let outDir = "";
+    let title;
+    let subtitle;
+    let screenshot = false;
+    let requireScreenshot = false;
+    let maxPromptChars;
+    let maxFileTreeEntries;
+    let plotsDir;
+    let visualizationsDir;
+    for (let index = 0; index < argv.length; index += 1) {
+        const arg = argv[index];
+        if (arg === "--experiment") {
+            experimentDir = argv[index + 1] ?? "";
+            index += 1;
+        }
+        else if (arg === "--out") {
+            outDir = argv[index + 1] ?? "";
+            index += 1;
+        }
+        else if (arg === "--title") {
+            title = argv[index + 1] ?? "";
+            index += 1;
+        }
+        else if (arg === "--subtitle") {
+            subtitle = argv[index + 1] ?? "";
+            index += 1;
+        }
+        else if (arg === "--screenshot") {
+            screenshot = true;
+        }
+        else if (arg === "--no-screenshot") {
+            screenshot = false;
+        }
+        else if (arg === "--require-screenshot") {
+            requireScreenshot = true;
+            screenshot = true;
+        }
+        else if (arg === "--max-prompt-chars") {
+            maxPromptChars = parsePositiveInteger("--max-prompt-chars", argv[index + 1] ?? "");
+            index += 1;
+        }
+        else if (arg === "--max-file-tree-entries") {
+            maxFileTreeEntries = parsePositiveInteger("--max-file-tree-entries", argv[index + 1] ?? "");
+            index += 1;
+        }
+        else if (arg === "--plots") {
+            plotsDir = argv[index + 1] ?? "";
+            index += 1;
+        }
+        else if (arg === "--visualizations") {
+            visualizationsDir = argv[index + 1] ?? "";
+            index += 1;
+        }
+    }
+    if (!experimentDir || !outDir) {
+        throw new Error([
+            "Usage: --experiment <controlled-experiment-dir> --out <directory>",
+            "[--title <title>] [--subtitle <subtitle>] [--screenshot|--no-screenshot]",
+            "[--require-screenshot] [--max-prompt-chars <n>] [--max-file-tree-entries <n>]",
+            "[--plots <dir>] [--visualizations <dir>]"
+        ].join(" "));
+    }
+    return { experimentDir, outDir, title, subtitle, screenshot, requireScreenshot, maxPromptChars, maxFileTreeEntries, plotsDir, visualizationsDir };
+}
+export async function runRenderExperimentReportFromArgs(args, repoRoot = process.cwd(), dependencies = {}) {
+    const experimentDir = path.resolve(repoRoot, args.experimentDir);
+    await access(experimentDir).catch(() => {
+        throw new Error(`Experiment directory not found: ${args.experimentDir}`);
+    });
+    const outDir = path.resolve(repoRoot, args.outDir);
+    const outputPaths = getExperimentReportArtifactPaths(outDir);
+    const report = await buildExperimentReportInput({
+        experimentDir,
+        repoRoot,
+        title: args.title,
+        subtitle: args.subtitle,
+        maxPromptChars: args.maxPromptChars,
+        maxFileTreeEntries: args.maxFileTreeEntries,
+        plotsDir: args.plotsDir,
+        visualizationsDir: args.visualizationsDir
+    });
+    let screenshot = {
+        status: "skipped",
+        htmlPath: outputPaths.htmlPath,
+        pngPath: outputPaths.pngPath,
+        warning: "PNG screenshot skipped because --screenshot was not provided."
+    };
+    let result = await writeExperimentReportArtifacts({ outDir, report, screenshot });
+    if (args.screenshot) {
+        const captureScreenshot = dependencies.captureScreenshot ?? captureReportScreenshot;
+        screenshot = await captureScreenshot(outputPaths.htmlPath, outputPaths.pngPath);
+        if (screenshot.status === "skipped" && !screenshot.warning) {
+            screenshot.warning = SCREENSHOT_SKIP_WARNING;
+        }
+        result = await writeExperimentReportArtifacts({ outDir, report, screenshot });
+    }
+    if (args.requireScreenshot && result.screenshot.status !== "captured") {
+        throw new Error(result.screenshot.error ?? result.screenshot.warning ?? "Required screenshot was not captured.");
+    }
+    return result;
+}
+export async function runRenderExperimentReportCommand(argv) {
+    try {
+        const args = parseRenderExperimentReportArgs(argv);
+        const result = await runRenderExperimentReportFromArgs(args);
+        console.log([
+            `Report: ${result.outputPaths.htmlPath}`,
+            `JSON: ${result.outputPaths.jsonPath}`,
+            `Screenshot: ${result.screenshot.status}`,
+            `Output: ${result.outputPaths.outDir}`
+        ].join("\n"));
+        return 0;
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        return 1;
+    }
+}
+function parsePositiveInteger(label, value) {
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed <= 0) {
+        throw new Error(`${label} must be a positive integer.`);
+    }
+    return parsed;
+}

package/dist/src/commands/runAgentPromptCommand.js

@@ -0,0 +1,132 @@
+import path from "node:path";
+import { parseAgentCommandTemplate, runAgentPrompt } from "../agents/index.js";
+import { parseAgentId } from "../agents/agentRegistry.js";
+import { readBenchmarkProjectProfiles, readEvaluationCases } from "../evaluation/index.js";
+import { generatePromptVariants, parsePromptComplexityLevel, parsePromptStrategy } from "../prompts/index.js";
+export function parseRunAgentPromptArgs(argv) {
+    let agentId;
+    let casesPath = "";
+    let caseId = "";
+    let strategy;
+    let complexity;
+    let outDir = "";
+    let projectProfilesPath = "benchmarks/contracts/benchmark-project-profiles.json";
+    let commandTemplate;
+    let requireAvailable = false;
+    let timeoutMs;
+    for (let index = 0; index < argv.length; index += 1) {
+        const arg = argv[index];
+        if (arg === "--agent") {
+            agentId = parseAgentId(argv[index + 1] ?? "");
+            index += 1;
+        }
+        else if (arg === "--cases") {
+            casesPath = argv[index + 1] ?? "";
+            index += 1;
+        }
+        else if (arg === "--case") {
+            caseId = argv[index + 1] ?? "";
+            index += 1;
+        }
+        else if (arg === "--strategy") {
+            strategy = parsePromptStrategy(argv[index + 1] ?? "");
+            index += 1;
+        }
+        else if (arg === "--complexity") {
+            complexity = parsePromptComplexityLevel(argv[index + 1] ?? "");
+            index += 1;
+        }
+        else if (arg === "--out") {
+            outDir = argv[index + 1] ?? "";
+            index += 1;
+        }
+        else if (arg === "--project-profiles") {
+            projectProfilesPath = argv[index + 1] ?? "";
+            index += 1;
+        }
+        else if (arg === "--command-template") {
+            commandTemplate = parseAgentCommandTemplate(argv[index + 1] ?? "");
+            index += 1;
+        }
+        else if (arg === "--require-agent") {
+            requireAvailable = true;
+        }
+        else if (arg === "--timeout-ms") {
+            timeoutMs = Number(argv[index + 1] ?? "");
+            if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+                throw new Error("--timeout-ms must be a positive number.");
+            }
+            index += 1;
+        }
+    }
+    if (!agentId || !casesPath || !caseId || !strategy || !complexity || !outDir || !projectProfilesPath) {
+        throw new Error([
+            "Usage: --agent <fake-agent|codex|claude> --cases <path> --case <id>",
+            "--strategy <raw-full-file|my-dev-kit-guided> --complexity <short|medium|long|multi-step>",
+            "--out <directory> [--project-profiles <path>] [--command-template <command>] [--require-agent] [--timeout-ms <ms>]"
+        ].join(" "));
+    }
+    return {
+        agentId,
+        casesPath,
+        caseId,
+        strategy,
+        complexity,
+        outDir,
+        projectProfilesPath,
+        commandTemplate,
+        requireAvailable,
+        timeoutMs
+    };
+}
+export async function runAgentPromptFromArgs(args, repoRoot = process.cwd()) {
+    const projectProfiles = await readBenchmarkProjectProfiles(path.resolve(repoRoot, args.projectProfilesPath), repoRoot);
+    const cases = await readEvaluationCases(path.resolve(repoRoot, args.casesPath), repoRoot, {
+        projectProfiles,
+        requireProjectProfileRef: true
+    });
+    const evaluationCase = cases.find((candidate) => candidate.id === args.caseId);
+    if (!evaluationCase) {
+        throw new Error(`Evaluation case not found: ${args.caseId}`);
+    }
+    const [promptVariant] = generatePromptVariants({
+        cases: [evaluationCase],
+        projectProfiles,
+        strategies: [args.strategy],
+        complexityLevels: [args.complexity]
+    });
+    if (!promptVariant) {
+        throw new Error(`Failed to generate prompt variant for case: ${args.caseId}`);
+    }
+    const outDir = path.resolve(repoRoot, args.outDir);
+    const result = await runAgentPrompt({
+        runId: `${args.caseId}.${args.agentId}.${args.strategy}.${args.complexity}`,
+        agentId: args.agentId,
+        promptVariant,
+        promptText: promptVariant.promptText,
+        cwd: repoRoot,
+        outDir,
+        commandTemplate: args.commandTemplate,
+        timeoutMs: args.timeoutMs,
+        requireAvailable: args.requireAvailable,
+        env: process.env
+    });
+    return { projectProfiles, cases, promptVariant, result, outDir };
+}
+export async function runAgentPromptCommand(argv) {
+    try {
+        const args = parseRunAgentPromptArgs(argv);
+        const { result, outDir } = await runAgentPromptFromArgs(args);
+        console.log([
+            `Agent: ${result.agentId}`,
+            `Status: ${result.status}`,
+            `Prompt: ${path.join(outDir, "prompt.txt")}`,
+            `Result: ${path.join(outDir, "agent-run-result.json")}`
+        ].join("\n"));
+        return result.status === "failed" ? 1 : 0;
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        return 1;
+    }
+}

package/dist/src/commands/runControlledExperimentCommand.js

@@ -0,0 +1,174 @@
+import path from "node:path";
+import { parseAgentCommandTemplate } from "../agents/index.js";
+import { parseAgentId } from "../agents/agentRegistry.js";
+import { readBenchmarkProjectProfiles, readEvaluationCases } from "../evaluation/index.js";
+import { contextStrategyComparisonPlugin, resolveExperimentTarget } from "../experiments/index.js";
+import { parsePromptComplexityLevel, parsePromptStrategy } from "../prompts/index.js";
+export function parseRunControlledExperimentArgs(argv) {
+    let casesPath = "";
+    let projectProfilesPath = "benchmarks/contracts/benchmark-project-profiles.json";
+    let outDir = "";
+    const caseIds = [];
+    const benchmarkProjects = [];
+    let agents;
+    let strategies;
+    let complexityLevels;
+    let timeoutMs;
+    let maxRuns;
+    let continueOnFailure = true;
+    let requireAgents = false;
+    let includeRealAgents = false;
+    const commandTemplates = {};
+    for (let index = 0; index < argv.length; index += 1) {
+        const arg = argv[index];
+        if (arg === "--cases") {
+            casesPath = argv[index + 1] ?? "";
+            index += 1;
+        }
+        else if (arg === "--project-profiles") {
+            projectProfilesPath = argv[index + 1] ?? "";
+            index += 1;
+        }
+        else if (arg === "--case") {
+            caseIds.push(...splitList(argv[index + 1] ?? ""));
+            index += 1;
+        }
+        else if (arg === "--benchmark-project") {
+            benchmarkProjects.push(...splitList(argv[index + 1] ?? ""));
+            index += 1;
+        }
+        else if (arg === "--agents") {
+            agents = splitList(argv[index + 1] ?? "").map((value) => parseAgentId(value));
+            index += 1;
+        }
+        else if (arg === "--strategies") {
+            strategies = splitList(argv[index + 1] ?? "").map(parsePromptStrategy);
+            index += 1;
+        }
+        else if (arg === "--complexities") {
+            complexityLevels = splitList(argv[index + 1] ?? "").map(parsePromptComplexityLevel);
+            index += 1;
+        }
+        else if (arg === "--out") {
+            outDir = argv[index + 1] ?? "";
+            index += 1;
+        }
+        else if (arg === "--timeout-ms") {
+            timeoutMs = parsePositiveInteger("--timeout-ms", argv[index + 1] ?? "");
+            index += 1;
+        }
+        else if (arg === "--max-runs") {
+            maxRuns = parsePositiveInteger("--max-runs", argv[index + 1] ?? "");
+            index += 1;
+        }
+        else if (arg === "--continue-on-failure") {
+            continueOnFailure = true;
+        }
+        else if (arg === "--no-continue-on-failure") {
+            continueOnFailure = false;
+        }
+        else if (arg === "--require-agents") {
+            requireAgents = true;
+        }
+        else if (arg === "--include-real-agents") {
+            includeRealAgents = true;
+        }
+        else if (arg === "--command-template-codex") {
+            commandTemplates.codex = parseAgentCommandTemplate(argv[index + 1] ?? "");
+            index += 1;
+        }
+        else if (arg === "--command-template-claude") {
+            commandTemplates.claude = parseAgentCommandTemplate(argv[index + 1] ?? "");
+            index += 1;
+        }
+    }
+    if (!casesPath || !outDir) {
+        throw new Error([
+            "Usage: --cases <path> --out <directory>",
+            "[--project-profiles <path>] [--case <id>] [--benchmark-project <id>]",
+            "[--agents <fake-agent,codex,claude>] [--strategies <raw-full-file,my-dev-kit-guided>]",
+            "[--complexities <short,medium,long,multi-step>] [--timeout-ms <ms>] [--max-runs <n>]",
+            "[--continue-on-failure] [--require-agents] [--include-real-agents]",
+            "[--command-template-codex <command>] [--command-template-claude <command>]"
+        ].join(" "));
+    }
+    return {
+        casesPath,
+        projectProfilesPath,
+        caseIds: caseIds.length > 0 ? caseIds : undefined,
+        benchmarkProjects: benchmarkProjects.length > 0 ? benchmarkProjects : undefined,
+        agents,
+        strategies,
+        complexityLevels,
+        outDir,
+        timeoutMs,
+        requireAgents,
+        continueOnFailure,
+        maxRuns,
+        commandTemplates: Object.keys(commandTemplates).length > 0 ? commandTemplates : undefined,
+        includeRealAgents
+    };
+}
+export async function runControlledExperimentFromArgs(args, repoRoot = process.cwd()) {
+    const projectProfilesPath = path.resolve(repoRoot, args.projectProfilesPath ?? "benchmarks/contracts/benchmark-project-profiles.json");
+    const casesPath = path.resolve(repoRoot, args.casesPath);
+    const projectProfiles = await readBenchmarkProjectProfiles(projectProfilesPath, repoRoot);
+    const cases = await readEvaluationCases(casesPath, repoRoot, {
+        projectProfiles,
+        requireProjectProfileRef: true
+    });
+    const config = {
+        ...args,
+        casesPath: args.casesPath,
+        projectProfilesPath: args.projectProfilesPath
+    };
+    const validation = contextStrategyComparisonPlugin.validateConfig(config);
+    if (!validation.valid || !validation.config) {
+        throw new Error(`Invalid context strategy comparison config: ${validation.errors.join("; ")}`);
+    }
+    const result = await contextStrategyComparisonPlugin.run({
+        runId: `context-strategy-comparison-${Date.now()}`,
+        startedAt: new Date(),
+        toolRoot: repoRoot,
+        target: resolveExperimentTarget(undefined, repoRoot),
+        config: validation.config,
+        outputRoot: path.resolve(repoRoot, validation.config.outDir),
+        inputs: {
+            cases,
+            projectProfiles,
+            env: process.env
+        }
+    });
+    const artifacts = result.legacyArtifacts;
+    return { projectProfiles, cases, artifacts };
+}
+export async function runControlledExperimentCommand(argv) {
+    try {
+        const args = parseRunControlledExperimentArgs(argv);
+        const { artifacts } = await runControlledExperimentFromArgs(args);
+        console.log([
+            `Runs: ${artifacts.summary.totalRuns}`,
+            `Completed: ${artifacts.summary.completedRuns}`,
+            `Comparisons: ${artifacts.summary.totalComparisons}`,
+            `Output: ${path.resolve(args.outDir)}`
+        ].join("\n"));
+        return artifacts.summary.failedRuns > 0 && args.continueOnFailure === false ? 1 : 0;
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        return 1;
+    }
+}
+function splitList(value) {
+    return value
+        .split(",")
+        .map((item) => item.trim())
+        .filter(Boolean);
+}
+function parsePositiveInteger(label, value) {
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed <= 0) {
+        throw new Error(`${label} must be a positive integer.`);
+    }
+    return parsed;
+}

package/dist/src/commands/runFinalDemoCommand.js

@@ -0,0 +1,123 @@
+import path from "node:path";
+import { parsePromptComplexityLevel, parsePromptStrategy } from "../prompts/index.js";
+import { parseAgentId } from "../agents/agentRegistry.js";
+import { runControlledExperimentFromArgs } from "./runControlledExperimentCommand.js";
+import { runRenderExperimentReportFromArgs } from "./renderExperimentReportCommand.js";
+import { runGenerateExperimentPlotsFromArgs } from "./generateExperimentPlotsCommand.js";
+import { runVisualizationDemosFromArgs } from "./runVisualizationDemosCommand.js";
+import { runBuildGalleryFromArgs } from "./buildGalleryCommand.js";
+export function parseRunFinalDemoArgs(argv) {
+    let casesPath = "";
+    let outDir = "";
+    let kitCommand = "";
+    let agents = ["fake-agent"];
+    let strategies = ["raw-full-file", "my-dev-kit-guided"];
+    let complexities = ["short"];
+    let caseIds;
+    let benchmarkProjects;
+    let maxRuns;
+    let screenshot = false;
+    let includeRealAgents = false;
+    let continueOnFailure = true;
+    let timeoutMs;
+    for (let index = 0; index < argv.length; index += 1) {
+        const arg = argv[index];
+        if (arg === "--cases") {
+            casesPath = argv[++index] ?? "";
+        }
+        else if (arg === "--out") {
+            outDir = argv[++index] ?? "";
+        }
+        else if (arg === "--kit-command") {
+            kitCommand = argv[++index] ?? "";
+        }
+        else if (arg === "--agents") {
+            agents = splitList(argv[++index] ?? "").map((value) => parseAgentId(value));
+        }
+        else if (arg === "--strategies") {
+            strategies = splitList(argv[++index] ?? "").map(parsePromptStrategy);
+        }
+        else if (arg === "--complexities") {
+            complexities = splitList(argv[++index] ?? "").map(parsePromptComplexityLevel);
+        }
+        else if (arg === "--case") {
+            caseIds = splitList(argv[++index] ?? "");
+        }
+        else if (arg === "--benchmark-project") {
+            benchmarkProjects = splitList(argv[++index] ?? "");
+        }
+        else if (arg === "--max-runs") {
+            maxRuns = Number(argv[++index]);
+        }
+        else if (arg === "--screenshot") {
+            screenshot = true;
+        }
+        else if (arg === "--no-screenshot") {
+            screenshot = false;
+        }
+        else if (arg === "--include-real-agents") {
+            includeRealAgents = true;
+        }
+        else if (arg === "--continue-on-failure") {
+            continueOnFailure = true;
+        }
+        else if (arg === "--no-continue-on-failure") {
+            continueOnFailure = false;
+        }
+        else if (arg === "--timeout-ms") {
+            timeoutMs = Number(argv[++index]);
+        }
+    }
+    if (!casesPath || !outDir || !kitCommand)
+        throw new Error("Usage: --cases <path> --out <dir> --kit-command <command>");
+    return { casesPath, outDir, kitCommand, agents, strategies, complexities, caseIds, benchmarkProjects, maxRuns, screenshot, includeRealAgents, continueOnFailure, timeoutMs };
+}
+export async function runFinalDemoFromArgs(args, repoRoot = process.cwd()) {
+    const rootOut = path.resolve(repoRoot, args.outDir);
+    const experimentDir = path.join(rootOut, "controlled-experiment");
+    const plotsDir = path.join(rootOut, "plots");
+    const visualizationsDir = path.join(rootOut, "visualization-demos");
+    const reportDir = path.join(rootOut, "experiment-report");
+    const galleryDir = path.join(rootOut, "gallery");
+    const experiment = await runControlledExperimentFromArgs({
+        casesPath: args.casesPath,
+        projectProfilesPath: "benchmarks/contracts/benchmark-project-profiles.json",
+        outDir: experimentDir,
+        agents: args.agents,
+        strategies: args.strategies,
+        complexityLevels: args.complexities,
+        caseIds: args.caseIds,
+        benchmarkProjects: args.benchmarkProjects,
+        maxRuns: args.maxRuns,
+        includeRealAgents: args.includeRealAgents,
+        continueOnFailure: args.continueOnFailure,
+        timeoutMs: args.timeoutMs
+    }, repoRoot);
+    const plots = await runGenerateExperimentPlotsFromArgs({ experimentDir, outDir: plotsDir }, repoRoot);
+    const firstProject = experiment.projectProfiles[0]?.rootPath ?? "benchmarks/projects/todo-ts";
+    const visualization = await runVisualizationDemosFromArgs({ projectPath: firstProject, kitCommand: args.kitCommand, outDir: visualizationsDir, timeoutMs: args.timeoutMs }, repoRoot);
+    const report = await runRenderExperimentReportFromArgs({ experimentDir, outDir: reportDir, screenshot: args.screenshot, requireScreenshot: false, plotsDir, visualizationsDir }, repoRoot);
+    const gallery = await runBuildGalleryFromArgs({ experimentDir, reportDir, plotsDir, visualizationsDir, outDir: galleryDir }, repoRoot);
+    return { experiment, plots, visualization, report, gallery, outDir: rootOut };
+}
+export async function runFinalDemoCommand(argv) {
+    try {
+        const args = parseRunFinalDemoArgs(argv);
+        const result = await runFinalDemoFromArgs(args);
+        console.log([
+            `Experiment runs: ${result.experiment.artifacts.summary.totalRuns}`,
+            `Charts: ${result.plots.summary.chartCount}`,
+            `Visualization runs: ${result.visualization.summary.totalRuns}`,
+            `Gallery manifest: ${result.gallery.manifestPath}`,
+            `Output: ${result.outDir}`
+        ].join("\n"));
+        return 0;
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        return 1;
+    }
+}
+function splitList(value) {
+    return value.split(",").map((item) => item.trim()).filter(Boolean);
+}

package/dist/src/commands/runLabDemo.js

@@ -0,0 +1,62 @@
+import path from "node:path";
+import { validateBenchmarks } from "../../scripts/verify-benchmarks.js";
+import { runTokenSavingsEvaluation, parseEvaluateTokenSavingsArgs } from "./evaluateTokenSavings.js";
+import { writeGalleryManifest } from "../gallery/index.js";
+export function parseRunLabDemoArgs(argv) {
+    const evaluationArgs = parseEvaluateTokenSavingsArgs(argv);
+    return {
+        ...evaluationArgs,
+        skipBenchmarkValidation: argv.includes("--skip-benchmark-validation")
+    };
+}
+function summarize(result, outDir) {
+    return [
+        `Benchmark validation: ${result.benchmarkValidation.skipped ? "skipped" : result.benchmarkValidation.ok ? "passed" : "failed"}`,
+        `Cases: ${result.evaluation.artifacts.summary.caseCount}`,
+        `Completed: ${result.evaluation.artifacts.summary.completedCaseCount}`,
+        `Skipped: ${result.evaluation.artifacts.summary.skippedCaseCount}`,
+        `Gallery manifest: ${result.gallery.manifestPath}`,
+        `Output: ${outDir}`
+    ].join("\n");
+}
+export async function runLabDemo(args, repoRoot = process.cwd()) {
+    const warnings = [];
+    const benchmarkValidation = args.skipBenchmarkValidation
+        ? { skipped: true, ok: true, checks: [], errors: [] }
+        : { skipped: false, ...validateBenchmarks(repoRoot) };
+    if (!args.skipBenchmarkValidation && !benchmarkValidation.ok) {
+        throw new Error(`Benchmark validation failed:\n${benchmarkValidation.errors.map((error) => `- ${error}`).join("\n")}`);
+    }
+    if (args.skipBenchmarkValidation) {
+        warnings.push("Benchmark validation skipped because --skip-benchmark-validation was provided.");
+    }
+    const evaluation = await runTokenSavingsEvaluation(args, repoRoot);
+    const gallery = await writeGalleryManifest({
+        outDir: path.resolve(repoRoot, args.outDir),
+        summary: evaluation.artifacts.summary,
+        artifactPaths: evaluation.artifacts.artifactPaths,
+        screenshot: evaluation.artifacts.screenshot,
+        warnings: [...warnings, ...evaluation.artifacts.warnings]
+    });
+    return {
+        benchmarkValidation,
+        evaluation,
+        gallery,
+        warnings: gallery.manifest.warnings
+    };
+}
+export async function runLabDemoCommand(argv) {
+    try {
+        const args = parseRunLabDemoArgs(argv);
+        const result = await runLabDemo(args);
+        console.log(summarize(result, path.resolve(args.outDir)));
+        if (args.requireKit && result.evaluation.artifacts.summary.completedCaseCount === 0) {
+            return 1;
+        }
+        return 0;
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        return 1;
+    }
+}