@skyramp/mcp 0.3.2-rc.pom-4 → 0.3.2

package/build/adapters/jestAdapter.d.ts

@@ -0,0 +1,14 @@
+import { ParsedExternalRun } from "../types/ExternalTestExecution.js";
+export declare function parseJestJson(report: unknown, opts?: {
+    truncated?: boolean;
+}): ParsedExternalRun;
+export declare function buildJestArgs(input: {
+    selectors: string[];
+    mode: "confirm" | "verify" | "probe";
+    reportPath: string;
+}): string[];
+export declare function buildVitestArgs(input: {
+    selectors: string[];
+    mode: "confirm" | "verify" | "probe";
+    reportPath: string;
+}): string[];

package/build/adapters/jestAdapter.js

@@ -0,0 +1,113 @@
+/**
+ * Shared jest + vitest adapter for skyramp_run_existing_tests. vitest's json
+ * reporter is jest-compatible, so both use ONE parser; only the reporter flag
+ * differs (`--json` vs `--reporter=json`), hence two buildArgs. Native JSON
+ * (not junit): preserves the fail signal and file-level testExecError (mapped to
+ * `error`).
+ */
+import { stripVTControlCharacters } from "util";
+function mapAssertion(status) {
+    switch (status) {
+        case "passed":
+            return "pass";
+        case "failed":
+            return "fail";
+        case "pending":
+        case "skipped":
+        case "todo":
+        case "disabled":
+            return "skipped";
+        default:
+            return status ? "error" : "skipped";
+    }
+}
+export function parseJestJson(report, opts) {
+    const rep = (report ?? {});
+    const results = [];
+    for (const file of rep.testResults ?? []) {
+        const name = file.name ?? "(unknown)";
+        // A test file that failed to compile/run has no assertionResults. Jest
+        // surfaces the cause two ways depending on failure type: a structured
+        // `testExecError` (e.g. environment setup errors), OR — confirmed against a
+        // REAL jest run with a syntax error — `status: "failed"` plus a plain
+        // top-level `message` and no `testExecError` at all. Treat either as one
+        // synthetic `error` result (a broken test file is PR signal, unlike a
+        // Playwright global-setup failure).
+        const noAssertions = (file.assertionResults ?? []).length === 0;
+        const isExecFailure = noAssertions && (file.testExecError || file.status === "failed");
+        if (isExecFailure) {
+            const raw = file.testExecError?.message ?? file.message ?? "test file failed to run";
+            results.push({
+                testId: `${name} › (file failed to run)`,
+                file: name,
+                status: "error",
+                message: stripVTControlCharacters(raw).trim() || undefined,
+                durationMs: 0,
+            });
+            continue;
+        }
+        for (const a of file.assertionResults ?? []) {
+            const status = mapAssertion(a.status);
+            const titlePath = [...(a.ancestorTitles ?? []), a.title ?? ""].filter(Boolean).join(" › ");
+            const message = status === "fail" || status === "error"
+                ? stripVTControlCharacters((a.failureMessages ?? [])[0] ?? "").trim() || undefined
+                : undefined;
+            results.push({
+                testId: `${name} › ${titlePath}`,
+                file: name,
+                status,
+                message,
+                durationMs: Math.round(a.duration ?? 0),
+            });
+        }
+    }
+    const failed = results.filter((r) => r.status === "fail").length;
+    const errored = results.filter((r) => r.status === "error").length;
+    const skipped = results.filter((r) => r.status === "skipped").length;
+    const passed = results.filter((r) => r.status === "pass").length;
+    return {
+        results,
+        summary: { ran: passed + failed + errored, failed, errored, skipped, truncated: opts?.truncated ?? false },
+        environmentHealthy: true,
+    };
+}
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function splitSelectors(selectors) {
+    const files = [];
+    const titles = [];
+    for (const sel of selectors) {
+        const idx = sel.indexOf("::");
+        if (idx >= 0) {
+            const file = sel.slice(0, idx).trim();
+            const title = sel.slice(idx + 2).trim();
+            if (file && !files.includes(file))
+                files.push(file);
+            if (title)
+                titles.push(title);
+        }
+        else if (sel.trim() && !files.includes(sel.trim())) {
+            files.push(sel.trim());
+        }
+    }
+    return { files, titles };
+}
+export function buildJestArgs(input) {
+    const { files, titles } = splitSelectors(input.selectors);
+    const args = [...files, "--json", `--outputFile=${input.reportPath}`];
+    if (input.mode === "probe")
+        args.push("--bail=1");
+    if (titles.length > 0)
+        args.push("-t", titles.map(escapeRegex).join("|"));
+    return args;
+}
+export function buildVitestArgs(input) {
+    const { files, titles } = splitSelectors(input.selectors);
+    const args = [...files, "--reporter=json", `--outputFile=${input.reportPath}`];
+    if (input.mode === "probe")
+        args.push("--bail=1");
+    if (titles.length > 0)
+        args.push("-t", titles.map(escapeRegex).join("|"));
+    return args;
+}

