@dailephd/my-dev-kit-lab 0.2.0

package/dist/src/agents/agentRegistry.js

@@ -0,0 +1,21 @@
+import { claudeAdapter } from "./adapters/claudeAdapter.js";
+import { codexAdapter } from "./adapters/codexAdapter.js";
+import { fakeAgentAdapter } from "./adapters/fakeAgentAdapter.js";
+export const agentAdapters = {
+    codex: codexAdapter,
+    claude: claudeAdapter,
+    "fake-agent": fakeAgentAdapter
+};
+export function getAgentAdapter(agentId) {
+    const adapter = agentAdapters[agentId];
+    if (!adapter) {
+        throw new Error(`Unknown agent adapter: ${agentId}`);
+    }
+    return adapter;
+}
+export function parseAgentId(value) {
+    if (value === "codex" || value === "claude" || value === "fake-agent") {
+        return value;
+    }
+    throw new Error(`Invalid agent id: ${value}`);
+}

package/dist/src/agents/index.js

@@ -0,0 +1,7 @@
+export * from "./types.js";
+export * from "./agentRegistry.js";
+export * from "./runAgentPrompt.js";
+export * from "./parseAgentTokenUsage.js";
+export * from "./adapters/fakeAgentAdapter.js";
+export * from "./adapters/codexAdapter.js";
+export * from "./adapters/claudeAdapter.js";

package/dist/src/agents/parseAgentTokenUsage.js

@@ -0,0 +1,137 @@
+const numberFields = {
+    inputTokens: ["input_tokens", "inputTokens", "prompt_tokens", "promptTokens"],
+    outputTokens: ["output_tokens", "outputTokens", "completion_tokens", "completionTokens"],
+    cachedInputTokens: [
+        "cached_input_tokens",
+        "cachedInputTokens",
+        "cacheReadInputTokens",
+        "cache_creation_input_tokens",
+        "cacheCreationInputTokens"
+    ],
+    reasoningTokens: ["reasoning_tokens", "reasoningTokens"],
+    totalTokens: ["total_tokens", "totalTokens"]
+};
+export function parseAgentTokenUsage(text) {
+    const warnings = [];
+    const jsonUsage = parseJsonUsage(text);
+    if (jsonUsage.found) {
+        return buildResult(jsonUsage.usage, "cli-json", text, warnings);
+    }
+    const plainTextUsage = parsePlainTextUsage(text);
+    if (plainTextUsage.found) {
+        return buildResult(plainTextUsage.usage, "agent-reported", text, warnings);
+    }
+    warnings.push("Token usage was not found in agent output.");
+    return {
+        tokenUsage: { source: "unavailable", rawText: text },
+        tokenUsageSource: "unavailable",
+        tokenUsageReliability: "unavailable",
+        warnings
+    };
+}
+function parseJsonUsage(text) {
+    const usage = {};
+    for (const candidate of collectJsonCandidates(text)) {
+        try {
+            mergeUsage(usage, extractUsage(JSON.parse(candidate)));
+        }
+        catch {
+            // Agent output is often mixed JSONL plus text; malformed lines are ignored.
+        }
+    }
+    return { found: hasAnyUsage(usage), usage };
+}
+function collectJsonCandidates(text) {
+    const trimmed = text.trim();
+    const candidates = [];
+    if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+        candidates.push(trimmed);
+    }
+    for (const line of text.split(/\r?\n/)) {
+        const lineTrimmed = line.trim();
+        if (lineTrimmed.startsWith("{") || lineTrimmed.startsWith("[")) {
+            candidates.push(lineTrimmed);
+        }
+    }
+    return [...new Set(candidates)];
+}
+function extractUsage(value) {
+    const usage = {};
+    visit(value, usage);
+    return usage;
+}
+function visit(value, usage) {
+    if (!value || typeof value !== "object") {
+        return;
+    }
+    if (Array.isArray(value)) {
+        value.forEach((item) => visit(item, usage));
+        return;
+    }
+    const record = value;
+    for (const [usageKey, fieldNames] of Object.entries(numberFields)) {
+        for (const fieldName of fieldNames) {
+            const fieldValue = record[fieldName];
+            if (typeof fieldValue === "number" && Number.isFinite(fieldValue)) {
+                usage[usageKey] = Math.max(usage[usageKey] ?? 0, fieldValue);
+            }
+        }
+    }
+    for (const child of Object.values(record)) {
+        visit(child, usage);
+    }
+}
+function parsePlainTextUsage(text) {
+    const usage = {};
+    const patterns = [
+        ["inputTokens", /(?:input|prompt)\s+tokens?\s*[:=]\s*(\d+)/i],
+        ["outputTokens", /(?:output|completion)\s+tokens?\s*[:=]\s*(\d+)/i],
+        ["cachedInputTokens", /cached\s+input\s+tokens?\s*[:=]\s*(\d+)/i],
+        ["reasoningTokens", /reasoning\s+tokens?\s*[:=]\s*(\d+)/i],
+        ["totalTokens", /total\s+tokens?\s*[:=]\s*(\d+)/i]
+    ];
+    for (const [key, pattern] of patterns) {
+        const match = text.match(pattern);
+        if (match?.[1]) {
+            usage[key] = Number(match[1]);
+        }
+    }
+    return { found: hasAnyUsage(usage), usage };
+}
+function mergeUsage(target, source) {
+    for (const key of Object.keys(numberFields)) {
+        if (source[key] !== undefined) {
+            target[key] = Math.max(target[key] ?? 0, source[key]);
+        }
+    }
+}
+function hasAnyUsage(usage) {
+    return Object.values(usage).some((value) => typeof value === "number");
+}
+function buildResult(usage, source, rawText, warnings) {
+    if (usage.totalTokens === undefined && (usage.inputTokens !== undefined || usage.outputTokens !== undefined)) {
+        usage.totalTokens = (usage.inputTokens ?? 0) + (usage.outputTokens ?? 0) + (usage.reasoningTokens ?? 0);
+    }
+    const reliability = determineReliability(usage, source);
+    if (reliability !== "high") {
+        warnings.push("Token usage was partial in agent output.");
+    }
+    const tokenUsage = {
+        ...usage,
+        source,
+        rawText
+    };
+    return {
+        tokenUsage,
+        tokenUsageSource: source,
+        tokenUsageReliability: reliability,
+        warnings
+    };
+}
+function determineReliability(usage, source) {
+    const complete = usage.totalTokens !== undefined && (usage.inputTokens !== undefined || usage.outputTokens !== undefined);
+    if (source === "cli-json") {
+        return complete ? "high" : "medium";
+    }
+    return complete ? "medium" : "low";
+}

