@webpresso/agent-kit 0.21.0

package/dist/esm/typecheck/index.js

@@ -0,0 +1,135 @@
+/**
+ * Stable subpath export: `webpresso/typecheck`.
+ *
+ * Exposes a framework-friendly `runTypecheck` runner that wraps
+ * `tsc --noEmit` either at cwd (no `packages` given) or once per resolved
+ * package path (each becomes `tsc --noEmit -p <pkg>/tsconfig.json`). Mirrors
+ * the semantics of the `wp_typecheck` MCP tool but returns a typed result
+ * directly so external scaffolders can consume it without the MCP transport.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { globSync } from 'glob';
+import { isRunFailure, runCommand } from '#mcp/tools/_shared/run-command';
+import { resolveProjectRoot } from '#mcp/tools/_shared/project-root';
+const DEFAULT_TYPECHECK_TIMEOUT_MS = 10 * 60 * 1_000;
+// Matches both standard tsc formats:
+//   src/foo.ts(5,12): error TS2304: Cannot find name 'bar'.
+//   src/foo.ts:5:12 - error TS2304: Cannot find name 'bar'.
+const ERROR_LINE = /^(.+?)(?:\((\d+),\d+\)|:(\d+):\d+)(?::\s*|\s+-\s+)error TS(\d+):\s*(.*)$/;
+function readWorkspaceGlobs(cwd) {
+    const file = join(cwd, 'pnpm-workspace.yaml');
+    if (!existsSync(file))
+        return null;
+    const text = readFileSync(file, 'utf8');
+    const globs = [];
+    for (const line of text.split('\n')) {
+        const m = /^\s*-\s*['"]?([^'"\s#]+)['"]?\s*$/.exec(line);
+        if (m && m[1])
+            globs.push(m[1]);
+    }
+    return globs;
+}
+function resolveTypecheckTarget(cwd, target, workspaceGlobs) {
+    const directTsconfig = join(cwd, target, 'tsconfig.json');
+    if (existsSync(directTsconfig))
+        return target;
+    if (!workspaceGlobs || !target.startsWith('@'))
+        return target;
+    for (const workspaceGlob of workspaceGlobs) {
+        const packageJsonPattern = join(workspaceGlob, 'package.json').replaceAll('\\', '/');
+        const packageJsonPaths = globSync(packageJsonPattern, {
+            cwd,
+            nodir: true,
+            absolute: false,
+        });
+        for (const packageJsonPath of packageJsonPaths) {
+            try {
+                const packageJson = JSON.parse(readFileSync(join(cwd, packageJsonPath), 'utf8'));
+                if (packageJson.name === target) {
+                    return packageJsonPath.slice(0, -'/package.json'.length);
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+    }
+    return target;
+}
+/**
+ * Parse `tsc --noEmit` stdout into structured `{file, line, code, message}`
+ * entries. Lines that don't match the diagnostic format are ignored so
+ * preamble/`tsc` chatter never ends up in the error list.
+ */
+export function parseTscOutput(raw) {
+    const errors = [];
+    for (const rawLine of raw.split('\n')) {
+        const line = rawLine.trim();
+        if (!line)
+            continue;
+        const match = ERROR_LINE.exec(line);
+        if (!match)
+            continue;
+        const [, file, paren, colon, code, message] = match;
+        const lineNumber = paren ?? colon ?? '0';
+        errors.push({
+            file: file ?? '',
+            line: Number(lineNumber),
+            code: code ?? '',
+            message: (message ?? '').trim(),
+        });
+    }
+    return errors;
+}
+/**
+ * Run typecheck and return structured diagnostics. When `packages` is
+ * provided, runs `tsc --noEmit -p <pkg>/tsconfig.json` once per entry
+ * sequentially and aggregates output; otherwise a single root-level
+ * `tsc --noEmit`. Throws on spawn failures (e.g. tsc missing) — those
+ * indicate a misconfigured environment, not a typecheck verdict.
+ */
+export async function runTypecheck(options = {}) {
+    const cwd = resolveProjectRoot(options.cwd ? { explicitCwd: options.cwd } : {});
+    const runOptions = {
+        timeoutMs: options.timeoutMs ?? DEFAULT_TYPECHECK_TIMEOUT_MS,
+        signal: options.signal,
+        cwd,
+    };
+    const targets = options.packages && options.packages.length > 0 ? options.packages : null;
+    const workspaceGlobs = targets ? readWorkspaceGlobs(cwd) : null;
+    const runs = [];
+    if (targets) {
+        for (const pkg of targets) {
+            const resolvedTarget = resolveTypecheckTarget(cwd, pkg, workspaceGlobs);
+            const tsconfig = join(resolvedTarget, 'tsconfig.json');
+            const outcome = await runCommand('tsc', ['--noEmit', '-p', tsconfig], runOptions);
+            if (isRunFailure(outcome)) {
+                throw outcome.error;
+            }
+            runs.push(outcome);
+        }
+    }
+    else {
+        const outcome = await runCommand('tsc', ['--noEmit'], runOptions);
+        if (isRunFailure(outcome)) {
+            throw outcome.error;
+        }
+        runs.push(outcome);
+    }
+    const combinedStdout = runs.map((r) => r.stdout).join('');
+    const combinedStderr = runs.map((r) => r.stderr).join('');
+    const errors = parseTscOutput(combinedStdout);
+    const passed = runs.every((r) => r.exitCode === 0);
+    const timedOut = runs.some((r) => r.timedOut);
+    const aborted = runs.some((r) => r.aborted);
+    return {
+        passed,
+        errorCount: errors.length,
+        errors,
+        output: [combinedStdout, combinedStderr].filter(Boolean).join(''),
+        timedOut: timedOut || undefined,
+        aborted: aborted || undefined,
+    };
+}
+//# sourceMappingURL=index.js.map

