@wix/pathgrade 0.36.0 → 1.0.0

package/dist/adapters/node-test/index.js

@@ -0,0 +1,106 @@
+import nodeTest from 'node:test';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { subscribeToEvalResults } from '../../sdk/result-capture.js';
+import { createRunnerLifecycleHooks } from '../../runners/lifecycle-hooks.js';
+const lifecycle = createRunnerLifecycleHooks();
+let subscribed = false;
+let caseCounter = 0;
+export function test(name, optionsOrFn, maybeFn) {
+    installResultCapture();
+    const options = typeof optionsOrFn === 'function' ? undefined : optionsOrFn;
+    const fn = typeof optionsOrFn === 'function' ? optionsOrFn : maybeFn;
+    const sourceRef = callerSourceRef();
+    const caseId = `${sourceRef}:${name}:${++caseCounter}`;
+    nodeTest(name, options, async (ctx) => {
+        const startedAt = performance.now();
+        let state = 'passed';
+        let thrown;
+        try {
+            await lifecycle.withCaseContext({
+                caseId,
+                caseName: name,
+                filePath: sourceRef,
+                sourceRef,
+                runnerNativeId: caseId,
+                scope: 'runner-case',
+            }, async () => {
+                await fn?.(ctx);
+            });
+        }
+        catch (err) {
+            state = 'failed';
+            thrown = err;
+        }
+        finally {
+            const evaluations = await lifecycle.flushCase(caseId);
+            writeCase({
+                caseId,
+                name,
+                state,
+                runnerDurationMs: performance.now() - startedAt,
+                sourceRef,
+                filePath: sourceRef,
+                groupName: sourceRef,
+                runnerCaseId: caseId,
+                evaluations: toReportEvaluations(evaluations),
+            });
+        }
+        if (thrown)
+            throw thrown;
+    });
+}
+export default test;
+export { createNodeTestAdapter } from './runner-adapter.js';
+export { createNodeTestInvocationAdapter } from './invocation-adapter.js';
+function installResultCapture() {
+    if (subscribed)
+        return;
+    subscribed = true;
+    subscribeToEvalResults(event => lifecycle.onResult(event), {
+        owner: 'adapter',
+        key: 'node-test-lifecycle',
+    });
+}
+function toReportEvaluations(evaluations) {
+    if (evaluations.length === 0)
+        return undefined;
+    return evaluations.map(entry => ({
+        score: entry.score,
+        trial: entry.trial,
+        diagnostics: entry.diagnostics,
+    }));
+}
+function writeCase(testCase) {
+    const resultsPath = process.env.PATHGRADE_NODE_TEST_RESULTS;
+    if (!resultsPath)
+        return;
+    fs.mkdirSync(path.dirname(resultsPath), { recursive: true });
+    const existing = fs.existsSync(resultsPath)
+        ? JSON.parse(fs.readFileSync(resultsPath, 'utf8'))
+        : [];
+    existing.push(testCase);
+    fs.writeFileSync(resultsPath, `${JSON.stringify(existing, null, 2)}\n`);
+}
+function callerSourceRef() {
+    const stack = new Error().stack ?? '';
+    const cwd = realpath(process.env.PATHGRADE_NODE_TEST_CWD ?? process.cwd());
+    for (const line of stack.split('\n')) {
+        const match = line.match(/\(?((?:file:\/\/)?[^() ]+\.eval\.[cm]?[jt]s)(?::\d+)?(?::\d+)?\)?/);
+        if (!match)
+            continue;
+        const raw = match[1];
+        const abs = realpath(raw.startsWith('file://') ? fileURLToPath(raw) : raw);
+        return path.relative(cwd, abs).replaceAll(path.sep, '/');
+    }
+    return 'node-test';
+}
+function realpath(value) {
+    try {
+        return fs.realpathSync(value);
+    }
+    catch {
+        return value;
+    }
+}

package/dist/adapters/node-test/invocation-adapter.d.ts

@@ -0,0 +1,5 @@
+import type { ResolvedPathgradeConfig } from '../../config/pathgrade.js';
+import type { RunnerInvocationAdapter } from '../../runners/invocation.js';
+export declare function createNodeTestInvocationAdapter(input: {
+    config: ResolvedPathgradeConfig;
+}): RunnerInvocationAdapter;

package/dist/adapters/node-test/invocation-adapter.js

@@ -0,0 +1,47 @@
+import { readSidecar } from '../../affected/sidecar.js';
+import { getPathgradeDir } from '../../reporters/results-path.js';
+import { printReportSummary } from '../../reporters/report-summary.js';
+import { runWithAdapter } from '../../runners/orchestrator.js';
+import { createNodeTestAdapter } from './runner-adapter.js';
+export function createNodeTestInvocationAdapter(input) {
+    return {
+        name: 'node-test',
+        async run(runInput) {
+            const selection = await readSidecar(runInput.cwd, msg => {
+                process.stderr.write(`[pathgrade] ${msg}\n`);
+            }) ?? undefined;
+            const include = runInput.selectedFiles && runInput.selectedFiles.length > 0
+                ? runInput.selectedFiles
+                : input.config.evals.include;
+            return await runWithAdapter({
+                adapter: createNodeTestAdapter(),
+                options: {
+                    cwd: runInput.cwd,
+                    discovery: {
+                        cwd: runInput.cwd,
+                        include,
+                        exclude: runInput.selectedFiles ? [] : input.config.evals.exclude,
+                    },
+                    runnerArgs: runInput.runnerArgs,
+                    env: runInput.env,
+                    artifactRoot: getPathgradeDir(runInput.cwd),
+                    reporterMode: input.config.reporter ?? 'cli',
+                    threshold: input.config.ci.threshold,
+                    selection,
+                    printSummary: summaries => {
+                        printReportSummary(summaries, {
+                            forceVerbose: input.config.diagnostics
+                                || runInput.env.PATHGRADE_DIAGNOSTICS === '1',
+                        });
+                    },
+                    log: () => {
+                        process.stdout.write(`\n  Results written to ${getPathgradeDir(runInput.cwd)}\n\n`);
+                    },
+                    onThresholdFailure: ({ overallPassRate, threshold }) => {
+                        process.stdout.write(`\n  CI THRESHOLD FAILED  avg score ${overallPassRate.toFixed(3)} < threshold ${threshold}\n\n`);
+                    },
+                },
+            });
+        },
+    };
+}