package/dist/src/agents/runAgentPrompt.js

@@ -0,0 +1,38 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { parseCommandString } from "../core/commandLine.js";
+import { getAgentAdapter } from "./agentRegistry.js";
+export async function runAgentPrompt(options) {
+    await mkdir(options.outDir, { recursive: true });
+    await writeFile(path.join(options.outDir, "prompt.txt"), options.promptText, "utf8");
+    const adapter = getAgentAdapter(options.agentId);
+    const result = await adapter.runPrompt(options);
+    await writeFile(path.join(options.outDir, "agent-run-result.json"), `${JSON.stringify(result, null, 2)}\n`, "utf8");
+    return result;
+}
+export function parseAgentCommandTemplate(template) {
+    const parts = parseCommandString(template);
+    return {
+        command: parts.executable,
+        args: parts.args,
+        promptPlaceholder: "{prompt}"
+    };
+}
+export function applyPromptToCommandTemplate(template, promptText) {
+    let replaced = false;
+    const args = template.args.map((arg) => {
+        if (arg.includes(`{${template.promptPlaceholder}}`)) {
+            replaced = true;
+            return arg.replaceAll(`{${template.promptPlaceholder}}`, promptText);
+        }
+        if (arg.includes(template.promptPlaceholder)) {
+            replaced = true;
+            return arg.replaceAll(template.promptPlaceholder, promptText);
+        }
+        return arg;
+    });
+    if (!replaced) {
+        args.push(promptText);
+    }
+    return { command: template.command, args };
+}

package/dist/src/agents/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/commands/buildGalleryCommand.js

