@wix/pathgrade 0.37.0 → 1.0.0

package/dist/adapters/vitest/index.js

@@ -0,0 +1,82 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { PathgradeReporter } from './reporter.js';
+import { discoverPathgradeEvalFiles } from '../../evals/discovery.js';
+import { DEFAULT_EVAL_EXCLUDE, DEFAULT_EVAL_INCLUDE } from '../../config/pathgrade.js';
+function resolveSetupFile() {
+    // Prefer .ts (running from source via vitest) over .js (built dist)
+    const tsPath = path.resolve(import.meta.dirname, 'setup.ts');
+    if (fs.existsSync(tsPath))
+        return tsPath;
+    return path.resolve(import.meta.dirname, 'setup.js');
+}
+/**
+ * Vitest plugin for pathgrade evaluations.
+ *
+ * Configures test file patterns, timeout, auto-dispose lifecycle hooks,
+ * and the pathgrade reporter for aggregate statistics.
+ */
+export function pathgrade(opts) {
+    const timeoutSec = opts?.timeout ?? 300;
+    // Verbose live-streaming seam: the SDK (createAgent) reads
+    // `process.env.PATHGRADE_VERBOSE` to decide whether to emit. Wiring the
+    // plugin option through the env var keeps a single source of truth and
+    // preserves CLI/env precedence — we only set the env if the user hasn't
+    // already set it via their shell or the `pathgrade run --verbose` CLI.
+    if (opts?.verbose === true && process.env.PATHGRADE_VERBOSE === undefined) {
+        process.env.PATHGRADE_VERBOSE = '1';
+    }
+    return {
+        name: 'pathgrade',
+        // Surface the user's options to pre-vitest CLI commands
+        // (`pathgrade affected`, `pathgrade run --changed`) so they can
+        // read `affected.global` after loading vitest.config.ts.
+        // See `src/affected/config.ts`.
+        __pathgradeOptions: opts ?? {},
+        config() {
+            return {
+                resolve: {
+                    alias: resolveLocalAliases(),
+                },
+                test: {
+                    include: opts?.include ?? DEFAULT_EVAL_INCLUDE,
+                    exclude: opts?.exclude ?? DEFAULT_EVAL_EXCLUDE,
+                    testTimeout: (timeoutSec + 30) * 1000,
+                    setupFiles: [resolveSetupFile()],
+                    reporters: [
+                        'default',
+                        new PathgradeReporter(opts),
+                    ],
+                },
+            };
+        },
+        configResolved(resolved) {
+            const root = resolved.root ?? process.cwd();
+            const include = resolved.test?.include ?? opts?.include ?? DEFAULT_EVAL_INCLUDE;
+            const exclude = resolved.test?.exclude ?? opts?.exclude ?? DEFAULT_EVAL_EXCLUDE;
+            const discovered = discoverPathgradeEvalFiles({ cwd: root, include, exclude });
+            if (!resolved.test) {
+                resolved.test = {};
+            }
+            resolved.test.include = discovered;
+        },
+    };
+}
+/**
+ * When running from source (not installed via npm), resolve
+ * `@wix/pathgrade` imports to the local src/ directory so examples
+ * can use canonical package imports while developing locally.
+ */
+function resolveLocalAliases() {
+    const sdkSource = path.resolve(import.meta.dirname, '..', '..', 'sdk', 'index.ts');
+    if (!fs.existsSync(sdkSource))
+        return undefined;
+    const src = path.resolve(import.meta.dirname, '..', '..');
+    return {
+        '@wix/pathgrade/mcp-mock': path.join(src, 'core', 'mcp-mock.ts'),
+        '@wix/pathgrade/plugin': path.join(src, 'plugin', 'index.ts'),
+        '@wix/pathgrade/plugin/vitest': path.join(src, 'adapters', 'vitest', 'index.ts'),
+        '@wix/pathgrade/adapters/vitest': path.join(src, 'adapters', 'vitest', 'index.ts'),
+        '@wix/pathgrade': path.join(src, 'sdk', 'index.ts'),
+    };
+}