package/build/adapters/mochaAdapter.d.ts

@@ -0,0 +1,13 @@
+import { ParsedExternalRun } from "../types/ExternalTestExecution.js";
+export declare function parseMochaJson(report: unknown, opts?: {
+    truncated?: boolean;
+}): ParsedExternalRun;
+/**
+ * Builds the args appended to the suite's `testRunCommand` (e.g. `npx mocha`).
+ * `--reporter json` prints the report to stdout (the generic runner captures
+ * it). Selectors are spec files, optionally `file::title` → `--grep`.
+ */
+export declare function buildMochaArgs(input: {
+    selectors: string[];
+    mode: "confirm" | "verify" | "probe";
+}): string[];

package/build/adapters/mochaAdapter.js

@@ -0,0 +1,87 @@
+/**
+ * Mocha adapter for skyramp_run_existing_tests. Normalizes `mocha --reporter
+ * json` (emitted to stdout) into the neutral shape. Mocha does not tag
+ * fail-vs-error, so we classify: an AssertionError is a test FAILURE; a hook
+ * failure or any other thrown error is an ERROR.
+ */
+import { stripVTControlCharacters } from "util";
+/** Assertion failure → fail; hook failure or any other throw → error. */
+function classifyFailure(t) {
+    const title = `${t.fullTitle ?? ""} ${t.title ?? ""}`;
+    // Mocha reports a hook failure with a title like `"before each" hook for "x"`.
+    // Match that specific shape (not a loose /hook/) so a normal test merely titled
+    // "...hook..." is not mislabeled as an environment error.
+    if (/"(before|after) (each|all)" hook\b/i.test(title))
+        return "error";
+    if (/assertion/i.test(t.err?.name ?? ""))
+        return "fail";
+    return "error";
+}
+function messageOf(t) {
+    const raw = t.err?.message ?? t.err?.stack;
+    if (!raw)
+        return undefined;
+    return stripVTControlCharacters(raw).split("\n")[0].trim() || undefined;
+}
+function toResult(t, status) {
+    const file = t.file ?? "(unknown)";
+    const full = t.fullTitle ?? t.title ?? "(unknown)";
+    return {
+        testId: `${file} › ${full}`,
+        file,
+        status,
+        message: status === "fail" || status === "error" ? messageOf(t) : undefined,
+        durationMs: Math.round(t.duration ?? 0),
+    };
+}
+export function parseMochaJson(report, opts) {
+    const rep = (report ?? {});
+    const results = [];
+    for (const t of rep.passes ?? [])
+        results.push(toResult(t, "pass"));
+    for (const t of rep.pending ?? [])
+        results.push(toResult(t, "skipped"));
+    for (const t of rep.failures ?? [])
+        results.push(toResult(t, classifyFailure(t)));
+    const failed = results.filter((r) => r.status === "fail").length;
+    const errored = results.filter((r) => r.status === "error").length;
+    const skipped = results.filter((r) => r.status === "skipped").length;
+    const passed = results.filter((r) => r.status === "pass").length;
+    return {
+        results,
+        summary: { ran: passed + failed + errored, failed, errored, skipped, truncated: opts?.truncated ?? false },
+        environmentHealthy: true,
+    };
+}
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/**
+ * Builds the args appended to the suite's `testRunCommand` (e.g. `npx mocha`).
+ * `--reporter json` prints the report to stdout (the generic runner captures
+ * it). Selectors are spec files, optionally `file::title` → `--grep`.
+ */
+export function buildMochaArgs(input) {
+    const files = [];
+    const titles = [];
+    for (const sel of input.selectors) {
+        const idx = sel.indexOf("::");
+        if (idx >= 0) {
+            const file = sel.slice(0, idx).trim();
+            const title = sel.slice(idx + 2).trim();
+            if (file && !files.includes(file))
+                files.push(file);
+            if (title)
+                titles.push(title);
+        }
+        else if (sel.trim() && !files.includes(sel.trim())) {
+            files.push(sel.trim());
+        }
+    }
+    const args = [...files, "--reporter", "json"];
+    if (input.mode === "probe")
+        args.push("--bail");
+    if (titles.length > 0)
+        args.push("--grep", titles.map(escapeRegex).join("|"));
+    return args;
+}