@@ -0,0 +1,56 @@
+import path from "node:path";
+import { writeExperimentGalleryManifest } from "../gallery/index.js";
+export function parseBuildGalleryArgs(argv) {
+    let outDir = "";
+    let reportDir;
+    let plotsDir;
+    let visualizationsDir;
+    let experimentDir;
+    for (let index = 0; index < argv.length; index += 1) {
+        const arg = argv[index];
+        if (arg === "--report") {
+            reportDir = 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;
+        }
+        else if (arg === "--experiment") {
+            experimentDir = argv[index + 1] ?? "";
+            index += 1;
+        }
+        else if (arg === "--out") {
+            outDir = argv[index + 1] ?? "";
+            index += 1;
+        }
+    }
+    if (!outDir)
+        throw new Error("Usage: --out <dir> [--report <dir>] [--plots <dir>] [--visualizations <dir>] [--experiment <dir>]");
+    return { outDir, reportDir, plotsDir, visualizationsDir, experimentDir };
+}
+export async function runBuildGalleryFromArgs(args, repoRoot = process.cwd()) {
+    return writeExperimentGalleryManifest({
+        outDir: path.resolve(repoRoot, args.outDir),
+        reportDir: args.reportDir ? path.resolve(repoRoot, args.reportDir) : undefined,
+        plotsDir: args.plotsDir ? path.resolve(repoRoot, args.plotsDir) : undefined,
+        visualizationsDir: args.visualizationsDir ? path.resolve(repoRoot, args.visualizationsDir) : undefined,
+        experimentDir: args.experimentDir ? path.resolve(repoRoot, args.experimentDir) : undefined
+    });
+}
+export async function runBuildGalleryCommand(argv) {
+    try {
+        const args = parseBuildGalleryArgs(argv);
+        const gallery = await runBuildGalleryFromArgs(args);
+        console.log([`Items: ${gallery.manifest.items.length}`, `Manifest: ${gallery.manifestPath}`, `Index: ${gallery.indexPath}`].join("\n"));
+        return 0;
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        return 1;
+    }
+}

package/dist/src/commands/captureDemoReport.js

@@ -0,0 +1,116 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { captureReportScreenshot, SCREENSHOT_SKIP_WARNING } from "../screenshot/index.js";
+import { getReportArtifactPaths, normalizeLabReport, writeReportArtifacts } from "../report/index.js";
+function parseArgs(argv) {
+    let inputPath = "";
+    let outDir = "";
+    let noScreenshot = false;
+    for (let index = 0; index < argv.length; index += 1) {
+        const arg = argv[index];
+        if (arg === "--input") {
+            inputPath = argv[index + 1] ?? "";
+            index += 1;
+        }
+        else if (arg === "--out") {
+            outDir = argv[index + 1] ?? "";
+            index += 1;
+        }
+        else if (arg === "--no-screenshot") {
+            noScreenshot = true;
+        }
+    }
+    if (!inputPath || !outDir) {
+        throw new Error("Usage: --input <path> --out <directory> [--no-screenshot]");
+    }
+    return { inputPath, outDir, noScreenshot };
+}
+function validateReportInput(value) {
+    if (!value || typeof value !== "object") {
+        throw new Error("Report input must be a JSON object.");
+    }
+    const report = value;
+    const requiredStringFields = ["reportId", "title", "projectName", "benchmarkProject", "workflowName", "summary"];
+    for (const field of requiredStringFields) {
+        if (typeof report[field] !== "string" || report[field] === "") {
+            throw new Error(`Missing required field: ${field}`);
+        }
+    }
+    const requiredArrayFields = ["steps", "metrics", "artifacts", "warnings"];
+    for (const field of requiredArrayFields) {
+        if (!Array.isArray(report[field])) {
+            throw new Error(`Missing required field: ${field}`);
+        }
+    }
+}
+function summarizeResult(result) {
+    const lines = [
+        `Report ID: ${result.report.reportId}`,
+        `HTML: ${result.outputPaths.htmlPath}`,
+        `JSON: ${result.outputPaths.jsonPath}`
+    ];
+    if (result.screenshot.status === "captured") {
+        lines.push(`PNG: ${result.outputPaths.pngPath}`);
+    }
+    if (result.screenshot.status === "skipped" && result.screenshot.warning) {
+        lines.push(result.screenshot.warning);
+    }
+    if (result.screenshot.status === "failed" && result.screenshot.error) {
+        lines.push(`PNG screenshot failed: ${result.screenshot.error}`);
+    }
+    return lines.join("\n");
+}
+export async function runCaptureDemoReportCommand(argv) {
+    try {
+        const args = parseArgs(argv);
+        const rawInput = await readFile(path.resolve(args.inputPath), "utf8").catch((error) => {
+            const fileError = error;
+            if (fileError.code === "ENOENT") {
+                throw new Error(`Input file not found: ${args.inputPath}`);
+            }
+            throw error;
+        });
+        let parsed;
+        try {
+            parsed = JSON.parse(rawInput);
+        }
+        catch (error) {
+            throw new Error(`Invalid JSON input: ${error.message}`);
+        }
+        validateReportInput(parsed);
+        const report = normalizeLabReport(parsed);
+        const outDir = path.resolve(args.outDir);
+        const outputPaths = getReportArtifactPaths(outDir, report.reportId);
+        let screenshot;
+        if (args.noScreenshot) {
+            screenshot = {
+                status: "skipped",
+                htmlPath: outputPaths.htmlPath,
+                pngPath: outputPaths.pngPath,
+                warning: "PNG screenshot skipped because --no-screenshot was provided."
+            };
+        }
+        else {
+            await writeReportArtifacts({
+                report,
+                outDir,
+                screenshot: {
+                    status: "skipped",
+                    htmlPath: outputPaths.htmlPath,
+                    pngPath: outputPaths.pngPath
+                }
+            });
+            screenshot = await captureReportScreenshot(outputPaths.htmlPath, outputPaths.pngPath);
+            if (screenshot.status === "skipped" && !screenshot.warning) {
+                screenshot.warning = SCREENSHOT_SKIP_WARNING;
+            }
+        }
+        const result = await writeReportArtifacts({ report, outDir, screenshot });
+        console.log(summarizeResult(result));
+        return screenshot.status === "failed" ? 1 : 0;
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        return 1;
+    }
+}