package/dist/adapters/vitest/lifecycle.d.ts

@@ -0,0 +1,24 @@
+import type { Agent, RecordedEvalResult } from '../../sdk/types.js';
+import { type VitestAfterAllFn, type VitestAfterEachFn, type VitestAroundEachFn } from '../../runners/vitest-lifecycle.js';
+declare function trackAgent(agent: Agent): void;
+declare function untrackAgent(agent: Agent): void;
+declare function releaseAgent(agent: Agent): void;
+declare function flush(task: {
+    id: string;
+    meta: Record<string, unknown>;
+}): Promise<void>;
+declare function onResult(result: RecordedEvalResult, agent: Agent): void;
+declare function flushAll(): Promise<void>;
+declare function reset(): void;
+declare function install(afterEach: VitestAfterEachFn, afterAll?: VitestAfterAllFn, aroundEach?: VitestAroundEachFn): void;
+export declare const lifecycle: {
+    trackAgent: typeof trackAgent;
+    untrackAgent: typeof untrackAgent;
+    releaseAgent: typeof releaseAgent;
+    flush: typeof flush;
+    flushAll: typeof flushAll;
+    onResult: typeof onResult;
+    reset: typeof reset;
+    install: typeof install;
+};
+export {};

package/dist/adapters/vitest/lifecycle.js

@@ -0,0 +1,41 @@
+import { createVitestLifecycleHooks, installVitestLifecycle, releaseVitestAgent, resetVitestLifecycle, trackVitestAgent, untrackVitestAgent, } from '../../runners/vitest-lifecycle.js';
+let installHandle = null;
+function trackAgent(agent) {
+    trackVitestAgent(agent, installHandle !== null);
+}
+function untrackAgent(agent) {
+    untrackVitestAgent(agent);
+}
+function releaseAgent(agent) {
+    releaseVitestAgent(agent);
+}
+async function flush(task) {
+    const results = await createVitestLifecycleHooks().flushCase(task.id);
+    if (results.length > 0) {
+        task.meta.pathgrade = results;
+    }
+}
+function onResult(result, agent) {
+    createVitestLifecycleHooks().onResult({ result, agent });
+}
+async function flushAll() {
+    await createVitestLifecycleHooks().cleanupRun();
+}
+function reset() {
+    resetVitestLifecycle(installHandle);
+    installHandle = null;
+}
+function install(afterEach, afterAll, aroundEach) {
+    installHandle?.restore();
+    installHandle = installVitestLifecycle({ afterEach, afterAll, aroundEach });
+}
+export const lifecycle = {
+    trackAgent,
+    untrackAgent,
+    releaseAgent,
+    flush,
+    flushAll,
+    onResult,
+    reset,
+    install,
+};

package/dist/adapters/vitest/reporter.d.ts

@@ -0,0 +1,12 @@
+import type { Reporter, TestModule } from 'vitest/node';
+import type { PathgradePluginOptions } from '../../sdk/types.js';
+/**
+ * Custom vitest reporter that layers pathgrade aggregate statistics
+ * on top of vitest's default output.
+ */
+export declare class PathgradeReporter implements Reporter {
+    private opts;
+    constructor(opts?: PathgradePluginOptions);
+    onTestRunEnd(testModules: ReadonlyArray<TestModule>): Promise<void>;
+    private openBrowserViewer;
+}

package/dist/adapters/vitest/reporter.js