package/dist/esm/vite/bundle-budget.d.ts

@@ -0,0 +1,37 @@
+export interface BundleBudgetAsset {
+    path: string;
+    bytes: number;
+}
+export interface BundleBudgetLimits {
+    maxJsAssetBytes?: number;
+    maxHtmlEagerJsAssetBytes?: number;
+    maxHtmlEagerJsTotalBytes?: number;
+}
+export interface AnalyzeBundleBudgetOptions extends BundleBudgetLimits {
+    assets: readonly BundleBudgetAsset[];
+    html?: string;
+    ignore?: readonly (RegExp | string)[];
+}
+export type BundleBudgetViolationKind = 'js-asset-too-large' | 'html-eager-js-asset-too-large' | 'html-eager-js-total-too-large' | 'html-referenced-asset-missing';
+export interface BundleBudgetViolation {
+    kind: BundleBudgetViolationKind;
+    path?: string;
+    bytes: number;
+    limit?: number;
+    message: string;
+}
+export interface BundleBudgetResult {
+    ok: boolean;
+    assets: readonly BundleBudgetAsset[];
+    jsAssets: readonly BundleBudgetAsset[];
+    htmlEagerJsAssets: readonly BundleBudgetAsset[];
+    htmlEagerJsTotalBytes: number;
+    htmlEagerJsReferences: readonly string[];
+    violations: readonly BundleBudgetViolation[];
+    limits: BundleBudgetLimits;
+}
+export declare function analyzeBundleBudget(options: AnalyzeBundleBudgetOptions): BundleBudgetResult;
+export declare function extractHtmlEagerJsReferences(html: string): string[];
+export declare function formatBundleBudgetReport(result: BundleBudgetResult): string;
+export declare function formatBytes(bytes: number): string;
+//# sourceMappingURL=bundle-budget.d.ts.map

package/dist/esm/vite/bundle-budget.js