package/dist/src/commands/evaluateTokenSavings.js

@@ -0,0 +1,175 @@
+import path from "node:path";
+import { readEvaluationCases, runRawFullFileBaseline, runMyDevKitRetrieval, compareTokenSavings, writeTokenSavingsArtifacts } from "../evaluation/index.js";
+import { captureReportScreenshot, SCREENSHOT_SKIP_WARNING } from "../screenshot/index.js";
+export function parseEvaluateTokenSavingsArgs(argv) {
+    let casesPath = "";
+    let kitCommand = "";
+    let outDir = "";
+    let requireKit = false;
+    let noScreenshot = false;
+    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 === "--kit-command") {
+            kitCommand = argv[index + 1] ?? "";
+            index += 1;
+        }
+        else if (arg === "--out") {
+            outDir = argv[index + 1] ?? "";
+            index += 1;
+        }
+        else if (arg === "--require-kit") {
+            requireKit = true;
+        }
+        else if (arg === "--no-screenshot") {
+            noScreenshot = true;
+        }
+    }
+    if (!casesPath || !kitCommand || !outDir) {
+        throw new Error("Usage: --cases <path> --kit-command <command> --out <directory> [--require-kit] [--no-screenshot]");
+    }
+    return { casesPath, kitCommand, outDir, requireKit, noScreenshot };
+}
+function summarize(summary, outDir) {
+    return [
+        `Cases: ${summary.caseCount}`,
+        `Completed: ${summary.completedCaseCount}`,
+        `Skipped: ${summary.skippedCaseCount}`,
+        `Total estimated tokens saved: ${summary.totalTokensSaved}`,
+        `Output: ${outDir}`
+    ].join("\n");
+}
+export async function runTokenSavingsEvaluation(args, repoRoot = process.cwd()) {
+    const cases = await readEvaluationCases(path.resolve(repoRoot, args.casesPath), repoRoot);
+    const outputDir = path.resolve(repoRoot, args.outDir);
+    const commandConfig = {
+        casesPath: path.resolve(repoRoot, args.casesPath),
+        kitCommand: args.kitCommand,
+        requireKit: args.requireKit,
+        noScreenshot: args.noScreenshot,
+        outputDir
+    };
+    const evaluations = [];
+    for (const evaluationCase of cases) {
+        const rawBaseline = await runRawFullFileBaseline(evaluationCase);
+        const myDevKit = await runMyDevKitRetrieval({
+            evaluationCase,
+            kitCommand: args.kitCommand,
+            outputDir,
+            requireKit: args.requireKit
+        });
+        evaluations.push({ evaluationCase, rawBaseline, myDevKit });
+    }
+    const comparison = compareTokenSavings(evaluations);
+    let screenshot = {
+        status: "skipped",
+        htmlPath: path.join(outputDir, "token-savings-report.html"),
+        pngPath: path.join(outputDir, "token-savings-report.png")
+    };
+    const runs = evaluations.map(({ evaluationCase, rawBaseline, myDevKit }, index) => ({
+        case: {
+            id: evaluationCase.id,
+            title: evaluationCase.title,
+            benchmarkProject: evaluationCase.benchmarkProject,
+            targetRoot: evaluationCase.targetRoot,
+            sourceRoots: evaluationCase.sourceRoots,
+            query: evaluationCase.query,
+            expectedFiles: evaluationCase.expectedFiles,
+            expectedSymbols: evaluationCase.expectedSymbols,
+            rawIncludeGlobs: evaluationCase.rawIncludeGlobs,
+            notes: evaluationCase.notes
+        },
+        rawBaseline: {
+            caseId: rawBaseline.caseId,
+            targetRoot: rawBaseline.targetRoot,
+            filesIncluded: rawBaseline.filesIncluded,
+            totalFiles: rawBaseline.totalFiles,
+            totalChars: rawBaseline.totalChars,
+            totalEstimatedTokens: rawBaseline.totalEstimatedTokens,
+            tokenCountMethod: rawBaseline.tokenCountMethod,
+            durationMs: rawBaseline.durationMs
+        },
+        myDevKit: {
+            caseId: myDevKit.caseId,
+            skipped: myDevKit.skipped,
+            warnings: myDevKit.warnings,
+            totalChars: myDevKit.totalChars,
+            totalEstimatedTokens: myDevKit.totalEstimatedTokens,
+            tokenCountMethod: myDevKit.tokenCountMethod,
+            filesRead: myDevKit.filesRead,
+            commands: myDevKit.commands,
+            selectedNodeId: myDevKit.selectedNodeId,
+            selectedFile: myDevKit.selectedFile,
+            selectedSymbol: myDevKit.selectedSymbol,
+            durationMs: myDevKit.durationMs,
+            commandTelemetry: myDevKit.commands.map((command) => ({
+                commandId: command.commandId,
+                stdoutPath: command.stdoutPath,
+                stderrPath: command.stderrPath,
+                telemetryPath: command.telemetryPath,
+                exitCode: command.exitCode,
+                ok: command.ok
+            }))
+        },
+        comparison: comparison.cases[index]
+    }));
+    let artifacts = await writeTokenSavingsArtifacts({
+        outDir: outputDir,
+        summary: comparison.summary,
+        runs,
+        comparisonCases: comparison.cases,
+        commandConfig,
+        screenshot
+    });
+    if (args.noScreenshot) {
+        screenshot = {
+            status: "skipped",
+            htmlPath: artifacts.artifactPaths.htmlPath,
+            pngPath: artifacts.artifactPaths.pngPath,
+            warning: "PNG screenshot skipped because --no-screenshot was provided."
+        };
+    }
+    else {
+        screenshot = await captureReportScreenshot(artifacts.artifactPaths.htmlPath, artifacts.artifactPaths.pngPath);
+        if (screenshot.status === "skipped" && !screenshot.warning) {
+            screenshot.warning = SCREENSHOT_SKIP_WARNING;
+        }
+    }
+    artifacts = await writeTokenSavingsArtifacts({
+        outDir: outputDir,
+        summary: comparison.summary,
+        runs,
+        comparisonCases: comparison.cases,
+        commandConfig,
+        screenshot
+    });
+    return {
+        commandConfig,
+        cases,
+        runs,
+        comparison,
+        artifacts
+    };
+}
+export async function runEvaluateTokenSavingsCommand(argv) {
+    try {
+        const args = parseEvaluateTokenSavingsArgs(argv);
+        const result = await runTokenSavingsEvaluation(args);
+        const { artifacts } = result;
+        console.log(summarize(artifacts.summary, result.commandConfig.outputDir));
+        if (args.requireKit && artifacts.summary.completedCaseCount === 0) {
+            return 1;
+        }
+        if (artifacts.screenshot.status === "failed" && args.requireKit) {
+            return 1;
+        }
+        return 0;
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        return 1;
+    }
+}