@@ -0,0 +1,75 @@
+import * as path from 'path';
+import { execSync } from 'child_process';
+import { fmt } from '../../utils/cli.js';
+import { getPathgradeDir } from '../../reporters/results-path.js';
+import { readSidecar } from '../../affected/sidecar.js';
+import { printReportSummary } from '../../reporters/report-summary.js';
+import { createVitestAdapter } from '../../runners/vitest-adapter.js';
+import { runWithAdapter } from '../../runners/orchestrator.js';
+import { resolvePathgradeConfig } from '../../config/pathgrade.js';
+/**
+ * Custom vitest reporter that layers pathgrade aggregate statistics
+ * on top of vitest's default output.
+ */
+export class PathgradeReporter {
+    opts;
+    constructor(opts) {
+        this.opts = opts ?? {};
+    }
+    async onTestRunEnd(testModules) {
+        const cwd = process.cwd();
+        const config = await resolvePathgradeConfig({ cwd });
+        const mode = this.opts.reporter ?? config.reporter ?? 'cli';
+        const outputDir = getPathgradeDir(cwd);
+        const adapter = createVitestAdapter({ testModules });
+        const exitCode = await runWithAdapter({
+            adapter,
+            options: {
+                cwd,
+                discovery: { cwd },
+                runnerArgs: [],
+                env: process.env,
+                artifactRoot: outputDir,
+                reporterMode: mode,
+                threshold: this.opts.ci?.threshold ?? config.ci.threshold,
+                writeEmptyReport: false,
+                warn: warning => console.warn(warning),
+                log: () => console.log(`\n  ${fmt.dim('Results written to')} ${outputDir}\n`),
+                loadSelection: async () => (await readSidecar(cwd, msg => {
+                    console.warn(`[pathgrade] ${msg}`);
+                })) ?? undefined,
+                printSummary: summaries => {
+                    printReportSummary(summaries, {
+                        forceVerbose: this.opts.diagnostics === true
+                            || config.diagnostics
+                            || process.env.PATHGRADE_DIAGNOSTICS === '1',
+                        currentTimeoutMs: this.opts.timeout != null ? this.opts.timeout * 1000 : undefined,
+                    });
+                },
+                openBrowser: () => this.openBrowserViewer(),
+                onThresholdFailure: ({ overallPassRate, threshold }) => {
+                    const avg = overallPassRate;
+                    const configuredThreshold = this.opts.ci?.threshold ?? threshold;
+                    process.exitCode = 1;
+                    console.log(`\n  ${fmt.fail('CI THRESHOLD FAILED')}  avg score ${fmt.bold(avg.toFixed(3))} < threshold ${fmt.bold(String(configuredThreshold))}\n`);
+                },
+            },
+        });
+        if (exitCode !== 0 && (process.exitCode === undefined || process.exitCode === 0)) {
+            process.exitCode = exitCode;
+        }
+    }
+    openBrowserViewer() {
+        const viewerPath = path.resolve(import.meta.dirname, '..', '..', 'viewer.html');
+        try {
+            const openCmd = process.platform === 'darwin' ? 'open'
+                : process.platform === 'win32' ? 'start'
+                    : 'xdg-open';
+            execSync(`${openCmd} "${viewerPath}"`, { stdio: 'ignore' });
+            console.log(`\n  ${fmt.dim('Opened viewer in browser')}\n`);
+        }
+        catch {
+            console.log(`\n  ${fmt.dim('Open manually:')} ${viewerPath}\n`);
+        }
+    }
+}

package/dist/adapters/vitest/setup.d.ts

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

package/dist/adapters/vitest/setup.js

@@ -0,0 +1,3 @@
+import { afterAll, afterEach, aroundEach } from 'vitest';
+import { lifecycle } from './lifecycle.js';
+lifecycle.install(afterEach, afterAll, aroundEach);

package/dist/agents/codex-app-server/agent.js

@@ -2,11 +2,12 @@ import { BaseAgent, getRuntimeEnv, getWorkspacePath, } from '../../types.js';
 import { mountMcpForCodexAppServer } from '../../providers/mcp-runtime-mounting.js';
 import { assertMcpSecretReferencesReady } from '../../providers/mcp-config.js';
 import { buildSummary, enrichSkillEvents, extractSkillNameFromPath, inferCodexExecAction, } from '../../tool-events.js';
-import { requireAskBusForLiveBatches, } from '../../sdk/ask-bus/bus.js';
+import { requireAskBusForLiveBatches } from '../../sdk/ask-bus/bus.js';
 import { toAskUserToolEvent } from '../../sdk/ask-bus/projection.js';
 import { decideMcpToolCall, redactMcpSecrets, } from '../../sdk/mcp-safety.js';
 import { spawnAppServerTransport, } from './transport.js';
 import { normalizeUpstreamQuestion, toWireAnswerMap, } from './wire-translators.js';
