@webpresso/agent-kit 0.21.0

package/dist/esm/mcp/tools/format.js

@@ -0,0 +1,107 @@
+/**
+ * `wp_format` MCP tool.
+ *
+ * Runs `oxfmt` on the resolved project root. By default writes fixes in
+ * place; pass `check: true` to verify formatting without writing (useful
+ * for CI / pre-commit). Returns the standard summary-first payload:
+ *
+ *   {
+ *     passed: boolean,
+ *     summary: string,
+ *     exitCode: number,
+ *     details: { spawnError?: string },
+ *   }
+ *
+ * No fallback — `oxfmt` must be on PATH. When missing, the tool returns
+ * `isError: true` with a clear install hint.
+ */
+import { z } from 'zod';
+import { applyOutputTransform } from '#output-transforms/index';
+import { resolveProjectRoot } from './_shared/project-root.js';
+import { createSummaryOutputSchema, createSummaryResult } from './_shared/result.js';
+import { isMissingBinary, isRunFailure, runCommand } from './_shared/run-command.js';
+const inputSchema = z.object({
+    check: z.boolean().optional().default(false),
+    cwd: z.string().optional(),
+});
+const outputSchema = createSummaryOutputSchema({
+    details: z.object({
+        spawnError: z.string().optional(),
+    }),
+});
+const FORMAT_COMMAND_TIMEOUT_MS = 5 * 60 * 1_000;
+const tool = {
+    name: 'wp_format',
+    description: 'Run formatter via `oxfmt`. By default writes fixes in place; pass `check: true` to verify without writing. No fallback — oxfmt must be on PATH.',
+    inputSchema,
+    outputSchema,
+    annotations: {
+        title: 'Format',
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+    handler: async (raw, extra) => {
+        const input = inputSchema.parse(raw ?? {});
+        const cwd = resolveProjectRoot(input.cwd ? { explicitCwd: input.cwd } : {});
+        const runOptions = {
+            timeoutMs: FORMAT_COMMAND_TIMEOUT_MS,
+            signal: extra?.signal,
+            cwd,
+        };
+        const args = input.check ? ['--check'] : ['--write'];
+        // Force --ignore-path to .gitignore so a `*` .prettierignore (used to
+        // disable conflicting IDE Prettier extensions) doesn't make oxfmt skip
+        // every file. .oxfmtrc.json#ignorePatterns still applies on top.
+        args.push('--ignore-path', '.gitignore');
+        const outcome = await runCommand('oxfmt', args, runOptions);
+        if (isRunFailure(outcome)) {
+            const message = isMissingBinary(outcome)
+                ? 'oxfmt binary not found on PATH. Install with: vp install -D oxfmt'
+                : `oxfmt spawn failed: ${outcome.error.code ?? 'unknown'} ${outcome.error.message}`;
+            const payload = {
+                passed: false,
+                summary: isMissingBinary(outcome)
+                    ? 'format could not start: oxfmt binary missing on PATH'
+                    : 'format could not start: oxfmt spawn failed',
+                exitCode: 1,
+                details: { spawnError: message },
+            };
+            return createSummaryResult(payload, { isError: true });
+        }
+        const combined = [outcome.stdout, outcome.stderr].filter(Boolean).join('');
+        const { transform: _transform, ...compact } = applyOutputTransform(combined, {
+            toolName: 'wp_format',
+        });
+        const payload = {
+            passed: outcome.exitCode === 0,
+            summary: summarizeFormatResult({
+                passed: outcome.exitCode === 0,
+                check: input.check,
+                exitCode: outcome.exitCode,
+                timedOut: outcome.timedOut,
+                aborted: outcome.aborted,
+            }),
+            exitCode: outcome.exitCode,
+            details: {},
+            ...compact,
+            timedOut: outcome.timedOut || undefined,
+            aborted: outcome.aborted || undefined,
+        };
+        return createSummaryResult(payload);
+    },
+};
+function summarizeFormatResult(options) {
+    if (options.timedOut)
+        return 'format timed out';
+    if (options.aborted)
+        return 'format aborted';
+    if (options.passed)
+        return options.check ? 'format check passed' : 'format applied';
+    return options.check
+        ? `format check failed (exit ${options.exitCode}) — run \`wp format\` to apply fixes`
+        : `format failed (exit ${options.exitCode})`;
+}
+export default tool;
+//# sourceMappingURL=format.js.map

package/dist/esm/mcp/tools/lint.d.ts

@@ -0,0 +1,26 @@
+/**
+ * `wp_lint` MCP tool.
+ *
+ * Runs `vp lint` on the supplied files (or `.` when none are given). Returns a
+ * structured payload:
+ *
+ *   {
+ *     passed: boolean,
+ *     issues: Array<{file, line, rule, message}>,
+ *     exitCode: number,
+ *   }
+ *
+ * `vp lint --format=json` forwards to the bundled Oxlint engine while keeping
+ * the repo command surface on the `vp` facade.
+ */
+import { z } from 'zod';
+import type { ToolDescriptor } from '#mcp/auto-discover';
+declare const inputSchema: z.ZodObject<{
+    cwd: z.ZodOptional<z.ZodString>;
+    files: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    fix: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, z.core.$strip>;
+export type AkLintInput = z.infer<typeof inputSchema>;
+declare const tool: ToolDescriptor;
+export default tool;
+//# sourceMappingURL=lint.d.ts.map

package/dist/esm/mcp/tools/lint.js

@@ -0,0 +1,229 @@
+/**
+ * `wp_lint` MCP tool.
+ *
+ * Runs `vp lint` on the supplied files (or `.` when none are given). Returns a
+ * structured payload:
+ *
+ *   {
+ *     passed: boolean,
+ *     issues: Array<{file, line, rule, message}>,
+ *     exitCode: number,
+ *   }
+ *
+ * `vp lint --format=json` forwards to the bundled Oxlint engine while keeping
+ * the repo command surface on the `vp` facade.
+ */
+import { z } from 'zod';
+import { applyOutputTransform } from '#output-transforms/index';
+import { resolveProjectRoot } from './_shared/project-root.js';
+import { createSummaryOutputSchema, createSummaryResult } from './_shared/result.js';
+import { isRunFailure, runCommand } from './_shared/run-command.js';
+const inputSchema = z.object({
+    cwd: z.string().optional(),
+    files: z.array(z.string()).optional(),
+    fix: z.boolean().optional().default(false),
+});
+const lintIssueSchema = z.object({
+    file: z.string(),
+    line: z.number(),
+    rule: z.string(),
+    message: z.string(),
+});
+const outputSchema = createSummaryOutputSchema({
+    counts: z.object({
+        issueCount: z.number(),
+    }),
+    details: z.object({
+        issues: z.array(lintIssueSchema),
+        parseError: z.string().optional(),
+        spawnError: z.string().optional(),
+    }),
+});
+// Hard cap so a hung lint cannot hang the MCP tool. Lints over 5 minutes are
+// pathological; surface them as a timeout signal instead of a silent stall.
+const LINT_COMMAND_TIMEOUT_MS = 5 * 60 * 1_000;
+/**
+ * Parse oxlint's `--format=json` output into our flattened issue list.
+ *
+ * oxlint emits an ESLint-compatible array: `[{filePath, messages: [...]}, ...]`.
+ * On JSON parse failure or unexpected shape we annotate the outcome with a
+ * concrete `parseError` instead of silently returning an empty list — the
+ * caller can then distinguish "lint passed cleanly" from "we couldn't read
+ * lint's output."
+ */
+function parseOxlintIssues(stdout) {
+    const trimmed = stdout.trim();
+    if (!trimmed)
+        return { issues: [] };
+    const jsonText = extractJsonObjectOrArray(trimmed) ?? trimmed;
+    let parsed;
+    try {
+        parsed = JSON.parse(jsonText);
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        return { issues: [], parseError: `oxlint JSON.parse failed: ${reason}` };
+    }
+    const reports = Array.isArray(parsed)
+        ? parsed
+        : normalizeWrappedOxlintReports(parsed);
+    if (!Array.isArray(reports))
+        return { issues: [], parseError: 'oxlint output was not a JSON array' };
+    const issues = [];
+    for (const fileReport of reports) {
+        const file = fileReport?.filePath ?? '';
+        const messages = fileReport?.messages;
+        if (!Array.isArray(messages))
+            continue;
+        for (const m of messages) {
+            issues.push({
+                file,
+                line: typeof m.line === 'number' ? m.line : 0,
+                rule: m.ruleId ?? '',
+                message: m.message ?? '',
+            });
+        }
+    }
+    return { issues };
+}
+function normalizeWrappedOxlintReports(parsed) {
+    if (!parsed || typeof parsed !== 'object')
+        return undefined;
+    const wrapper = parsed;
+    const reports = wrapper.diagnostics ?? wrapper.results;
+    if (!Array.isArray(reports))
+        return undefined;
+    if (reports.every((report) => report && typeof report === 'object' && 'message' in report)) {
+        return reports.map((report) => {
+            const message = report;
+            return {
+                filePath: message.filename ?? '',
+                messages: [
+                    {
+                        line: message.line ?? message.labels?.[0]?.span?.line ?? 0,
+                        ruleId: message.ruleId ?? 'parse',
+                        message: message.message ?? '',
+                    },
+                ],
+            };
+        });
+    }
+    return reports;
+}
+function extractJsonObjectOrArray(raw) {
+    const start = raw.search(/[[{]/u);
+    if (start < 0)
+        return undefined;
+    const open = raw[start];
+    const close = open === '{' ? '}' : ']';
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    for (let index = start; index < raw.length; index += 1) {
+        const char = raw[index];
+        if (inString) {
+            if (escaped)
+                escaped = false;
+            else if (char === '\\')
+                escaped = true;
+            else if (char === '"')
+                inString = false;
+            continue;
+        }
+        if (char === '"')
+            inString = true;
+        if (char === open)
+            depth += 1;
+        if (char === close)
+            depth -= 1;
+        if (depth === 0)
+            return raw.slice(start, index + 1);
+    }
+    return undefined;
+}
+function summarizeLintResult(options) {
+    if (options.timedOut)
+        return 'lint timed out via vp lint';
+    if (options.aborted)
+        return 'lint aborted via vp lint';
+    if (options.parseError)
+        return 'lint failed: could not parse vp lint output';
+    if (options.passed)
+        return 'lint passed via vp lint';
+    if (options.issueCount > 0) {
+        return `lint failed with ${options.issueCount} issue${options.issueCount === 1 ? '' : 's'} via vp lint`;
+    }
+    return `lint failed via vp lint (exit ${options.exitCode})`;
+}
+const tool = {
+    name: 'wp_lint',
+    description: 'Run lint via the `vp lint` facade. Returns `{passed, issues: [{file, line, rule, message}]}`.',
+    inputSchema,
+    outputSchema,
+    annotations: {
+        title: 'Lint',
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+    handler: async (raw, extra) => {
+        const input = inputSchema.parse(raw ?? {});
+        const cwd = resolveProjectRoot(input.cwd ? { cwd: input.cwd } : {});
+        const runOptions = {
+            timeoutMs: LINT_COMMAND_TIMEOUT_MS,
+            signal: extra?.signal,
+            cwd,
+        };
+        const lintArgs = ['lint', '--format=json'];
+        if (input.fix)
+            lintArgs.push('--fix');
+        if (input.files && input.files.length > 0) {
+            lintArgs.push(...input.files);
+        }
+        else {
+            lintArgs.push('.');
+        }
+        const vpOutcome = await runCommand('vp', lintArgs, runOptions);
+        if (!isRunFailure(vpOutcome)) {
+            const { issues, parseError } = parseOxlintIssues(vpOutcome.stdout);
+            const { transform: _transform, ...compact } = applyOutputTransform(vpOutcome.stdout || vpOutcome.stderr, {
+                toolName: 'wp_lint-vp',
+            });
+            const payload = {
+                passed: vpOutcome.exitCode === 0,
+                summary: summarizeLintResult({
+                    passed: vpOutcome.exitCode === 0,
+                    issueCount: issues.length,
+                    exitCode: vpOutcome.exitCode,
+                    parseError,
+                    timedOut: vpOutcome.timedOut,
+                    aborted: vpOutcome.aborted,
+                }),
+                exitCode: vpOutcome.exitCode,
+                counts: { issueCount: issues.length },
+                details: {
+                    issues,
+                    parseError,
+                },
+                ...compact,
+                timedOut: vpOutcome.timedOut || undefined,
+                aborted: vpOutcome.aborted || undefined,
+            };
+            return createSummaryResult(payload);
+        }
+        const payload = {
+            passed: false,
+            summary: 'lint could not start: vp lint spawn failed',
+            exitCode: 1,
+            counts: { issueCount: 0 },
+            details: {
+                issues: [],
+                spawnError: `vp lint spawn failed: ${vpOutcome.error.code ?? 'unknown'} ${vpOutcome.error.message}`,
+            },
+        };
+        return createSummaryResult(payload, { isError: true });
+    },
+};
+export default tool;
+//# sourceMappingURL=lint.js.map

package/dist/esm/mcp/tools/qa.d.ts

@@ -0,0 +1,39 @@
+/**
+ * `wp_qa` MCP tool.
+ *
+ * Composite tool that fans out to the three sibling check tools in parallel
+ * via `Promise.all` and returns an aggregated structured payload:
+ *
+ *   {
+ *     passed: lint.passed && typecheck.passed && test.passed,
+ *     lint: <wp_lint payload>,
+ *     typecheck: <wp_typecheck payload>,
+ *     test: <wp_test payload>,
+ *   }
+ *
+ * Implementation calls the sibling tools' `handler` exports through their
+ * default descriptors — no public re-exports needed. Parallelism is the whole
+ * point: a sequential composite would be strictly worse than the user simply
+ * running each tool back-to-back, since the sub-tools each spawn long-lived
+ * external processes (`oxlint`, `tsc`, the test runner). Running them
+ * concurrently is the only thing this composite buys you.
+ */
+import { z } from 'zod';
+import type { ToolDescriptor } from '#mcp/auto-discover';
+declare const inputSchema: z.ZodObject<{
+    cwd: z.ZodOptional<z.ZodString>;
+    files: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    packages: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+    workspaceSharding: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        minFilesToShard: z.ZodOptional<z.ZodNumber>;
+        targetFilesPerShard: z.ZodOptional<z.ZodNumber>;
+        maxShards: z.ZodOptional<z.ZodNumber>;
+        totalBudgetMs: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+}, z.core.$strip>;
+export type AkQaInput = z.infer<typeof inputSchema>;
+declare const tool: ToolDescriptor;
+export default tool;
+//# sourceMappingURL=qa.d.ts.map

package/dist/esm/mcp/tools/qa.js

@@ -0,0 +1,218 @@
+/**
+ * `wp_qa` MCP tool.
+ *
+ * Composite tool that fans out to the three sibling check tools in parallel
+ * via `Promise.all` and returns an aggregated structured payload:
+ *
+ *   {
+ *     passed: lint.passed && typecheck.passed && test.passed,
+ *     lint: <wp_lint payload>,
+ *     typecheck: <wp_typecheck payload>,
+ *     test: <wp_test payload>,
+ *   }
+ *
+ * Implementation calls the sibling tools' `handler` exports through their
+ * default descriptors — no public re-exports needed. Parallelism is the whole
+ * point: a sequential composite would be strictly worse than the user simply
+ * running each tool back-to-back, since the sub-tools each spawn long-lived
+ * external processes (`oxlint`, `tsc`, the test runner). Running them
+ * concurrently is the only thing this composite buys you.
+ */
+import { z } from 'zod';
+import { createSummaryOutputSchema, createSummaryResult, failureSchema } from './_shared/result.js';
+import { MCP_SAFE_TEST_BUDGET_MS, refineTestBudgetContract, workspaceShardingInputSchema, } from './_shared/test-budget-contract.js';
+import { detectUiChanges } from './_shared/ui-detection.js';
+import lintTool from './lint.js';
+import testTool from './test.js';
+import typecheckTool from './typecheck.js';
+const inputSchema = z
+    .object({
+    // Forwarded to all three sub-tools so cross-repo invocation works (e.g.
+    // run webpresso's QA from a session launched in monorepo).
+    cwd: z.string().optional(),
+    // Forwarded to `wp_lint.files` and `wp_test.files` so a scoped QA on
+    // changed files is possible. `wp_typecheck` ignores files (it operates on
+    // tsconfig projects).
+    files: z.array(z.string()).optional(),
+    // Forwarded to `wp_typecheck.packages` and `wp_test.packages` to scope
+    // the run to specific workspace packages.
+    packages: z.array(z.string()).optional(),
+    // Forwarded only to `wp_test` so QA callers can use the same safe test
+    // budget contract without widening lint/typecheck inputs.
+    timeoutMs: z.number().int().positive().max(MCP_SAFE_TEST_BUDGET_MS).optional(),
+    workspaceSharding: workspaceShardingInputSchema.optional(),
+})
+    .superRefine(refineTestBudgetContract);
+const qaLeafSchema = z
+    .object({
+    passed: z.boolean(),
+    summary: z.string(),
+    exitCode: z.number().optional(),
+    failures: z.array(failureSchema),
+    tier: z.union([z.literal(1), z.literal(2), z.literal(3)]).optional(),
+    bytes: z.number().optional(),
+    tokensSaved: z.number().optional(),
+    timedOut: z.boolean().optional(),
+    aborted: z.boolean().optional(),
+    unwrapError: z.string().optional(),
+})
+    .strict();
+const outputSchema = createSummaryOutputSchema({
+    details: z.object({
+        lint: qaLeafSchema,
+        typecheck: qaLeafSchema,
+        test: qaLeafSchema,
+    }),
+});
+const QA_FAILURE_LIMIT = 10;
+/**
+ * Sub-tool handlers return MCP `{content: [{type: 'text', text: <json>}]}`.
+ * To aggregate into a single structured payload we re-parse the JSON.
+ *
+ * On any unwrap failure (non-text block, non-object payload, JSON parse error)
+ * the step is marked `passed: false` AND annotated with a concrete
+ * `unwrapError` string so the caller can distinguish "lint genuinely failed
+ * with empty issues" from "we couldn't read lint's response" — the previous
+ * silent collapse hid composition bugs as fake lint failures.
+ */
+function unwrap(result) {
+    const structured = result
+        .structuredContent;
+    if (structured && typeof structured === 'object') {
+        return structured;
+    }
+    const block = result.content[0];
+    if (!block || block.type !== 'text' || typeof block.text !== 'string') {
+        return {
+            passed: false,
+            unwrapError: 'sub-tool did not return a text content block',
+            raw: result,
+        };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(block.text);
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        return { passed: false, unwrapError: `JSON.parse failed: ${reason}`, raw: block.text };
+    }
+    if (!parsed || typeof parsed !== 'object') {
+        return { passed: false, unwrapError: 'sub-tool payload was not an object', raw: block.text };
+    }
+    return parsed;
+}
+function normalizeFailureEntry(entry, fallbackMessage) {
+    if (typeof entry === 'string')
+        return { message: entry };
+    if (entry && typeof entry === 'object') {
+        const record = entry;
+        const message = typeof record.message === 'string'
+            ? record.message
+            : typeof record.summary === 'string'
+                ? record.summary
+                : fallbackMessage;
+        const normalized = { message };
+        if (typeof record.file === 'string')
+            normalized.file = record.file;
+        if (typeof record.line === 'number')
+            normalized.line = record.line;
+        if (typeof record.code === 'string')
+            normalized.code = record.code;
+        return normalized;
+    }
+    return { message: fallbackMessage };
+}
+function toCompactLeaf(result) {
+    const details = result.details;
+    const failures = Array.isArray(result.failures)
+        ? result.failures
+        : details && typeof details === 'object'
+            ? Array.isArray(details.failures)
+                ? (details.failures ?? [])
+                : Array.isArray(details.issues)
+                    ? (details.issues ?? [])
+                    : Array.isArray(details.errors)
+                        ? (details.errors ?? [])
+                        : []
+            : [];
+    const fallbackMessage = typeof result.summary === 'string' ? result.summary : 'failed';
+    const normalizedFailures = failures.length > 0
+        ? failures
+            .slice(0, QA_FAILURE_LIMIT)
+            .map((failure) => normalizeFailureEntry(failure, fallbackMessage))
+        : result.passed === false
+            ? [normalizeFailureEntry(undefined, fallbackMessage)]
+            : [];
+    return {
+        passed: result.passed === true,
+        summary: typeof result.summary === 'string' ? result.summary : '',
+        ...(typeof result.exitCode === 'number' ? { exitCode: result.exitCode } : {}),
+        failures: normalizedFailures,
+        ...(typeof result.tier === 'number' ? { tier: result.tier } : {}),
+        ...(typeof result.bytes === 'number' ? { bytes: result.bytes } : {}),
+        ...(typeof result.tokensSaved === 'number' ? { tokensSaved: result.tokensSaved } : {}),
+        ...(typeof result.timedOut === 'boolean' ? { timedOut: result.timedOut } : {}),
+        ...(typeof result.aborted === 'boolean' ? { aborted: result.aborted } : {}),
+        ...(typeof result.unwrapError === 'string' ? { unwrapError: result.unwrapError } : {}),
+    };
+}
+const UI_QA_HINT = 'Static QA passed. For visual/UX QA, run /qa (gstack).';
+function summarizeQa(lint, typecheck, test, hasUiChanges = false) {
+    const failed = [];
+    if (lint.passed !== true)
+        failed.push('lint');
+    if (typecheck.passed !== true)
+        failed.push('typecheck');
+    if (test.passed !== true)
+        failed.push('test');
+    if (failed.length > 0)
+        return `qa failed: ${failed.join(', ')}`;
+    return hasUiChanges ? `qa passed. ${UI_QA_HINT}` : 'qa passed';
+}
+const tool = {
+    name: 'wp_qa',
+    description: 'Run `wp_lint`, `wp_typecheck`, and `wp_test` in parallel via `Promise.all`. Returns `{passed, lint, typecheck, test}` where the top-level `passed` is the AND of the three sub-results.',
+    inputSchema,
+    outputSchema,
+    annotations: {
+        title: 'QA (lint + typecheck + test)',
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+    handler: async (raw, extra) => {
+        const input = inputSchema.parse(raw ?? {});
+        const [lintResult, typecheckResult, testResult] = await Promise.all([
+            lintTool.handler({ cwd: input.cwd, files: input.files }, extra),
+            typecheckTool.handler({ cwd: input.cwd, packages: input.packages }, extra),
+            testTool.handler({
+                cwd: input.cwd,
+                files: input.files,
+                packages: input.packages,
+                timeoutMs: input.timeoutMs,
+                workspaceSharding: input.workspaceSharding,
+            }, extra),
+        ]);
+        const lint = toCompactLeaf(unwrap(lintResult));
+        const typecheck = toCompactLeaf(unwrap(typecheckResult));
+        const test = toCompactLeaf(unwrap(testResult));
+        const passed = lint.passed === true && typecheck.passed === true && test.passed === true;
+        // `isError: true` only fires when we couldn't even READ a sub-tool's
+        // result (composition bug). A sub-tool legitimately reporting
+        // `passed: false` is normal output the agent can act on.
+        const composeError = typeof lint.unwrapError === 'string' ||
+            typeof typecheck.unwrapError === 'string' ||
+            typeof test.unwrapError === 'string';
+        const hasUiChanges = passed && input.cwd ? detectUiChanges(input.cwd) : false;
+        const payload = {
+            passed,
+            summary: summarizeQa(lint, typecheck, test, hasUiChanges),
+            details: { lint, typecheck, test },
+        };
+        return createSummaryResult(payload, composeError ? { isError: true } : {});
+    },
+};
+export default tool;
+//# sourceMappingURL=qa.js.map

package/dist/esm/mcp/tools/test.d.ts

@@ -0,0 +1,25 @@
+/**
+ * `wp_test` MCP tool.
+ *
+ * Routes test execution through the `vp` package-manager facade and returns a
+ * summary-first payload with bounded `rawOutput`.
+ */
+import { z } from 'zod';
+import type { ToolDescriptor } from '#mcp/auto-discover';
+declare const inputSchema: z.ZodObject<{
+    cwd: z.ZodOptional<z.ZodString>;
+    packages: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    files: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+    workspaceSharding: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        minFilesToShard: z.ZodOptional<z.ZodNumber>;
+        targetFilesPerShard: z.ZodOptional<z.ZodNumber>;
+        maxShards: z.ZodOptional<z.ZodNumber>;
+        totalBudgetMs: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type AkTestInput = z.infer<typeof inputSchema>;
+declare const tool: ToolDescriptor;
+export default tool;
+//# sourceMappingURL=test.d.ts.map