@@ -0,0 +1,151 @@
+const JS_EXTENSION_PATTERN = /\.js$/i;
+const SCRIPT_SRC_PATTERN = /<script\b[^>]*\bsrc\s*=\s*(["'])(.*?)\1[^>]*>/gi;
+const MODULEPRELOAD_HREF_PATTERN = /<link\b(?=[^>]*\brel\s*=\s*(["'])modulepreload\1)[^>]*\bhref\s*=\s*(["'])(.*?)\2[^>]*>/gi;
+export function analyzeBundleBudget(options) {
+    const limits = {
+        maxJsAssetBytes: options.maxJsAssetBytes,
+        maxHtmlEagerJsAssetBytes: options.maxHtmlEagerJsAssetBytes,
+        maxHtmlEagerJsTotalBytes: options.maxHtmlEagerJsTotalBytes,
+    };
+    const assets = normalizeAssets(options.assets).filter((asset) => !isIgnored(asset.path, options.ignore));
+    const assetByPath = new Map(assets.map((asset) => [asset.path, asset]));
+    const jsAssets = assets.filter((asset) => isJavaScriptPath(asset.path));
+    const htmlEagerJsReferences = options.html ? extractHtmlEagerJsReferences(options.html) : [];
+    const htmlEagerJsAssets = [];
+    const violations = [];
+    for (const asset of jsAssets) {
+        if (limits.maxJsAssetBytes !== undefined && asset.bytes > limits.maxJsAssetBytes) {
+            violations.push({
+                kind: 'js-asset-too-large',
+                path: asset.path,
+                bytes: asset.bytes,
+                limit: limits.maxJsAssetBytes,
+                message: `${asset.path} is ${asset.bytes} bytes, above JS asset budget ${limits.maxJsAssetBytes} bytes.`,
+            });
+        }
+    }
+    for (const reference of htmlEagerJsReferences) {
+        if (isIgnored(reference, options.ignore))
+            continue;
+        const asset = assetByPath.get(reference);
+        if (!asset) {
+            violations.push({
+                kind: 'html-referenced-asset-missing',
+                path: reference,
+                bytes: 0,
+                message: `HTML references ${reference}, but the asset was not found in the dist directory.`,
+            });
+            continue;
+        }
+        htmlEagerJsAssets.push(asset);
+        if (limits.maxHtmlEagerJsAssetBytes !== undefined &&
+            asset.bytes > limits.maxHtmlEagerJsAssetBytes) {
+            violations.push({
+                kind: 'html-eager-js-asset-too-large',
+                path: asset.path,
+                bytes: asset.bytes,
+                limit: limits.maxHtmlEagerJsAssetBytes,
+                message: `${asset.path} is ${asset.bytes} bytes, above HTML-eager JS asset budget ${limits.maxHtmlEagerJsAssetBytes} bytes.`,
+            });
+        }
+    }
+    const htmlEagerJsTotalBytes = htmlEagerJsAssets.reduce((total, asset) => total + asset.bytes, 0);
+    if (limits.maxHtmlEagerJsTotalBytes !== undefined &&
+        htmlEagerJsTotalBytes > limits.maxHtmlEagerJsTotalBytes) {
+        violations.push({
+            kind: 'html-eager-js-total-too-large',
+            bytes: htmlEagerJsTotalBytes,
+            limit: limits.maxHtmlEagerJsTotalBytes,
+            message: `HTML-eager JS total is ${htmlEagerJsTotalBytes} bytes, above budget ${limits.maxHtmlEagerJsTotalBytes} bytes.`,
+        });
+    }
+    return {
+        ok: violations.length === 0,
+        assets,
+        jsAssets,
+        htmlEagerJsAssets,
+        htmlEagerJsReferences,
+        htmlEagerJsTotalBytes,
+        limits,
+        violations,
+    };
+}
+export function extractHtmlEagerJsReferences(html) {
+    const references = new Set();
+    for (const match of html.matchAll(SCRIPT_SRC_PATTERN)) {
+        const src = match[2];
+        if (src)
+            addJavaScriptReference(references, src);
+    }
+    for (const match of html.matchAll(MODULEPRELOAD_HREF_PATTERN)) {
+        const href = match[3];
+        if (href)
+            addJavaScriptReference(references, href);
+    }
+    return [...references];
+}
+export function formatBundleBudgetReport(result) {
+    const lines = [];
+    lines.push(result.ok ? '✓ Bundle budget passed' : '✗ Bundle budget failed');
+    lines.push('');
+    lines.push('JS assets:');
+    for (const asset of [...result.jsAssets].toSorted(compareAssetPath)) {
+        lines.push(`  ${formatBytes(asset.bytes).padStart(10)}  ${asset.path}`);
+    }
+    if (!result.jsAssets.length)
+        lines.push('  (none)');
+    lines.push('');
+    lines.push(`HTML-eager JS total: ${formatBytes(result.htmlEagerJsTotalBytes)}`);
+    for (const asset of [...result.htmlEagerJsAssets].toSorted(compareAssetPath)) {
+        lines.push(`  ${formatBytes(asset.bytes).padStart(10)}  ${asset.path}`);
+    }
+    if (!result.htmlEagerJsAssets.length)
+        lines.push('  (none)');
+    if (result.violations.length) {
+        lines.push('');
+        lines.push('Violations:');
+        for (const violation of result.violations) {
+            lines.push(`  - ${violation.message}`);
+        }
+    }
+    return lines.join('\n');
+}
+export function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    const kib = bytes / 1024;
+    if (kib < 1024)
+        return `${kib.toFixed(1)} KiB`;
+    return `${(kib / 1024).toFixed(2)} MiB`;
+}
+function addJavaScriptReference(references, rawReference) {
+    const normalized = normalizeReferencePath(rawReference);
+    if (normalized && isJavaScriptPath(normalized))
+        references.add(normalized);
+}
+function normalizeAssets(assets) {
+    return assets.map((asset) => ({
+        path: normalizeReferencePath(asset.path),
+        bytes: asset.bytes,
+    }));
+}
+function normalizeReferencePath(rawPath) {
+    const withoutQuery = rawPath.split(/[?#]/, 1)[0] ?? '';
+    return withoutQuery.replace(/^\.?\//, '').replace(/^\//, '');
+}
+function isJavaScriptPath(assetPath) {
+    return JS_EXTENSION_PATTERN.test(assetPath);
+}
+function isIgnored(assetPath, ignore) {
+    if (!ignore?.length)
+        return false;
+    return ignore.some((pattern) => {
+        if (typeof pattern === 'string')
+            return assetPath.includes(pattern);
+        return pattern.test(assetPath);
+    });
+}
+function compareAssetPath(left, right) {
+    return left.path.localeCompare(right.path);
+}
+//# sourceMappingURL=bundle-budget.js.map

package/dist/esm/vite/chunk-load-recovery.d.ts

@@ -0,0 +1,18 @@
+export interface ChunkLoadRecoveryStorage {
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+}
+export interface ChunkLoadRecoveryEvent {
+    preventDefault?: () => void;
+}
+export interface ChunkLoadRecoveryTarget {
+    addEventListener(type: 'vite:preloadError', listener: (event: ChunkLoadRecoveryEvent) => void): void;
+}
+export interface InstallChunkLoadRecoveryOptions {
+    target?: ChunkLoadRecoveryTarget;
+    storage?: ChunkLoadRecoveryStorage;
+    reload?: () => void;
+    key?: string;
+}
+export declare function installChunkLoadRecovery(options?: InstallChunkLoadRecoveryOptions): boolean;
+//# sourceMappingURL=chunk-load-recovery.d.ts.map

package/dist/esm/vite/chunk-load-recovery.js

@@ -0,0 +1,62 @@
+const DEFAULT_RELOAD_KEY = 'vite-preload-error-reloaded';
+const installedTargets = new WeakSet();
+let memoryReloaded = false;
+export function installChunkLoadRecovery(options = {}) {
+    const target = options.target ?? getDefaultTarget();
+    if (!target)
+        return false;
+    if (installedTargets.has(target))
+        return false;
+    const storage = options.storage ?? getDefaultStorage();
+    const reload = options.reload ?? getDefaultReload();
+    const key = options.key ?? DEFAULT_RELOAD_KEY;
+    target.addEventListener('vite:preloadError', (event) => {
+        event.preventDefault?.();
+        if (hasReloaded(storage, key))
+            return;
+        markReloaded(storage, key);
+        reload();
+    });
+    installedTargets.add(target);
+    return true;
+}
+function hasReloaded(storage, key) {
+    if (!storage)
+        return memoryReloaded;
+    try {
+        return storage.getItem(key) === '1';
+    }
+    catch {
+        return memoryReloaded;
+    }
+}
+function markReloaded(storage, key) {
+    memoryReloaded = true;
+    if (!storage)
+        return;
+    try {
+        storage.setItem(key, '1');
+    }
+    catch {
+        // A private-mode or denied storage write should not prevent last-resort recovery.
+    }
+}
+function getDefaultTarget() {
+    const candidate = globalThis;
+    const target = candidate.window ?? candidate;
+    if (typeof target.addEventListener !== 'function')
+        return undefined;
+    return target;
+}
+function getDefaultStorage() {
+    const candidate = globalThis;
+    return candidate.window?.sessionStorage ?? candidate.sessionStorage;
+}
+function getDefaultReload() {
+    return () => {
+        const candidate = globalThis;
+        const reload = candidate.window?.location?.reload ?? candidate.location?.reload;
+        reload?.();
+    };
+}
+//# sourceMappingURL=chunk-load-recovery.js.map

package/dist/esm/vite/index.d.ts

@@ -0,0 +1,3 @@
+export { analyzeBundleBudget, extractHtmlEagerJsReferences, formatBundleBudgetReport, formatBytes, type AnalyzeBundleBudgetOptions, type BundleBudgetAsset, type BundleBudgetLimits, type BundleBudgetResult, type BundleBudgetViolation, type BundleBudgetViolationKind, } from './bundle-budget.js';
+export { installChunkLoadRecovery, type ChunkLoadRecoveryEvent, type ChunkLoadRecoveryStorage, type ChunkLoadRecoveryTarget, type InstallChunkLoadRecoveryOptions, } from './chunk-load-recovery.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/vite/index.js

@@ -0,0 +1,3 @@
+export { analyzeBundleBudget, extractHtmlEagerJsReferences, formatBundleBudgetReport, formatBytes, } from './bundle-budget.js';
+export { installChunkLoadRecovery, } from './chunk-load-recovery.js';
+//# sourceMappingURL=index.js.map

package/dist/esm/vite/local.d.ts

@@ -0,0 +1,16 @@
+import type { BundleBudgetLimits } from './bundle-budget.js';
+export interface AnalyzeViteDistBundleBudgetOptions extends BundleBudgetLimits {
+    distDir: string;
+    htmlEntry?: string;
+    ignore?: readonly (RegExp | string)[];
+}
+export interface BundleBudgetCliOptions extends BundleBudgetLimits {
+    distDir: string;
+    htmlEntry: string;
+    ignore: readonly string[];
+}
+export declare function analyzeViteDistBundleBudget(options: AnalyzeViteDistBundleBudgetOptions): import("./bundle-budget.js").BundleBudgetResult;
+export declare function parseBundleBudgetCliArgs(argv: readonly string[]): BundleBudgetCliOptions;
+export declare function runBundleBudgetCli(argv?: readonly string[]): Promise<number>;
+export declare function bundleBudgetCliHelp(): string;
+//# sourceMappingURL=local.d.ts.map

package/dist/esm/vite/local.js

@@ -0,0 +1,164 @@
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import path from 'node:path';
+import { analyzeBundleBudget, formatBundleBudgetReport } from './bundle-budget.js';
+export function analyzeViteDistBundleBudget(options) {
+    const distDir = path.resolve(options.distDir);
+    const htmlEntry = options.htmlEntry ?? 'index.html';
+    const htmlPath = path.join(distDir, htmlEntry);
+    if (!existsSync(distDir)) {
+        throw new Error(`Dist directory does not exist: ${distDir}`);
+    }
+    if (!existsSync(htmlPath)) {
+        throw new Error(`HTML entry does not exist: ${htmlPath}`);
+    }
+    const assets = readDistAssets(distDir);
+    const html = readFileSync(htmlPath, 'utf-8');
+    const analysisOptions = {
+        assets,
+        html,
+        ignore: options.ignore,
+        maxHtmlEagerJsAssetBytes: options.maxHtmlEagerJsAssetBytes,
+        maxHtmlEagerJsTotalBytes: options.maxHtmlEagerJsTotalBytes,
+        maxJsAssetBytes: options.maxJsAssetBytes,
+    };
+    return analyzeBundleBudget(analysisOptions);
+}
+export function parseBundleBudgetCliArgs(argv) {
+    const parsed = {
+        distDir: 'dist',
+        htmlEntry: 'index.html',
+        ignore: [],
+    };
+    for (let index = 0; index < argv.length; index++) {
+        const arg = argv[index];
+        if (arg === undefined)
+            continue;
+        const next = argv[index + 1];
+        switch (arg) {
+            case '--dist':
+            case '-d': {
+                parsed.distDir = requireValue(arg, next);
+                index++;
+                break;
+            }
+            case '--html-entry': {
+                parsed.htmlEntry = requireValue(arg, next);
+                index++;
+                break;
+            }
+            case '--max-js-asset-bytes': {
+                parsed.maxJsAssetBytes = parseByteLimit(arg, next);
+                index++;
+                break;
+            }
+            case '--max-html-eager-js-asset-bytes': {
+                parsed.maxHtmlEagerJsAssetBytes = parseByteLimit(arg, next);
+                index++;
+                break;
+            }
+            case '--max-html-eager-js-total-bytes': {
+                parsed.maxHtmlEagerJsTotalBytes = parseByteLimit(arg, next);
+                index++;
+                break;
+            }
+            case '--ignore': {
+                parsed.ignore = [...parsed.ignore, requireValue(arg, next)];
+                index++;
+                break;
+            }
+            case '--help':
+            case '-h': {
+                throw new Error(bundleBudgetCliHelp());
+            }
+            default: {
+                if (arg.startsWith('-'))
+                    throw new Error(`Unknown bundle-budget option: ${arg}`);
+                parsed.distDir = arg;
+            }
+        }
+    }
+    return parsed;
+}
+export async function runBundleBudgetCli(argv = process.argv.slice(2)) {
+    try {
+        const options = parseBundleBudgetCliArgs(argv);
+        const target = inspectBundleBudgetTarget(options);
+        if (!hasExplicitBundleBudgetDistTarget(argv) && !target.hasHtmlEntry) {
+            console.log('bundle-budget skipped: no default dist/index.html found. Pass --dist <dir> to audit a built Vite app.');
+            return 0;
+        }
+        const result = analyzeViteDistBundleBudget(options);
+        console.log(formatBundleBudgetReport(result));
+        return result.ok ? 0 : 1;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(message);
+        return message === bundleBudgetCliHelp() ? 0 : 1;
+    }
+}
+export function bundleBudgetCliHelp() {
+    return [
+        'Usage: wp audit bundle-budget [dist] [options]',
+        '',
+        'Options:',
+        '  -d, --dist <dir>                                  Built Vite dist directory (default: dist)',
+        '  --html-entry <file>                               HTML entry relative to dist (default: index.html)',
+        '  --max-js-asset-bytes <bytes>                      Max size for any generated JS asset',
+        '  --max-html-eager-js-asset-bytes <bytes>           Max size for any JS asset referenced by HTML',
+        '  --max-html-eager-js-total-bytes <bytes>           Max total size for JS assets referenced by HTML',
+        '  --ignore <substring>                              Ignore matching asset path; repeatable',
+    ].join('\n');
+}
+function inspectBundleBudgetTarget(options) {
+    const distDir = path.resolve(options.distDir);
+    const htmlPath = path.join(distDir, options.htmlEntry);
+    return {
+        distDir,
+        htmlPath,
+        hasDistDir: existsSync(distDir),
+        hasHtmlEntry: existsSync(htmlPath),
+    };
+}
+function hasExplicitBundleBudgetDistTarget(argv) {
+    for (let index = 0; index < argv.length; index++) {
+        const arg = argv[index];
+        if (arg === '--dist' || arg === '-d')
+            return true;
+        if (arg && !arg.startsWith('-'))
+            return true;
+    }
+    return false;
+}
+function readDistAssets(distDir) {
+    const assets = [];
+    function visit(directory) {
+        for (const entry of readdirSync(directory, { withFileTypes: true })) {
+            const absolutePath = path.join(directory, entry.name);
+            if (entry.isDirectory()) {
+                visit(absolutePath);
+                continue;
+            }
+            if (!entry.isFile())
+                continue;
+            const relativePath = path.relative(distDir, absolutePath).split(path.sep).join('/');
+            assets.push({ path: relativePath, bytes: statSync(absolutePath).size });
+        }
+    }
+    visit(distDir);
+    return assets;
+}
+function requireValue(option, value) {
+    if (!value || value.startsWith('-'))
+        throw new Error(`Missing value for ${option}`);
+    return value;
+}
+function parseByteLimit(option, value) {
+    const rawValue = requireValue(option, value);
+    const bytes = Number(rawValue);
+    if (!Number.isInteger(bytes) || bytes < 0) {
+        throw new Error(`${option} must be a non-negative integer number of bytes, got ${rawValue}`);
+    }
+    return bytes;
+}
+//# sourceMappingURL=local.js.map

package/just/dev-kit.just

@@ -0,0 +1,24 @@
+# Consumer drop-in for the agent-kit development surface.
+#
+# Import from a consumer justfile with:
+#   import 'node_modules/@webpresso/agent-kit/just/dev-kit.just'
+
+[doc('Start a manifest-backed development target')]
+[group('agent-kit')]
+dev *targets:
+    @wp dev {{ targets }}
+
+[doc('Validate the dev manifest and print the resolved services')]
+[group('agent-kit')]
+dev-doctor *targets:
+    @wp dev {{ targets }} --doctor
+
+[doc('Clean supervisor-owned state for a manifest-backed development target')]
+[group('agent-kit')]
+dev-clean *targets:
+    @wp dev {{ targets }} --clean
+
+[doc('Restart a manifest-backed development target')]
+[group('agent-kit')]
+dev-restart *targets:
+    @wp dev {{ targets }} --restart

package/just/e2e-kit.just

@@ -0,0 +1,13 @@
+# Portable E2E recipes for repositories that consume @webpresso/agent-kit.
+#
+# Hosts are still responsible for starting their own services before invoking
+# these commands.
+
+set positional-arguments
+
+wp_bin := env_var_or_default('WP_BIN', 'wp')
+
+[group('test')]
+[doc('Run E2E tests through wp e2e. Forward suite/file/config flags unchanged.')]
+wp-e2e *args:
+    @{{wp_bin}} e2e {{args}}

package/just/test-kit.just

@@ -0,0 +1,10 @@
+# Portable test recipes for repositories that consume @webpresso/agent-kit.
+
+set positional-arguments
+
+wp_bin := env_var_or_default('WP_BIN', 'wp')
+
+[group('test')]
+[doc('Run tests through wp test. Forward package/file flags and passthrough args unchanged.')]
+wp-test *args:
+    @{{wp_bin}} test {{args}}