+import { extractTurnCompletionFailure } from './turn-completion.js';
 const DEFAULT_MODEL = 'gpt-5.4';
 const TURN_COMPLETED_METHOD = 'turn/completed';
 function recordFromUnknown(value) {
@@ -308,6 +309,9 @@ export class CodexAppServerAgent extends BaseAgent {
                             settled = true;
                             off();
                             closeOff();
+                            const failure = extractTurnCompletionFailure(n.params);
+                            if (failure)
+                                Object.assign(turn, { turnFailed: true, failureMessage: failure });
                             resolve();
                         }
                     });

package/dist/agents/codex-app-server/protocol/index.js

@@ -1,8 +1,8 @@
 // Curated re-exports for the pathgrade Codex app-server driver and fixture
-// tests. Every re-exported symbol is either vendored verbatim from
+// tests. Every re-exported symbol is either a curated upstream shape from
 // openai/codex@rust-v0.124.0 (with an upstream-citation header in its file) or
-// a pathgrade-local composition (ClientRequest, ServerRequest, Op) whose
-// header spells out the composition rationale.
+// a pathgrade-local composition (ClientRequest, ServerRequest, Op) whose header
+// spells out the composition rationale.
 //
 // Refresh policy: to bump the vendored version, update each file's header
 // citation to the new tag, replace the `unknown` aliases with their vendored

package/dist/agents/codex-app-server/turn-completion.d.ts

@@ -0,0 +1 @@
+export declare function extractTurnCompletionFailure(params: unknown): string | undefined;

package/dist/agents/codex-app-server/turn-completion.js

@@ -0,0 +1,9 @@
+export function extractTurnCompletionFailure(params) {
+    const turn = params?.turn;
+    const message = turn?.error?.message;
+    const details = turn?.error?.additionalDetails;
+    if (typeof message === 'string' && message.length > 0) {
+        return typeof details === 'string' && details.length > 0 ? `${message} ${details}` : message;
+    }
+    return turn?.status === 'failed' ? 'turn failed' : undefined;
+}

package/dist/commands/affected.js

@@ -12,19 +12,11 @@
  * and `--explain` / `--json` presentation.
  */
 import * as fs from 'fs';
-import { configDefaults } from 'vitest/config';
 import { selectAffected } from '../affected/select.js';
 import { resolveBaseRef, computeChangedFiles } from '../affected/git.js';
-import { loadAffectedConfig } from '../affected/config.js';
 import { formatExplain, formatJson } from '../affected/format.js';
 import { discoverPathgradeEvalFiles } from '../evals/discovery.js';