package/dist/src/commands/generateExperimentPlotsCommand.js

@@ -0,0 +1,38 @@
+import path from "node:path";
+import { writePlotArtifacts } from "../plots/index.js";
+export function parseGenerateExperimentPlotsArgs(argv) {
+    let experimentDir = "";
+    let outDir = "";
+    for (let index = 0; index < argv.length; index += 1) {
+        if (argv[index] === "--experiment") {
+            experimentDir = argv[index + 1] ?? "";
+            index += 1;
+        }
+        else if (argv[index] === "--out") {
+            outDir = argv[index + 1] ?? "";
+            index += 1;
+        }
+    }
+    if (!experimentDir || !outDir)
+        throw new Error("Usage: --experiment <dir> --out <dir>");
+    return { experimentDir, outDir };
+}
+export async function runGenerateExperimentPlotsFromArgs(args, repoRoot = process.cwd()) {
+    return writePlotArtifacts({
+        experimentDir: path.resolve(repoRoot, args.experimentDir),
+        outDir: path.resolve(repoRoot, args.outDir),
+        repoRoot
+    });
+}
+export async function runGenerateExperimentPlotsCommand(argv) {
+    try {
+        const args = parseGenerateExperimentPlotsArgs(argv);
+        const artifacts = await runGenerateExperimentPlotsFromArgs(args);
+        console.log([`Charts: ${artifacts.summary.chartCount}`, `Skipped points: ${artifacts.summary.skippedPointCount}`, `Output: ${path.resolve(args.outDir)}`].join("\n"));
+        return 0;
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        return 1;
+    }
+}