package/build/adapters/playwrightAdapter.d.ts

@@ -0,0 +1,17 @@
+import { ParsedExternalRun } from "../types/ExternalTestExecution.js";
+export declare function parsePlaywrightJson(report: unknown, opts?: {
+    truncated?: boolean;
+}): ParsedExternalRun;
+/**
+ * Builds the argument list appended to a suite's `testRunCommand` (e.g.
+ * `npx playwright test`). Selectors are spec files, optionally `file::title`
+ * to also filter by test name. Forces the JSON reporter for machine-readable
+ * results and, in confirm mode, disables the failure cap so ALL breakages are
+ * counted (Ghost's config sets `maxFailures: 1`, which would otherwise stop at
+ * the first break).
+ */
+export declare function buildPlaywrightArgs(input: {
+    selectors: string[];
+    mode: "confirm" | "verify";
+    project?: string;
+}): string[];

package/build/adapters/playwrightAdapter.js

@@ -0,0 +1,182 @@
+/**
+ * Playwright adapter for skyramp_run_existing_tests.
+ *
+ * Runs a repo's OWN Playwright suite (external, user-authored tests) and turns
+ * the `@playwright/test` JSON reporter output into the tool's neutral result
+ * shape. This is the DELEGATE-mode path (eng doc §7 / design spec §7): the
+ * suite owns environment bring-up (via a Playwright `global-setup` dependency
+ * and/or a wrapper entrypoint), and this adapter only drives the run with
+ * scoped selectors + config overrides and reads back structured results.
+ *
+ * The pure `parsePlaywrightJson` is the tested core; `buildPlaywrightArgs`
+ * builds the flags appended to the suite's `testRunCommand`. The IO shell that
+ * actually spawns the run lives in `runExistingTestsTool`.
+ */
+import { stripVTControlCharacters } from "util";
+/**
+ * A Playwright project (or spec file) is "infra" when it exists to bring up /
+ * tear down the environment rather than to assert product behavior. Its
+ * failures are environment health signals, not PR signals.
+ */
+function isInfraSpec(projectName, file) {
+    if (/setup|teardown/i.test(projectName ?? ""))
+        return true;
+    return /(^|\/)global[.-]?(setup|teardown)|\.(setup|teardown)\.[cm]?[jt]s$/i.test(file);
+}
+/** Depth-first walk collecting every spec with its file + describe-title path.
+ *  A file-level suite's own title is the filename, so it is NOT added to the
+ *  path; nested (describe) suite titles are. */
+function collectSpecs(suite, file, describePath, out) {
+    const suiteFile = suite.file ?? file;
+    for (const spec of suite.specs ?? []) {
+        out.push({ spec, file: spec.file ?? suiteFile, describePath });
+    }
+    for (const child of suite.suites ?? []) {
+        collectSpecs(child, suiteFile, [...describePath, child.title ?? ""], out);
+    }
+}
+/** Maps a single Playwright test (one project's run of a spec) to a neutral status. */
+function mapStatus(test) {
+    if (test.status === "skipped")
+        return "skipped";
+    const results = test.results ?? [];
+    if (results.length === 0)
+        return "skipped"; // never executed (e.g. dependency failed)
+    const final = results[results.length - 1];
+    switch (final.status) {
+        case "passed":
+            return "pass";
+        case "skipped":
+            return "skipped";
+        case "timedOut":
+        case "interrupted":
+            return "error";
+        case "failed":
+            return "fail";
+        default:
+            return final.status ? "error" : "skipped";
+    }
+}
+function messageOf(test) {
+    const results = test.results ?? [];
+    const final = results[results.length - 1];
+    const raw = final?.error?.message ?? final?.errors?.[0]?.message;
+    if (!raw)
+        return undefined;
+    return stripVTControlCharacters(raw).trim() || undefined;
+}
+export function parsePlaywrightJson(report, opts) {
+    const rep = (report ?? {});
+    const collected = [];
+    for (const fileSuite of rep.suites ?? []) {
+        collectSpecs(fileSuite, fileSuite.file ?? "", [], collected);
+    }
+    const results = [];
+    let environmentHealthy = true;
+    let healthDetail;
+    let infraSpecFailed = false;
+    const runLevelErrors = (rep.errors ?? []).map((e) => stripVTControlCharacters(e?.message ?? "unknown error").split("\n")[0]);
+    const isMaxFailuresBail = (m) => /maximum allowed failures|stopped early/i.test(m);
+    const maxFailuresBail = runLevelErrors.some(isMaxFailuresBail);
+    // A top-level error normally means the run never really started (import/config
+    // error) → broken environment. The exception is a --max-failures bail ("stopped
+    // early after N maximum allowed failures"): the run DID start and these are real
+    // product-test failures (still PR signal), so a bail must NOT flip
+    // environmentHealthy — otherwise downstream env-health logic would discard the
+    // failures it stands for. Only a non-bail run-level error marks the env unhealthy.
+    const firstFatalError = runLevelErrors.find((m) => !isMaxFailuresBail(m));
+    if (firstFatalError) {
+        environmentHealthy = false;
+        healthDetail =
+            `Playwright reported a run-level error; the suite could not be collected or configured. ` +
+                `First: ${firstFatalError}`;
+    }
+    for (const { spec, file, describePath } of collected) {
+        const tests = spec.tests ?? [];
+        const multiProject = tests.length > 1;
+        for (const test of tests) {
+            const status = mapStatus(test);
+            const infra = isInfraSpec(test.projectName, file);
+            if (infra) {
+                // Setup/teardown failure = broken environment, not a product failure, so
+                // the first failing infra spec flips environmentHealthy and its cause
+                // ("global-setup failed") — more actionable than any generic run-level
+                // line — wins the healthDetail.
+                if (status === "fail" || status === "error") {
+                    if (!infraSpecFailed) {
+                        environmentHealthy = false;
+                        healthDetail = `Environment setup failed: "${spec.title}" (${file}) reported ${status}. Skipped tests are not PR signal.`;
+                    }
+                    infraSpecFailed = true;
+                }
+                continue; // never reported as a test result
+            }
+            const titlePath = [...describePath, spec.title].filter(Boolean).join(" › ");
+            const testId = `${file} › ${titlePath}` +
+                (multiProject && test.projectName ? ` [${test.projectName}]` : "");
+            const durationMs = test.results?.[test.results.length - 1]?.duration ?? 0;
+            results.push({
+                testId,
+                file,
+                status,
+                message: status === "fail" || status === "error" ? messageOf(test) : undefined,
+                durationMs,
+            });
+        }
+    }
+    const failed = results.filter((r) => r.status === "fail").length;
+    const errored = results.filter((r) => r.status === "error").length;
+    const skipped = results.filter((r) => r.status === "skipped").length;
+    const passed = results.filter((r) => r.status === "pass").length;
+    return {
+        results,
+        summary: {
+            ran: passed + failed + errored,
+            failed,
+            errored,
+            skipped,
+            truncated: opts?.truncated ?? false,
+        },
+        environmentHealthy,
+        healthDetail,
+        diagnostics: { runLevelErrors, infraSpecFailed, maxFailuresBail },
+    };
+}
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/**
+ * Builds the argument list appended to a suite's `testRunCommand` (e.g.
+ * `npx playwright test`). Selectors are spec files, optionally `file::title`
+ * to also filter by test name. Forces the JSON reporter for machine-readable
+ * results and, in confirm mode, disables the failure cap so ALL breakages are
+ * counted (Ghost's config sets `maxFailures: 1`, which would otherwise stop at
+ * the first break).
+ */
+export function buildPlaywrightArgs(input) {
+    const files = [];
+    const titles = [];
+    for (const sel of input.selectors) {
+        const idx = sel.indexOf("::");
+        if (idx >= 0) {
+            const file = sel.slice(0, idx).trim();
+            const title = sel.slice(idx + 2).trim();
+            if (file && !files.includes(file))
+                files.push(file);
+            if (title)
+                titles.push(title);
+        }
+        else if (sel.trim() && !files.includes(sel.trim())) {
+            files.push(sel.trim());
+        }
+    }
+    const args = [...files, "--reporter=json"];
+    if (input.mode === "confirm")
+        args.push("--max-failures=0");
+    if (input.project)
+        args.push(`--project=${input.project}`);
+    if (titles.length > 0) {
+        args.push("--grep", titles.map(escapeRegex).join("|"));
+    }
+    return args;
+}