-const DEFAULT_EXCLUDE = [
-    ...configDefaults.exclude,
-    '.worktrees/**',
-    'worktrees/**',
-    '**/node_modules/**',
-    '**/fixtures/**',
-];
+import { DEFAULT_EVAL_EXCLUDE, DEFAULT_EVAL_INCLUDE, resolvePathgradeConfig, } from '../config/pathgrade.js';
 export async function runAffected(opts) {
     const { cwd } = opts;
     let changes;
@@ -44,9 +36,21 @@ export async function runAffected(opts) {
     if (changes.baseRefLine) {
         process.stderr.write(`${changes.baseRefLine}\n`);
     }
-    const evalFiles = discoverEvalFiles(cwd);
-    const config = await loadAffectedConfig(cwd, {
-        onWarning: w => process.stderr.write(`${w}\n`),
+    let config;
+    try {
+        config = await resolvePathgradeConfig({
+            cwd,
+            warn: w => process.stderr.write(`${w}\n`),
+        });
+    }
+    catch (err) {
+        process.stderr.write(`pathgrade affected: ${errMsg(err)}\n`);
+        return 1;
+    }
+    const evalFiles = discoverPathgradeEvalFiles({
+        cwd,
+        include: config.evals.include,
+        exclude: config.evals.exclude,
     });
     let result;
     try {
@@ -55,7 +59,7 @@ export async function runAffected(opts) {
             changedFiles: changes.changedFiles,
             repoRoot: cwd,
             baseRef: changes.baseRef,
-            global: config.global,
+            global: config.affected.global,
         });
     }
     catch (err) {
@@ -132,6 +136,9 @@ function readChangedFilesList(filePath) {
         .map(l => l.trim())
         .filter(l => l.length > 0);
 }
+function errMsg(err) {
+    return err instanceof Error ? err.message : String(err);
+}
 /**
  * Discover repo-relative `*.eval.ts` files under `cwd`, honoring the same
  * exclude defaults the vitest plugin uses.
@@ -139,8 +146,8 @@ function readChangedFilesList(filePath) {
 export function discoverEvalFiles(cwd) {
     return discoverPathgradeEvalFiles({
         cwd,
-        include: ['**/*.eval.ts'],
-        exclude: DEFAULT_EXCLUDE,
+        include: DEFAULT_EVAL_INCLUDE,
+        exclude: DEFAULT_EVAL_EXCLUDE,
     });
 }
 function printSelectedToStdout(result) {

package/dist/commands/run-args.d.ts

@@ -2,11 +2,12 @@
  * Parse `pathgrade run` arguments.
  *
  * Recognized pathgrade-specific flags are consumed here; everything else
- * passes through to vitest. After a literal `--` separator, all remaining
- * args are forwarded verbatim (vitest uses `--` the same way).
+ * passes through to the selected runner. After a literal `--` separator,
+ * all remaining args are forwarded verbatim.
  */
 export interface PathgradeRunArgs {
-    vitestArgs: string[];
+    runnerArgs: string[];
+    adapterName?: string;
     forceDiagnostics: boolean;
     forceVerbose: boolean;
     changed: boolean;

package/dist/commands/run-args.js

@@ -2,21 +2,22 @@
  * Parse `pathgrade run` arguments.
  *
  * Recognized pathgrade-specific flags are consumed here; everything else
- * passes through to vitest. After a literal `--` separator, all remaining
- * args are forwarded verbatim (vitest uses `--` the same way).
+ * passes through to the selected runner. After a literal `--` separator,
+ * all remaining args are forwarded verbatim.
  */
 export function parsePathgradeRunArgs(args) {
-    const vitestArgs = [];
+    const runnerArgs = [];
     let forceDiagnostics = false;
     let forceVerbose = false;
     let changed = false;
     let quiet = false;
     let since;
     let changedFilesPath;
+    let adapterName;
     let passthrough = false;
     for (const arg of args) {
         if (passthrough) {
-            vitestArgs.push(arg);
+            runnerArgs.push(arg);
             continue;
         }
         if (arg === '--') {
@@ -39,6 +40,10 @@ export function parsePathgradeRunArgs(args) {
             quiet = true;
             continue;
         }
+        if (arg.startsWith('--adapter=')) {
+            adapterName = arg.slice('--adapter='.length);
+            continue;
+        }
         if (arg.startsWith('--since=')) {
             since = arg.slice('--since='.length);
             continue;
@@ -47,7 +52,7 @@ export function parsePathgradeRunArgs(args) {
             changedFilesPath = arg.slice('--changed-files='.length);
             continue;
         }
-        vitestArgs.push(arg);
+        runnerArgs.push(arg);
     }
     const warnings = [];
     if (!changed && since !== undefined) {
@@ -57,11 +62,12 @@ export function parsePathgradeRunArgs(args) {
         warnings.push('--changed-files has no effect without --changed; the flag is being ignored.');
     }
     const base = {
-        vitestArgs,
+        runnerArgs,
         forceDiagnostics,
         forceVerbose,
         changed,
         quiet,
+        adapterName,
         since,
         changedFilesPath,
     };

package/dist/commands/run-changed.d.ts

@@ -12,15 +12,15 @@
  * Git-resolution failures exit non-zero. The selection pipeline is the
  * only producer of the file list here.
  */
+import type { RunnerInvocationAdapter } from '../runners/invocation.js';
+import type { SpawnVitest } from '../runners/vitest-invocation.js';
 import type { PathgradeRunArgs } from './run-args.js';
-export interface SpawnVitestRequest {
-    argv: string[];
-}
-export type SpawnVitest = (req: SpawnVitestRequest) => Promise<number> | number;
+export type { SpawnVitest };
 export interface RunChangedOptions {
     cwd: string;
     parsed: PathgradeRunArgs;
     /** Override for tests; default spawns `npx vitest` inheriting stdio. */
     spawnVitest?: SpawnVitest;
+    runnerInvocation?: RunnerInvocationAdapter;
 }
 export declare function runChanged(opts: RunChangedOptions): Promise<number>;

package/dist/commands/run-changed.js

@@ -13,15 +13,42 @@
  * only producer of the file list here.
  */
 import * as fs from 'fs';
-import picomatch from 'picomatch';
 import { selectAffected } from '../affected/select.js';
 import { resolveBaseRef, computeChangedFiles } from '../affected/git.js';
-import { loadAffectedConfig } from '../affected/config.js';
 import { writeSidecar } from '../affected/sidecar.js';
-import { discoverEvalFiles } from './affected.js';
+import { discoverPathgradeEvalFiles } from '../evals/discovery.js';
+import { resolvePathgradeConfig } from '../config/pathgrade.js';
+import { loadRunnerInvocationAdapter } from '../runners/adapter-loader.js';
 export async function runChanged(opts) {
     const { cwd, parsed } = opts;
-    const spawnVitest = opts.spawnVitest ?? defaultSpawnVitest;
+    const runnerEnv = {
+        ...process.env,
+        ...(parsed.forceDiagnostics ? { PATHGRADE_DIAGNOSTICS: '1' } : {}),
+        ...(parsed.forceVerbose ? { PATHGRADE_VERBOSE: '1' } : {}),
+    };
+    const configPath = findVitestConfigArg(parsed.runnerArgs);
+    let config;
+    let runnerInvocation;
+    try {
+        config = await resolvePathgradeConfig({
+            cwd,
+            legacyVitestConfigPath: configPath,
+            warn: w => {
+                if (!parsed.quiet)
+                    process.stderr.write(`${w}\n`);
+            },
+        });
+        runnerInvocation = opts.runnerInvocation ?? await loadRunnerInvocationAdapter({
+            adapterName: parsed.adapterName ?? config.runner.adapter,
+            cwd,
+            config,
+            spawnVitest: opts.spawnVitest,
+        });
+    }
+    catch (err) {
+        process.stderr.write(`${errMsg(err)}\n`);
+        return 1;
+    }
     // 1. Change-set
     let baseRef;
     let changedFiles;
@@ -53,22 +80,11 @@ export async function runChanged(opts) {
         baseRefLine = `pathgrade: base = ${baseRef} (merge-base with HEAD)`;
     }
     // 2. Selection
-    const configPath = findVitestConfigArg(parsed.vitestArgs);
-    let config;
-    try {
-        config = await loadAffectedConfig(cwd, {
-            configPath,
-            onWarning: w => {
-                if (!parsed.quiet)
-                    process.stderr.write(`${w}\n`);
-            },
-        });
-    }
-    catch (err) {
-        process.stderr.write(`${errMsg(err)}\n`);
-        return 1;
-    }
-    const evalFiles = filterEvalFilesForConfig(discoverEvalFiles(cwd), config);
+    const evalFiles = discoverPathgradeEvalFiles({
+        cwd,
+        include: config.evals.include,
+        exclude: config.evals.exclude,
+    });
     let result;
     try {
         result = selectAffected({
@@ -76,7 +92,7 @@ export async function runChanged(opts) {
             changedFiles,
             repoRoot: cwd,
             baseRef,
-            global: config.global,
+            global: config.affected.global,
         });
     }
     catch (err) {
@@ -103,16 +119,16 @@ export async function runChanged(opts) {
         return 0;
     }
     const selectedFiles = result.selected.map(s => s.file);
-    if (hasPassWithNoTests(parsed.vitestArgs)) {
-        process.stderr.write('pathgrade run: --passWithNoTests cannot be used with pathgrade run --changed. ' +
-            'The command already exits 0 when no evals are selected; if selected evals resolve to no Vitest files, CI must fail.\n');
-        return 1;
-    }
-    const argv = ['run', ...selectedFiles, ...parsed.vitestArgs];
+    const runnerArgs = [...config.runner.args, ...parsed.runnerArgs];
     if (!parsed.quiet) {
-        process.stderr.write(`→ vitest run ${selectedFiles.join(' ')}\n`);
+        process.stderr.write(`→ ${runnerInvocation.name} run ${selectedFiles.join(' ')}\n`);
     }
-    return await spawnVitest({ argv });
+    return await runnerInvocation.run({
+        cwd,
+        runnerArgs,
+        selectedFiles,
+        env: runnerEnv,
+    });
 }
 function printRunStartSummary(input) {
     const { baseRefLine, totalEvals, changedCount, result } = input;
@@ -141,15 +157,6 @@ function readChangedFilesList(filePath) {
 function errMsg(err) {
     return err instanceof Error ? err.message : String(err);
 }
-function hasPassWithNoTests(args) {
-    return args.some(arg => {
-        if (arg === '--passWithNoTests')
-            return true;
-        if (!arg.startsWith('--passWithNoTests='))
-            return false;
-        return arg.slice('--passWithNoTests='.length).toLowerCase() !== 'false';
-    });
-}
 function findVitestConfigArg(args) {
     for (let i = 0; i < args.length; i++) {
         const arg = args[i];
@@ -162,23 +169,3 @@ function findVitestConfigArg(args) {
     }
     return undefined;
 }
-function filterEvalFilesForConfig(evalFiles, config) {
-    if (!config.include && !config.exclude)
-        return evalFiles;
-    const includeMatchers = config.include?.map(g => picomatch(g, { dot: true }));
-    const excludeMatchers = config.exclude?.map(g => picomatch(g, { dot: true })) ?? [];
-    return evalFiles.filter(file => {
-        const included = includeMatchers ? includeMatchers.some(m => m(file)) : true;
-        return included && !excludeMatchers.some(m => m(file));
-    });
-}
-async function defaultSpawnVitest(req) {
-    const { spawn } = await import('child_process');
-    return await new Promise(resolve => {
-        const child = spawn('npx', ['vitest', ...req.argv], {
-            stdio: 'inherit',
-            shell: true,
-        });
-        child.on('close', code => resolve(code ?? 0));
-    });
-}

package/dist/config/pathgrade.d.ts

@@ -0,0 +1,48 @@
+export interface PathgradeConfig {
+    runner?: {
+        adapter?: string;
+        args?: string[];
+    };
+    evals?: {
+        include?: string[];
+        exclude?: string[];
+    };
+    affected?: {
+        global?: string[];
+    };
+    reporter?: 'cli' | 'browser' | 'json';
+    diagnostics?: boolean;
+    verbose?: boolean;
+    ci?: {
+        threshold?: number;
+    };
+}
+export interface ResolvedPathgradeConfig {
+    runner: {
+        adapter: string;
+        args: string[];
+    };
+    evals: {
+        include: string[];
+        exclude: string[];
+    };
+    affected: {
+        global: string[];
+    };
+    reporter?: 'cli' | 'browser' | 'json';
+    diagnostics: boolean;
+    verbose: boolean;
+    ci: {
+        threshold?: number;
+    };
+}
+export declare const DEFAULT_EVAL_INCLUDE: string[];
+export declare const DEFAULT_EVAL_EXCLUDE: string[];
+export declare function defaultPathgradeConfig(): ResolvedPathgradeConfig;
+export declare function resolvePathgradeConfig(input: {
+    cwd: string;
+    cli?: PathgradeConfig;
+    configPath?: string;
+    legacyVitestConfigPath?: string;
+    warn?: (message: string) => void;
+}): Promise<ResolvedPathgradeConfig>;