package/dist/src/commands/generatePromptVariants.js

@@ -0,0 +1,67 @@
+import path from "node:path";
+import { readBenchmarkProjectProfiles, readEvaluationCases } from "../evaluation/index.js";
+import { generatePromptVariants, parsePromptComplexityLevel, parsePromptStrategy, writePromptArtifacts } from "../prompts/index.js";
+export function parseGeneratePromptVariantsArgs(argv) {
+    let casesPath = "";
+    let outDir = "";
+    let projectProfilesPath = "benchmarks/contracts/benchmark-project-profiles.json";
+    let strategy;
+    let complexity;
+    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 === "--out") {
+            outDir = argv[index + 1] ?? "";
+            index += 1;
+        }
+        else if (arg === "--project-profiles") {
+            projectProfilesPath = 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;
+        }
+    }
+    if (!casesPath || !outDir || !projectProfilesPath) {
+        throw new Error("Usage: --cases <path> --out <directory> [--project-profiles <path>] [--strategy <raw-full-file|my-dev-kit-guided>] [--complexity <short|medium|long|multi-step>]");
+    }
+    return { casesPath, outDir, projectProfilesPath, strategy, complexity };
+}
+export async function runGeneratePromptVariants(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 variants = generatePromptVariants({
+        cases,
+        projectProfiles,
+        strategies: args.strategy ? [args.strategy] : undefined,
+        complexityLevels: args.complexity ? [args.complexity] : undefined
+    });
+    const summary = await writePromptArtifacts({
+        outDir: path.resolve(repoRoot, args.outDir),
+        variants
+    });
+    return { cases, projectProfiles, variants, summary };
+}
+export async function runGeneratePromptVariantsCommand(argv) {
+    try {
+        const args = parseGeneratePromptVariantsArgs(argv);
+        const result = await runGeneratePromptVariants(args);
+        console.log([`Cases: ${result.summary.caseCount}`, `Prompts: ${result.summary.promptCount}`, `Output: ${path.resolve(args.outDir)}`].join("\n"));
+        return 0;
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        return 1;
+    }
+}