package/build/adapters/pytestAdapter.d.ts

@@ -0,0 +1,15 @@
+import { ParsedExternalRun } from "../types/ExternalTestExecution.js";
+export declare function parsePytestJson(report: unknown, opts?: {
+    truncated?: boolean;
+}): ParsedExternalRun;
+/**
+ * Builds the args appended to the suite's `testRunCommand` (e.g. `pytest`).
+ * Selectors are pytest nodeids (`file.py::Class::test`) and pass through as
+ * positional args — `file::test` IS a nodeid, so no separate name filter is
+ * needed. Forces the json-report reporter to the given path.
+ */
+export declare function buildPytestArgs(input: {
+    selectors: string[];
+    mode: "confirm" | "verify" | "probe";
+    reportPath: string;
+}): string[];

package/build/adapters/pytestAdapter.js

@@ -0,0 +1,108 @@
+/**
+ * pytest adapter for skyramp_run_existing_tests. Normalizes the
+ * `pytest-json-report` (`--json-report`) output into the neutral result shape.
+ * Native JSON (not junit): preserves the real nodeid and pytest's explicit
+ * passed/failed/error/skipped, so a fixture/collection error stays distinct from
+ * an assertion failure.
+ */
+import { stripVTControlCharacters } from "util";
+function mapOutcome(outcome) {
+    switch (outcome) {
+        case "passed":
+        case "xpassed":
+            return "pass";
+        case "failed":
+            return "fail";
+        case "error":
+            return "error";
+        case "skipped":
+        case "xfailed":
+            return "skipped";
+        default:
+            return outcome ? "error" : "skipped";
+    }
+}
+function fileOf(nodeid) {
+    const idx = nodeid.indexOf("::");
+    return idx >= 0 ? nodeid.slice(0, idx) : nodeid;
+}
+function messageOf(test) {
+    const raw = test.call?.longrepr ?? test.setup?.longrepr ?? test.teardown?.longrepr;
+    if (!raw)
+        return undefined;
+    return stripVTControlCharacters(raw).trim() || undefined;
+}
+function durationMsOf(test) {
+    const secs = (test.setup?.duration ?? 0) + (test.call?.duration ?? 0) + (test.teardown?.duration ?? 0);
+    return Math.round(secs * 1000);
+}
+export function parsePytestJson(report, opts) {
+    const rep = (report ?? {});
+    const tests = rep.tests ?? [];
+    // Real test outcomes.
+    const testResults = tests.map((t) => {
+        const status = mapOutcome(t.outcome);
+        const nodeid = t.nodeid ?? "(unknown)";
+        return {
+            testId: nodeid,
+            file: fileOf(nodeid),
+            status,
+            message: status === "fail" || status === "error" ? messageOf(t) : undefined,
+            durationMs: durationMsOf(t),
+        };
+    });
+    const collectionErrors = (rep.collectors ?? []).filter((c) => c.outcome === "error" || c.outcome === "failed");
+    const lastLine = (raw) => stripVTControlCharacters(raw ?? "collection error").split("\n").filter(Boolean).slice(-1)[0] ?? "collection error";
+    // Surface each collection/import error as an errored result so a broken file is
+    // never invisible — regardless of whether other selected files ran. A collection
+    // error IS a real breakage (PR signal), counted in `errored`/`ran`.
+    const collectionResults = collectionErrors.map((c) => {
+        const nodeid = c.nodeid ?? "(collection)";
+        return {
+            testId: `${nodeid} › (collection error)`,
+            file: fileOf(nodeid),
+            status: "error",
+            message: lastLine(c.longrepr),
+            durationMs: 0,
+        };
+    });
+    const results = [...testResults, ...collectionResults];
+    let environmentHealthy = true;
+    let healthDetail;
+    // When collection failed AND no real test ran, the suite as a whole could not be
+    // collected — environmental (a wall of red), not PR signal. When some real tests
+    // DID run, the collection errors above stand as ordinary PR-signal error results.
+    if (collectionErrors.length > 0 && testResults.length === 0) {
+        environmentHealthy = false;
+        const first = collectionErrors[0];
+        healthDetail = `pytest could not collect the suite: ${collectionErrors.length} collection error(s). First (${first.nodeid ?? "?"}): ${lastLine(first.longrepr)}`;
+    }
+    const failed = results.filter((r) => r.status === "fail").length;
+    const errored = results.filter((r) => r.status === "error").length;
+    const skipped = results.filter((r) => r.status === "skipped").length;
+    const passed = results.filter((r) => r.status === "pass").length;
+    return {
+        results,
+        summary: { ran: passed + failed + errored, failed, errored, skipped, truncated: opts?.truncated ?? false },
+        environmentHealthy,
+        healthDetail,
+        diagnostics: {
+            runLevelErrors: collectionErrors.map((c) => lastLine(c.longrepr)),
+            infraSpecFailed: false,
+            maxFailuresBail: false,
+        },
+    };
+}
+/**
+ * Builds the args appended to the suite's `testRunCommand` (e.g. `pytest`).
+ * Selectors are pytest nodeids (`file.py::Class::test`) and pass through as
+ * positional args — `file::test` IS a nodeid, so no separate name filter is
+ * needed. Forces the json-report reporter to the given path.
+ */
+export function buildPytestArgs(input) {
+    const args = input.selectors.map((s) => s.trim()).filter(Boolean);
+    args.push("--json-report", `--json-report-file=${input.reportPath}`);
+    if (input.mode === "probe")
+        args.push("--maxfail=1");
+    return args;
+}