package/dist/adapters/node-test/runner-adapter.d.ts

@@ -0,0 +1,2 @@
+import type { RunnerAdapter } from '../../runners/adapter.js';
+export declare function createNodeTestAdapter(): RunnerAdapter;

package/dist/adapters/node-test/runner-adapter.js

@@ -0,0 +1,116 @@
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { spawn } from 'node:child_process';
+import fs from 'fs-extra';
+import { discoverPathgradeEvalFiles } from '../../evals/discovery.js';
+import { buildNormalizedRunSnapshotFromReportGroups } from '../../runners/model-builders.js';
+export function createNodeTestAdapter() {
+    return {
+        name: 'node-test',
+        async discover(input) {
+            const include = input.include ?? ['**/*.eval.ts'];
+            const exclude = input.exclude ?? [];
+            const files = discoverPathgradeEvalFiles({
+                cwd: input.cwd,
+                include,
+                exclude,
+            });
+            return {
+                units: files.map(file => ({
+                    id: file,
+                    displayName: file,
+                    sourceRef: file,
+                    native: { file, cwd: input.cwd },
+                })),
+            };
+        },
+        async invoke(input) {
+            const resultsDir = await fs.mkdtemp(path.join(os.tmpdir(), 'pathgrade-node-test-'));
+            const resultsPath = path.join(resultsDir, 'cases.json');
+            const cwd = readDiscoveredCwd(input.discovered.units[0]?.native) ?? process.cwd();
+            const files = input.discovered.units
+                .map(unit => unit.sourceRef)
+                .filter((sourceRef) => typeof sourceRef === 'string');
+            if (files.length === 0) {
+                await fs.writeJson(resultsPath, []);
+                return {
+                    adapterName: this.name,
+                    status: 'completed',
+                    exitCode: 0,
+                    native: { resultsPath },
+                };
+            }
+            const exitCode = await spawnNodeTest({
+                testCwd: cwd,
+                files,
+                argv: input.argv,
+                env: {
+                    ...input.env,
+                    PATHGRADE_NODE_TEST_RESULTS: resultsPath,
+                    PATHGRADE_NODE_TEST_CWD: cwd,
+                },
+            });
+            return {
+                adapterName: this.name,
+                status: input.signal?.aborted ? 'cancelled' : (exitCode === 0 ? 'completed' : 'failed'),
+                exitCode,
+                native: { resultsPath },
+            };
+        },
+        async collectNormalizedRunSnapshot(run) {
+            const native = readNodeTestRunNative(run);
+            const cases = await readCases(native.resultsPath);
+            const groupMap = new Map();
+            for (const testCase of cases) {
+                const groupName = testCase.groupName ?? testCase.filePath ?? testCase.sourceRef ?? 'node-test';
+                if (!groupMap.has(groupName))
+                    groupMap.set(groupName, []);
+                groupMap.get(groupName).push(testCase);
+            }
+            return buildNormalizedRunSnapshotFromReportGroups(run, Array.from(groupMap.entries()).map(([groupName, groupedCases]) => ({
+                groupName,
+                cases: groupedCases,
+            })));
+        },
+    };
+}
+async function spawnNodeTest(input) {
+    const tsxLoader = import.meta.resolve('tsx');
+    const args = [
+        '--import',
+        tsxLoader,
+        '--test',
+        ...input.files,
+        ...input.argv,
+    ];
+    return await new Promise(resolve => {
+        const child = spawn(process.execPath, args, {
+            cwd: input.testCwd,
+            env: input.env,
+            stdio: 'inherit',
+        });
+        child.on('close', code => resolve(code ?? 0));
+        child.on('error', () => resolve(1));
+    });
+}
+function readNodeTestRunNative(run) {
+    if (typeof run.native === 'object'
+        && run.native !== null
+        && typeof run.native.resultsPath === 'string') {
+        return run.native;
+    }
+    return { resultsPath: '' };
+}
+async function readCases(resultsPath) {
+    if (!resultsPath || !(await fs.pathExists(resultsPath)))
+        return [];
+    return await fs.readJson(resultsPath);
+}
+function readDiscoveredCwd(native) {
+    if (typeof native === 'object'
+        && native !== null
+        && typeof native.cwd === 'string') {
+        return native.cwd;
+    }
+    return undefined;
+}

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

@@ -0,0 +1,9 @@
+import type { PathgradePluginOptions } from '../../sdk/types.js';
+export type { PathgradePluginOptions };
+/**
+ * Vitest plugin for pathgrade evaluations.
+ *
+ * Configures test file patterns, timeout, auto-dispose lifecycle hooks,
+ * and the pathgrade reporter for aggregate statistics.
+ */
+export declare function pathgrade(opts?: PathgradePluginOptions): any;

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) {