@webpresso/agent-kit 0.21.5 → 0.24.0

package/dist/esm/mutation/affected.js

@@ -0,0 +1,36 @@
+import { execSync } from 'node:child_process';
+/**
+ * Run Stryker only on packages changed vs. the base branch.
+ * Returns 0 on success, 1 if any package fails its break threshold.
+ *
+ * Reads GITHUB_BASE_REF (set by GitHub Actions on pull_request events) to
+ * determine the base branch; falls back to "main".
+ */
+export function runAffectedMutation() {
+    const base = process.env.GITHUB_BASE_REF ?? 'main';
+    const changed = execSync(`git diff --name-only origin/${base}...HEAD`)
+        .toString()
+        .trim()
+        .split('\n')
+        .filter(Boolean);
+    const affectedPkgs = new Set();
+    for (const file of changed) {
+        const match = file.match(/^(apps\/[^/]+|packages\/[^/]+)\//);
+        if (match)
+            affectedPkgs.add(match[1]);
+    }
+    if (affectedPkgs.size === 0) {
+        console.log('No affected packages — skipping mutation.');
+        return 0;
+    }
+    for (const pkg of affectedPkgs) {
+        try {
+            execSync(`pnpm --filter ./${pkg} mutation --if-present`, { stdio: 'inherit' });
+        }
+        catch {
+            return 1;
+        }
+    }
+    return 0;
+}
+//# sourceMappingURL=affected.js.map

package/dist/esm/package.json

@@ -51,6 +51,11 @@
     "#tool-runtime": "./tool-runtime/index.js",
     "#tool-runtime/*.js": "./tool-runtime/*.js",
     "#tool-runtime/*": "./tool-runtime/*.js",
+    "#wp-extension": "./wp-extension/index.js",
+    "#wp-extension/*.js": "./wp-extension/*.js",
+    "#wp-extension/*": "./wp-extension/*.js",
+    "#runtime/*.js": "./runtime/*.js",
+    "#runtime/*": "./runtime/*.js",
     "#output-transforms/*.js": "./output-transforms/*.js",
     "#output-transforms/*": "./output-transforms/*.js",
     "#lint/*.js": "./lint/*.js",

package/dist/esm/runtime/package-version.d.ts

@@ -0,0 +1,2 @@
+export declare function readOwnedPackageVersion(moduleUrl: string): string;
+//# sourceMappingURL=package-version.d.ts.map

package/dist/esm/runtime/package-version.js

@@ -0,0 +1,43 @@
+import { existsSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+const ACCEPTED_PACKAGE_PREFIXES = ['@webpresso/agent-kit', 'webpresso'];
+const MAX_UPWARD_LEVELS = 8;
+function matchesOwnedPackageName(name) {
+    return (typeof name === 'string' &&
+        ACCEPTED_PACKAGE_PREFIXES.some((prefix) => name === prefix || name.startsWith(`${prefix}-`)));
+}
+function readVersionFromDir(startDir) {
+    let dir = path.resolve(startDir);
+    for (let i = 0; i < MAX_UPWARD_LEVELS; i++) {
+        const candidate = path.join(dir, 'package.json');
+        if (existsSync(candidate)) {
+            try {
+                const parsed = JSON.parse(readFileSync(candidate, 'utf8'));
+                if (matchesOwnedPackageName(parsed.name) && typeof parsed.version === 'string') {
+                    return parsed.version;
+                }
+            }
+            catch {
+                // keep walking
+            }
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return null;
+}
+export function readOwnedPackageVersion(moduleUrl) {
+    const fromModule = readVersionFromDir(path.dirname(fileURLToPath(moduleUrl)));
+    if (fromModule)
+        return fromModule;
+    if (process.execPath) {
+        const fromExec = readVersionFromDir(path.dirname(process.execPath));
+        if (fromExec)
+            return fromExec;
+    }
+    return '0.0.0';
+}
+//# sourceMappingURL=package-version.js.map

package/dist/esm/test/command-builder.d.ts

@@ -1,4 +1,5 @@
 import type { ResolvedTestTarget } from './target-resolver.js';
+import { type ManagedRunnerOutputPolicy } from '#tool-runtime';
 export interface CommandConfig {
     command: string;
     args: string[];
@@ -6,6 +7,7 @@ export interface CommandConfig {
 }
 export type VpRunLogMode = 'interleaved' | 'labeled' | 'grouped';
 export interface TestCommandOptions {
+    cwd?: string;
     watch?: boolean;
     coverage?: boolean;
     testNamePattern?: string;
@@ -18,6 +20,7 @@ export interface TestCommandOptions {
     log?: VpRunLogMode;
     passthrough?: readonly string[];
     filterOutput?: boolean;
+    outputPolicy?: ManagedRunnerOutputPolicy;
 }
 export declare function buildTestCommand(target: ResolvedTestTarget, options?: TestCommandOptions): CommandConfig;
 export declare function buildVpTestCommand(filters: readonly string[], options?: TestCommandOptions): CommandConfig;

package/dist/esm/test/command-builder.js

@@ -1,5 +1,9 @@
 import { getManagedRunner } from '#tool-runtime';
+import { getPackageScript, isRecursiveWpScript, packageUsesVitest } from '#cli/package-scripts.js';
 export function buildTestCommand(target, options = {}) {
+    if (target.type === 'all' && shouldBypassRecursiveWpTest(options.cwd ?? process.cwd())) {
+        return buildVitestCommand([], options);
+    }
     if (target.type === 'file') {
         return buildVitestCommand(target.values, options);
     }
@@ -8,7 +12,7 @@ export function buildTestCommand(target, options = {}) {
 export function buildVpTestCommand(filters, options = {}) {
     const task = getVpTestTask(options);
     const resolvedFilters = filters.map((filter) => formatVpRunFilter(filter, task));
-    const explicitTargets = resolvedFilters.every(isExplicitVpTaskTarget);
+    const explicitTargets = resolvedFilters.length > 0 && resolvedFilters.every(isExplicitVpTaskTarget);
     const args = ['run', ...resolvedFilters];
     appendVpRunOptions(args, options);
     if (!explicitTargets) {
@@ -18,7 +22,9 @@ export function buildVpTestCommand(filters, options = {}) {
     if (passthrough.length > 0) {
         args.push('--', ...passthrough);
     }
-    const resolution = getManagedRunner('vp', { filterOutput: options.filterOutput });
+    const resolution = getManagedRunner('vp', {
+        outputPolicy: resolveOutputPolicy(options.outputPolicy, options.filterOutput),
+    });
     const env = buildVpRunEnv(options);
     const mergedArgs = [...resolution.args, ...args];
     return env
@@ -45,7 +51,9 @@ export function buildVitestCommand(files, options = {}) {
         args.push('--config', configFile);
     }
     args.push(...buildVitestPassthrough(options), ...testFiles);
-    const resolution = getManagedRunner('vitest', { filterOutput: options.filterOutput });
+    const resolution = getManagedRunner('vitest', {
+        outputPolicy: resolveOutputPolicy(options.outputPolicy, options.filterOutput),
+    });
     return { command: resolution.command, args: [...resolution.args, ...args] };
 }
 export function getVpTestTask(options) {
@@ -101,4 +109,15 @@ function buildVitestPassthrough(options) {
 function isVitestConfigFile(file) {
     return /^vitest(?:\.[\w-]+)?\.config\.(?:ts|mts|cts|js|mjs|cjs)$/u.test(file);
 }
+function resolveOutputPolicy(outputPolicy, filterOutput) {
+    if (outputPolicy)
+        return outputPolicy;
+    return filterOutput === false ? 'structured' : 'rtk-filtered';
+}
+function shouldBypassRecursiveWpTest(cwd) {
+    const testScript = getPackageScript(cwd, 'test');
+    if (!testScript || !isRecursiveWpScript(testScript, 'test'))
+        return false;
+    return packageUsesVitest(cwd);
+}
 //# sourceMappingURL=command-builder.js.map

package/dist/esm/tool-runtime/index.d.ts

@@ -1,5 +1,5 @@
-import { type ManagedRunnerResolution, type ResolveRunnerOptions } from './resolve-runner.js';
+import { type ManagedRunnerResolution, type ResolveRunnerOptions, type ManagedRunnerOutputPolicy } from './resolve-runner.js';
 export declare function getManagedRunner(tool: string, options?: ResolveRunnerOptions): ManagedRunnerResolution;
 export declare function clearManagedRunnerCache(): void;
-export type { ManagedRunnerResolution, ResolveRunnerOptions };
+export type { ManagedRunnerOutputPolicy, ManagedRunnerResolution, ResolveRunnerOptions };
 //# sourceMappingURL=index.d.ts.map

package/dist/esm/tool-runtime/index.js

@@ -1,9 +1,10 @@
 import { resolveRunner, } from './resolve-runner.js';
 const runtimeCache = new Map();
 function cacheKey(tool, options) {
+    const outputPolicy = options.outputPolicy ?? (options.filterOutput === false ? 'structured' : 'rtk-filtered');
     return JSON.stringify({
         tool,
-        filterOutput: options.filterOutput ?? true,
+        outputPolicy,
         fallbackCommand: options.fallbackCommand ?? null,
         fallbackArgs: options.fallbackArgs ?? [],
     });

package/dist/esm/tool-runtime/resolve-runner.d.ts

@@ -4,10 +4,13 @@ export interface ManagedRunnerResolution {
     readonly args: readonly string[];
     readonly source: 'managed' | 'fallback';
 }
+export type ManagedRunnerOutputPolicy = 'rtk-filtered' | 'structured';
 export interface ResolveRunnerOptions {
     readonly fallbackCommand?: string;
     readonly fallbackArgs?: readonly string[];
+    /** @deprecated Use {@link outputPolicy} for explicit output routing. */
     readonly filterOutput?: boolean;
+    readonly outputPolicy?: ManagedRunnerOutputPolicy;
 }
 export declare function resolveRunner(tool: string, options?: ResolveRunnerOptions): ManagedRunnerResolution;
 //# sourceMappingURL=resolve-runner.d.ts.map

package/dist/esm/tool-runtime/resolve-runner.js

@@ -1,10 +1,12 @@
 const MANAGED_TOOL_PREFIX = {
+    oxfmt: { command: 'vp', args: ['exec', 'oxfmt'] },
     playwright: { command: 'vp', args: ['exec', 'playwright'] },
+    tsc: { command: 'vp', args: ['exec', 'tsc'] },
     vitest: { command: 'vp', args: ['exec', 'vitest'] },
     vp: { command: 'vp', args: [] },
 };
-function withOptionalRtk(resolution, filterOutput) {
-    if (!filterOutput)
+function withOptionalRtk(resolution, outputPolicy) {
+    if (outputPolicy !== 'rtk-filtered')
         return resolution;
     return {
         ...resolution,
@@ -17,7 +19,7 @@ export function resolveRunner(tool, options = {}) {
     if (!normalized) {
         throw new Error('tool runtime resolution requires a non-empty tool name');
     }
-    const filterOutput = options.filterOutput ?? true;
+    const outputPolicy = options.outputPolicy ?? (options.filterOutput === false ? 'structured' : 'rtk-filtered');
     const managed = MANAGED_TOOL_PREFIX[normalized];
     if (managed) {
         return withOptionalRtk({
@@ -25,7 +27,7 @@ export function resolveRunner(tool, options = {}) {
             command: managed.command,
             args: [...managed.args],
             source: 'managed',
-        }, filterOutput);
+        }, outputPolicy);
     }
     if (options.fallbackCommand) {
         return withOptionalRtk({
@@ -33,7 +35,7 @@ export function resolveRunner(tool, options = {}) {
             command: options.fallbackCommand,
             args: [...(options.fallbackArgs ?? [])],
             source: 'fallback',
-        }, filterOutput);
+        }, outputPolicy);
     }
     throw new Error(`No managed runtime runner is defined for tool "${normalized}"`);
 }

package/dist/esm/typecheck/index.js

@@ -12,6 +12,7 @@ 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';
+import { getManagedRunner } from '#tool-runtime';
 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'.
@@ -99,11 +100,12 @@ export async function runTypecheck(options = {}) {
     const targets = options.packages && options.packages.length > 0 ? options.packages : null;
     const workspaceGlobs = targets ? readWorkspaceGlobs(cwd) : null;
     const runs = [];
+    const resolution = getManagedRunner('tsc', { outputPolicy: 'structured' });
     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);
+            const outcome = await runCommand(resolution.command, [...resolution.args, '--noEmit', '-p', tsconfig], runOptions);
             if (isRunFailure(outcome)) {
                 throw outcome.error;
             }
@@ -111,7 +113,7 @@ export async function runTypecheck(options = {}) {
         }
     }
     else {
-        const outcome = await runCommand('tsc', ['--noEmit'], runOptions);
+        const outcome = await runCommand(resolution.command, [...resolution.args, '--noEmit'], runOptions);
         if (isRunFailure(outcome)) {
             throw outcome.error;
         }

package/dist/esm/wp-extension/index.d.ts

@@ -0,0 +1,50 @@
+import type { CAC } from 'cac';
+export interface WpExtensionContext {
+    readonly cwd: string;
+    readonly env: NodeJS.ProcessEnv;
+}
+export interface WpExtensionCommandV1 {
+    readonly name: string;
+    readonly description: string;
+    readonly register: (cli: CAC) => void;
+}
+export interface WpExtensionAliasV1 {
+    readonly name: string;
+    readonly commandName: string;
+}
+export interface WpExtensionV1 {
+    readonly apiVersion: '1';
+    readonly name: string;
+    readonly version: string;
+    readonly hostRange: string;
+    readonly detect: (context: WpExtensionContext) => boolean | Promise<boolean>;
+    readonly commands: readonly WpExtensionCommandV1[];
+    readonly aliases?: readonly WpExtensionAliasV1[];
+}
+export interface LoadedWpExtension {
+    readonly packageName: string;
+    readonly specifier: string;
+    readonly extension?: WpExtensionV1;
+    readonly compatible: boolean;
+    readonly detected: boolean;
+    readonly warnings: readonly string[];
+}
+export interface WpExtensionAliasResolution {
+    readonly aliases: ReadonlyMap<string, WpExtensionAliasV1>;
+    readonly warnings: readonly string[];
+    readonly acceptedCommandNames: readonly string[];
+}
+export interface LoadWpExtensionsOptions {
+    readonly cwd?: string;
+    readonly env?: NodeJS.ProcessEnv;
+    readonly hostVersion: string;
+    readonly importModule?: (specifier: string) => Promise<{
+        default?: unknown;
+    }>;
+    readonly resolveFrom?: (fromFile: string, specifier: string) => string;
+    readonly readJsonFile?: (path: string) => unknown;
+}
+export declare function loadWpExtensions(options: LoadWpExtensionsOptions): Promise<readonly LoadedWpExtension[]>;
+export declare function resolveAcceptedExtensionAliases(extensions: readonly LoadedWpExtension[], baseCommands: Iterable<string>, acceptedCommandNames: Iterable<string>): WpExtensionAliasResolution;
+export declare function isWpExtensionV1(value: unknown): value is WpExtensionV1;
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/wp-extension/index.js

@@ -0,0 +1,268 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { createRequire } from 'node:module';
+import { pathToFileURL } from 'node:url';
+export async function loadWpExtensions(options) {
+    const cwd = options.cwd ?? process.cwd();
+    const env = options.env ?? process.env;
+    const readJsonFile = options.readJsonFile ?? defaultReadJsonFile;
+    const resolveFrom = options.resolveFrom ?? defaultResolveFrom;
+    const importModule = options.importModule ?? defaultImportModule;
+    const rootManifestPath = join(cwd, 'package.json');
+    const rootManifest = readJsonFile(rootManifestPath);
+    const enabled = collectEnabledExtensionPackageNames(rootManifest);
+    const loaded = [];
+    for (const warning of enabled.warnings) {
+        loaded.push({
+            packageName: rootManifest?.name ?? '<root>',
+            specifier: 'webpresso.wpExtensions',
+            compatible: false,
+            detected: false,
+            warnings: [warning],
+        });
+    }
+    for (const packageName of enabled.packageNames) {
+        const packageJsonPath = tryResolve(() => resolveFrom(rootManifestPath, `${packageName}/package.json`));
+        if (!packageJsonPath)
+            continue;
+        const dependencyManifest = readJsonFile(packageJsonPath);
+        const extensionSpecifier = dependencyManifest?.webpresso?.wpExtension;
+        if (typeof extensionSpecifier !== 'string' || extensionSpecifier.trim().length === 0)
+            continue;
+        const normalizedSpecifier = extensionSpecifier.trim();
+        const modulePath = tryResolve(() => resolveFrom(packageJsonPath, normalizedSpecifier.startsWith('.') ? normalizedSpecifier : normalizedSpecifier));
+        if (!modulePath) {
+            loaded.push({
+                packageName,
+                specifier: normalizedSpecifier,
+                compatible: false,
+                detected: false,
+                warnings: [`${packageName}: could not resolve wp extension "${normalizedSpecifier}"`],
+            });
+            continue;
+        }
+        let mod;
+        try {
+            mod = await importModule(modulePath);
+        }
+        catch (error) {
+            loaded.push({
+                packageName,
+                specifier: normalizedSpecifier,
+                compatible: false,
+                detected: false,
+                warnings: [`${packageName}: failed to load wp extension — ${formatError(error)}`],
+            });
+            continue;
+        }
+        if (!isWpExtensionV1(mod.default)) {
+            loaded.push({
+                packageName,
+                specifier: normalizedSpecifier,
+                compatible: false,
+                detected: false,
+                warnings: [
+                    `${packageName}: wp extension module must default-export a WpExtensionV1 object`,
+                ],
+            });
+            continue;
+        }
+        const extension = mod.default;
+        const compatible = satisfiesHostRange(options.hostVersion, extension.hostRange);
+        if (!compatible) {
+            loaded.push({
+                packageName,
+                specifier: normalizedSpecifier,
+                extension,
+                compatible: false,
+                detected: false,
+                warnings: [
+                    `${packageName}: wp extension requires host ${extension.hostRange} but current host is ${options.hostVersion}`,
+                ],
+            });
+            continue;
+        }
+        let detected = false;
+        try {
+            detected = await extension.detect({ cwd, env });
+        }
+        catch (error) {
+            loaded.push({
+                packageName,
+                specifier: normalizedSpecifier,
+                extension,
+                compatible: true,
+                detected: false,
+                warnings: [`${packageName}: extension detect() threw: ${formatError(error)}`],
+            });
+            continue;
+        }
+        loaded.push({
+            packageName,
+            specifier: normalizedSpecifier,
+            extension,
+            compatible: true,
+            detected,
+            warnings: [],
+        });
+    }
+    return loaded;
+}
+export function resolveAcceptedExtensionAliases(extensions, baseCommands, acceptedCommandNames) {
+    const blocked = new Set(baseCommands);
+    const knownCommands = new Set(acceptedCommandNames);
+    for (const commandName of acceptedCommandNames) {
+        blocked.add(commandName);
+    }
+    const aliases = new Map();
+    const warnings = [];
+    for (const extension of extensions) {
+        if (!extension.extension || !extension.compatible || !extension.detected)
+            continue;
+        for (const alias of extension.extension.aliases ?? []) {
+            if (!knownCommands.has(alias.commandName)) {
+                warnings.push(`${extension.packageName}: skipped alias "${alias.name}" because command "${alias.commandName}" is not registered`);
+                continue;
+            }
+            if (blocked.has(alias.name)) {
+                warnings.push(`${extension.packageName}: skipped alias "${alias.name}" because it collides with an existing wp command`);
+                continue;
+            }
+            if (aliases.has(alias.name)) {
+                warnings.push(`${extension.packageName}: skipped alias "${alias.name}" because another extension already claimed it`);
+                continue;
+            }
+            aliases.set(alias.name, alias);
+        }
+    }
+    return { aliases, warnings, acceptedCommandNames: [...acceptedCommandNames] };
+}
+export function isWpExtensionV1(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const candidate = value;
+    if (candidate.apiVersion !== '1')
+        return false;
+    if (typeof candidate.name !== 'string' || candidate.name.length === 0)
+        return false;
+    if (typeof candidate.version !== 'string' || candidate.version.length === 0)
+        return false;
+    if (typeof candidate.hostRange !== 'string' || candidate.hostRange.length === 0)
+        return false;
+    if (typeof candidate.detect !== 'function')
+        return false;
+    if (!Array.isArray(candidate.commands))
+        return false;
+    return candidate.commands.every((command) => command &&
+        typeof command === 'object' &&
+        typeof command.name === 'string' &&
+        typeof command.description === 'string' &&
+        typeof command.register === 'function');
+}
+function collectEnabledExtensionPackageNames(manifest) {
+    if (!manifest)
+        return { packageNames: [], warnings: [] };
+    const enabled = manifest.webpresso?.wpExtensions;
+    if (enabled === undefined || enabled === false)
+        return { packageNames: [], warnings: [] };
+    const dependencyNames = collectDependencyNames(manifest);
+    if (enabled === true)
+        return { packageNames: dependencyNames, warnings: [] };
+    if (!Array.isArray(enabled)) {
+        return {
+            packageNames: [],
+            warnings: ['root package webpresso.wpExtensions must be true or an array of package names'],
+        };
+    }
+    const dependencySet = new Set(dependencyNames);
+    const packageNames = [];
+    const warnings = [];
+    for (const entry of enabled) {
+        if (typeof entry !== 'string' || entry.trim().length === 0) {
+            warnings.push('root package webpresso.wpExtensions contains a non-string package name');
+            continue;
+        }
+        const packageName = entry.trim();
+        if (!dependencySet.has(packageName)) {
+            warnings.push(`root package enables wp extension "${packageName}" but it is not a direct dependency`);
+            continue;
+        }
+        packageNames.push(packageName);
+    }
+    return { packageNames: [...new Set(packageNames)], warnings };
+}
+function collectDependencyNames(manifest) {
+    const packageNames = new Set();
+    for (const section of ['dependencies', 'devDependencies', 'optionalDependencies']) {
+        const dependencies = manifest[section];
+        if (!dependencies || typeof dependencies !== 'object' || Array.isArray(dependencies))
+            continue;
+        for (const packageName of Object.keys(dependencies))
+            packageNames.add(packageName);
+    }
+    return [...packageNames];
+}
+function defaultReadJsonFile(path) {
+    if (!existsSync(path))
+        return;
+    try {
+        return JSON.parse(readFileSync(path, 'utf8'));
+    }
+    catch {
+        return;
+    }
+}
+function defaultResolveFrom(fromFile, specifier) {
+    const localRequire = createRequire(fromFile);
+    if (specifier.startsWith('.')) {
+        return localRequire.resolve(join(dirname(fromFile), specifier));
+    }
+    return localRequire.resolve(specifier);
+}
+async function defaultImportModule(specifier) {
+    return import(pathToFileURL(specifier).href);
+}
+function satisfiesHostRange(version, range) {
+    const normalizedRange = range.trim();
+    if (normalizedRange.startsWith('^')) {
+        const actual = parseVersion(version);
+        const expected = parseVersion(normalizedRange.slice(1));
+        if (!actual || !expected)
+            return false;
+        const [actualMajor, actualMinor, actualPatch] = actual;
+        const [expectedMajor, expectedMinor, expectedPatch] = expected;
+        if (expectedMajor === 0) {
+            return actualMajor === 0 && actualMinor === expectedMinor && actualPatch >= expectedPatch;
+        }
+        if (actualMajor !== expectedMajor)
+            return false;
+        if (actualMinor > expectedMinor)
+            return true;
+        if (actualMinor < expectedMinor)
+            return false;
+        return actualPatch >= expectedPatch;
+    }
+    const actual = parseVersion(version);
+    const expected = parseVersion(normalizedRange);
+    if (!actual || !expected)
+        return false;
+    return actual[0] === expected[0] && actual[1] === expected[1] && actual[2] === expected[2];
+}
+function parseVersion(value) {
+    const match = /^v?(\d+)\.(\d+)\.(\d+)/u.exec(value.trim());
+    if (!match)
+        return null;
+    return [Number(match[1]), Number(match[2]), Number(match[3])];
+}
+function tryResolve(callback) {
+    try {
+        return callback();
+    }
+    catch {
+        return;
+    }
+}
+function formatError(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+//# sourceMappingURL=index.js.map