package/build/commands/commandLibrary.d.ts

@@ -9,3 +9,4 @@ export declare function getCommandIds(): OneClickCommandId[];
 export declare function lookupCommand(id: string): OneClickCommandDef;
 export { TEST_GIVEN_ENDPOINT_COMPREHENSIVELY_COMMAND } from "./testThisEndpointCommand.js";
 export { FULLREPO_RECOMMEND_GENERATE_EXECUTE_TOPN_TESTS_COMMAND } from "./recommendTestsAndExecuteCommand.js";
+export { LOCAL_DEV_TEST_CHANGES_COMMAND } from "./localDevTestChangesCommand.js";

package/build/commands/commandLibrary.js

@@ -1,23 +1,28 @@
+import { isLocalDevEnabled, isOneClickEnabled } from "../utils/featureFlags.js";
 import { TEST_GIVEN_ENDPOINT_COMPREHENSIVELY_COMMAND } from "./testThisEndpointCommand.js";
 import { FULLREPO_RECOMMEND_GENERATE_EXECUTE_TOPN_TESTS_COMMAND } from "./recommendTestsAndExecuteCommand.js";
-/**
- * To add a new predefined workflow:
- * 1. Add a new id to OneClickCommandId in types/OneClickCommands.ts
- * 2. Create a new file in commands/ (e.g. myWorkflowCommand.ts) with steps and export the command
- * 3. Import the command here and add it to COMMAND_LIBRARY
- * 4. The generic buildWorkflowFromCommand() will render detailed instructions from your steps
- *    (no schema changes needed in oneClickTool.ts — the workflow param description is generated dynamically)
- */
-/** All predefined one-click commands */
-const COMMAND_LIBRARY = {
+import { LOCAL_DEV_TEST_CHANGES_COMMAND } from "./localDevTestChangesCommand.js";
+/** Base predefined one-click commands */
+const BASE_COMMAND_LIBRARY = {
     test_given_endpoint_comprehensively: TEST_GIVEN_ENDPOINT_COMPREHENSIVELY_COMMAND,
     full_repo_scan_recommend_generate_and_execute_top_n_tests: FULLREPO_RECOMMEND_GENERATE_EXECUTE_TOPN_TESTS_COMMAND,
 };
+/** All enabled predefined one-click commands */
+function getCommandLibrary() {
+    const commands = {};
+    if (isOneClickEnabled()) {
+        Object.assign(commands, BASE_COMMAND_LIBRARY);
+    }
+    if (isLocalDevEnabled()) {
+        commands.local_dev_test_changes = LOCAL_DEV_TEST_CHANGES_COMMAND;
+    }
+    return commands;
+}
 export function getAllCommands() {
-    return Object.values(COMMAND_LIBRARY);
+    return Object.values(getCommandLibrary()).filter((cmd) => Boolean(cmd));
 }
 export function getCommandIds() {
-    return Object.keys(COMMAND_LIBRARY);
+    return getAllCommands().map((cmd) => cmd.id);
 }
 /**
  * Look up a command by its string ID. Accepts any string so the tool handler
@@ -25,7 +30,7 @@ export function getCommandIds() {
  * the ID is not found.
  */
 export function lookupCommand(id) {
-    const cmd = COMMAND_LIBRARY[id];
+    const cmd = getCommandLibrary()[id];
     if (!cmd) {
         const available = getCommandIds().join(", ");
         throw new Error(`Unknown workflow: "${id}". Valid workflow IDs: ${available}.`);
@@ -35,3 +40,4 @@ export function lookupCommand(id) {
 // Re-export commands for consumers that import from commandLibrary
 export { TEST_GIVEN_ENDPOINT_COMPREHENSIVELY_COMMAND } from "./testThisEndpointCommand.js";
 export { FULLREPO_RECOMMEND_GENERATE_EXECUTE_TOPN_TESTS_COMMAND } from "./recommendTestsAndExecuteCommand.js";
+export { LOCAL_DEV_TEST_CHANGES_COMMAND } from "./localDevTestChangesCommand.js";

package/build/commands/localDevTestChangesCommand.d.ts

@@ -0,0 +1,15 @@
+import type { OneClickCommandDef } from "../types/OneClickCommands.js";
+/**
+ * Predefined One-Click Command: Local Dev — Test Changes
+ *
+ * This is the BOOTSTRAPPER / ENTRY POINT for local-dev testing.
+ * It handles first-time setup (skills + workspace), then delegates
+ * the actual test workflow to the `skyramp_local_dev` MCP prompt.
+ *
+ * Flow:
+ *   Step 0: Install IDE skill into repo for the calling agent
+ *   Step 1: Ensure .skyramp/workspace.yml exists
+ *   Step 2: Invoke skyramp_local_dev prompt (which runs the full workflow)
+ */
+export declare const LOCAL_DEV_SKILL_CONTENT = "---\nname: local-dev\ndescription: Run the Skyramp MCP local-dev workflow to test local code changes against a base branch. Use when the user asks to test changes, mock downstream services, validate a feature branch, run local-dev, or verify a PR before merge.\nuser_invocable: true\n---\n\n# local-dev\n\nUse the Skyramp MCP local-dev workflow as the source of truth. Do not recreate the workflow steps from this skill.\n\n## Usage\n\n`/local-dev` \u2014 diff against main (default)\n`/local-dev main --mock stripe,billing --real postgres,redis`\n\n## Invocation\n\nCall the `skyramp_local_dev` MCP prompt with the user's intent preserved:\n- `baseCommit`: branch/SHA to diff against (default: main)\n- `repositoryPath`: absolute path to repo\n- `servicesToMock`: comma-separated services the user explicitly wants mocked\n- `realServices`: comma-separated services that should receive real traffic\n- `mockProtocols`: comma-separated protocols the user explicitly wants mocked (for example, `rest`)\n\nBy default, mock only true third-party downstream services. Keep the service under test, infrastructure, and local first-party services real unless the user explicitly asks to mock them.\n";
+export declare const LOCAL_DEV_TEST_CHANGES_COMMAND: OneClickCommandDef;