mocode-ai 0.7.1 → 0.7.2

package/dist/verification/index.js

@@ -4,10 +4,14 @@ import { checkPermission } from '../permissions/index.js';
 import { beginWorkspaceMutation, endWorkspaceMutation, getCurrentTurnMutationState, } from '../rollback/index.js';
 import { formatCommandResult, runCommandRaw, runCommandTool, } from '../tools/builtins/run-command.js';
 import { resolveAffectedPackages } from './affected.js';
-import { discoverPackageValidationCommand } from './discovery.js';
+import { discoverPackageValidationCommands } from './discovery.js';
+import { runChangedFileDiagnostics } from './diagnostics.js';
+import { fingerprintFiles, fingerprintValidation } from './fingerprint.js';
+import { runFilePostconditions } from './postconditions.js';
 import { discoverProjectProfile } from './profile.js';
+import { discoverTargetedTestCommands } from './targeted-tests.js';
 export { resolveAffectedPackages } from './affected.js';
-export { discoverPackageValidationCommand, discoverValidationCommand } from './discovery.js';
+export { discoverPackageValidationCommand, discoverPackageValidationCommands, discoverValidationCommand, } from './discovery.js';
 export { clearProjectProfileCache, discoverProjectProfile } from './profile.js';
 const NON_CODE_EXTENSIONS = new Set([
     '.md', '.mdx', '.txt', '.rst', '.png', '.jpg', '.jpeg', '.gif', '.svg', '.webp',
@@ -16,14 +20,14 @@ function isNonCodePath(file) {
     return NON_CODE_EXTENSIONS.has(path.extname(file).toLowerCase());
 }
 function affectedSummary(affected) {
-    return affected.packages.map((item) => ({
+    return affected?.packages.map((item) => ({
         name: item.package.name,
         root: item.package.root,
         reasons: item.reasons,
-    }));
+    })) ?? [];
 }
 function selectionOutput(affected) {
-    if (affected.packages.length === 0)
+    if (!affected || affected.packages.length === 0)
         return '';
     return [
         'Affected packages:',
@@ -33,131 +37,297 @@ function selectionOutput(affected) {
         }),
     ].join('\n');
 }
-function skipped(reason, patch = {}) {
+function stageOutput(stage) {
+    const scope = stage.packageName ? ` ${stage.packageName}` : '';
+    return `[${stage.level}${scope}] ${stage.status} (${stage.adapter})${stage.output ? `\n${stage.output}` : ''}`;
+}
+function highestLevel(stages) {
+    return stages.at(-1)?.level;
+}
+function aggregate(options) {
     const state = getCurrentTurnMutationState();
+    const diagnostics = options.stages.flatMap((stage) => stage.diagnostics);
+    const terminal = options.stages.find((stage) => stage.status === 'failed' || stage.status === 'aborted');
+    const blockingSkip = options.stages.find((stage) => stage.status === 'skipped' && [
+        'permission_denied', 'no_validation_script', 'no_package_json',
+        'no_affected_package', 'invalid_changed_path',
+    ].includes(stage.skipReason ?? ''));
+    const v3Passed = options.stages.some((stage) => stage.level === 'V3' && stage.status === 'passed');
+    const substantivePassed = options.stages.some((stage) => stage.level !== 'V0' && stage.status === 'passed');
+    const status = terminal?.status ?? (blockingSkip || !substantivePassed ? 'skipped' : 'passed');
+    const level = terminal?.level ?? highestLevel(options.stages);
+    const output = [selectionOutput(options.affected), ...options.stages.map(stageOutput)].filter(Boolean).join('\n\n');
+    const commands = options.stages.flatMap((stage) => stage.command ? [stage.command] : []);
+    const skipReason = options.skipReason
+        ?? blockingSkip?.skipReason
+        ?? (status === 'skipped' ? 'no_applicable_validator' : undefined);
+    const fingerprint = fingerprintValidation({
+        root: options.root,
+        level,
+        status,
+        adapter: terminal?.adapter,
+        command: commands.join(' | '),
+        diagnostics,
+        output,
+    });
+    return {
+        status,
+        level,
+        script: commands.length === 1 ? options.packageResults?.[0]?.script : undefined,
+        command: commands.length > 0 ? commands.join(' | ') : undefined,
+        exitCode: terminal?.exitCode,
+        output,
+        durationMs: options.stages.reduce((sum, stage) => sum + stage.durationMs, 0),
+        skipReason,
+        diagnostics,
+        stages: options.stages,
+        verificationComplete: status === 'passed' && v3Passed && !blockingSkip,
+        fingerprint,
+        inputFingerprint: options.inputFingerprint,
+        inputMutationVersion: options.inputMutationVersion,
+        affectedPackages: affectedSummary(options.affected),
+        rejectedChangedFiles: options.affected?.rejected,
+        packageResults: options.packageResults,
+        changedFiles: state.changedFiles.map((item) => item.path),
+        mutationVersion: state.version,
+    };
+}
+function emptyResult(root, reason, inputMutationVersion, changedFiles) {
+    const inputFingerprint = fingerprintFiles(root, changedFiles);
+    return aggregate({ root, inputMutationVersion, inputFingerprint, stages: [], skipReason: reason });
+}
+function skippedStage(level, adapter, reason, output, inputFingerprint, packageName) {
     return {
+        level,
         status: 'skipped',
-        output: '',
+        adapter,
+        packageName,
+        diagnostics: [],
+        output,
         durationMs: 0,
         skipReason: reason,
-        changedFiles: state.changedFiles.map((item) => item.path),
-        mutationVersion: state.version,
-        ...patch,
+        inputFingerprint,
+    };
+}
+function commandSource(command) {
+    return command.script;
+}
+async function executeSelectedCommand(item, root, inputFingerprint, signal, callbacks) {
+    const relativeCwd = path.relative(root, item.command.cwd) || '.';
+    const permissionArgs = { command: item.command.command, path: relativeCwd };
+    const permission = await checkPermission(runCommandTool, permissionArgs, signal, { projectRoot: root });
+    callbacks.onPermissionDecision?.({
+        decision: permission,
+        tool: runCommandTool.name,
+        arguments: permissionArgs,
+    });
+    if (signal?.aborted) {
+        return {
+            stage: {
+                level: item.level, status: 'aborted', adapter: item.adapter,
+                packageName: item.affected.package.name, command: item.command.command,
+                diagnostics: [], output: 'Validation aborted.', durationMs: 0, inputFingerprint,
+            },
+        };
+    }
+    if (permission === 'deny') {
+        return {
+            stage: skippedStage(item.level, item.adapter, 'permission_denied', 'Validation command permission was denied.', inputFingerprint, item.affected.package.name),
+        };
+    }
+    callbacks.onCommandStart?.(`[${item.level} ${item.affected.package.name}] ${item.command.command}`);
+    const capture = beginWorkspaceMutation();
+    let raw;
+    try {
+        raw = await runCommandRaw(item.command.command, 120000, signal, item.command.cwd);
+    }
+    finally {
+        endWorkspaceMutation(capture, 'automatic_validation');
+    }
+    const status = raw.status === 'passed' ? 'passed' : raw.status === 'aborted' ? 'aborted' : 'failed';
+    const output = formatCommandResult(raw);
+    const diagnostics = status === 'failed'
+        ? [{
+                level: item.level,
+                source: commandSource(item.command),
+                severity: 'error',
+                code: raw.status.toUpperCase(),
+                packageName: item.affected.package.name,
+                message: output,
+            }]
+        : [];
+    const stage = {
+        level: item.level,
+        status,
+        adapter: item.adapter,
+        packageName: item.affected.package.name,
+        command: item.command.command,
+        exitCode: raw.exitCode,
+        diagnostics,
+        output,
+        durationMs: raw.durationMs,
+        inputFingerprint,
+    };
+    stage.fingerprint = fingerprintValidation({
+        root,
+        level: stage.level,
+        status: stage.status,
+        adapter: stage.adapter,
+        command: stage.command,
+        diagnostics,
+        output,
+    });
+    return {
+        stage,
+        packageResult: {
+            packageName: item.affected.package.name,
+            packageRoot: item.affected.package.root,
+            level: item.level,
+            status,
+            script: item.command.script,
+            command: item.command.command,
+            exitCode: raw.exitCode,
+            output,
+            durationMs: raw.durationMs,
+        },
     };
 }
-function commandSummary(selected) {
-    return selected.map((item) => `${item.affected.package.name}: ${item.command.command}`).join(' | ');
+async function runCommands(selected, root, inputFingerprint, signal, callbacks, stages, packageResults) {
+    for (const item of selected) {
+        const result = await executeSelectedCommand(item, root, inputFingerprint, signal, callbacks);
+        stages.push(result.stage);
+        if (result.packageResult)
+            packageResults.push(result.packageResult);
+        if (result.stage.status !== 'passed')
+            return false;
+    }
+    return true;
+}
+function resolveProfile(root, validationPaths) {
+    try {
+        const profile = discoverProjectProfile(root);
+        return {
+            profile,
+            affected: resolveAffectedPackages(profile, validationPaths, { changedFilesBase: process.cwd() }),
+        };
+    }
+    catch {
+        return {};
+    }
 }
-/** Run the lowest-cost validation command for each package affected by this turn's code changes. */
+/** Run V0→V3 in cost order and stop at the first actionable failure. */
 export async function runAutomaticValidation(signal, callbacks = {}) {
     const before = getCurrentTurnMutationState();
+    const root = path.resolve(getSandboxRoot() ?? process.cwd());
     const changedPaths = before.changedFiles.map((item) => item.path);
     if (changedPaths.length === 0)
-        return skipped('no_changes');
+        return emptyResult(root, 'no_changes', before.version, changedPaths);
     const validationPaths = changedPaths.filter((item) => !isNonCodePath(item));
-    if (validationPaths.length === 0)
-        return skipped('non_code_changes');
-    const root = path.resolve(getSandboxRoot() ?? process.cwd());
-    let affected;
-    let selected;
-    try {
-        const profile = discoverProjectProfile(root);
-        affected = resolveAffectedPackages(profile, validationPaths, { changedFilesBase: process.cwd() });
-        selected = affected.packages.flatMap((item) => {
-            const command = discoverPackageValidationCommand(profile, item.package);
-            return command ? [{ affected: item, command }] : [];
-        });
+    if (validationPaths.length === 0) {
+        return emptyResult(root, 'non_code_changes', before.version, changedPaths);
     }
-    catch {
-        return skipped('no_validation_script');
+    const inputFingerprint = fingerprintFiles(root, validationPaths);
+    const { profile, affected } = resolveProfile(root, validationPaths);
+    const stages = [];
+    const packageResults = [];
+    const finish = (skipReason) => aggregate({
+        root,
+        inputMutationVersion: before.version,
+        inputFingerprint,
+        stages,
+        affected,
+        packageResults,
+        skipReason,
+    });
+    const v0 = await runFilePostconditions(root, validationPaths, inputFingerprint);
+    stages.push(v0);
+    if (v0.status === 'failed')
+        return finish();
+    const v1 = await runChangedFileDiagnostics(root, validationPaths, inputFingerprint);
+    stages.push(v1);
+    if (v1.status === 'failed')
+        return finish();
+    if (!profile || !affected) {
+        stages.push(skippedStage('V3', 'package-scripts', 'no_package_json', 'No project package profile is available.', inputFingerprint));
+        return finish('no_package_json');
     }
-    const summary = affectedSummary(affected);
-    const selectedOutput = selectionOutput(affected);
     if (affected.rejected.length > 0) {
-        return skipped('invalid_changed_path', {
-            output: [
-                selectedOutput,
-                ...affected.rejected.map((item) => `Rejected changed path: ${item.input} (${item.reason})`),
-            ].filter(Boolean).join('\n'),
-            affectedPackages: summary,
-            rejectedChangedFiles: affected.rejected,
-        });
+        stages.push(skippedStage('V3', 'affected-packages', 'invalid_changed_path', affected.rejected.map((item) => `Rejected changed path: ${item.input} (${item.reason})`).join('\n'), inputFingerprint));
+        return finish('invalid_changed_path');
     }
     if (affected.packages.length === 0) {
-        return skipped('no_affected_package', { output: selectedOutput, affectedPackages: summary });
+        stages.push(skippedStage('V3', 'affected-packages', 'no_affected_package', 'No package owns the changed files.', inputFingerprint));
+        return finish('no_affected_package');
+    }
+    const targeted = discoverTargetedTestCommands(profile, affected.packages).map((item) => ({
+        affected: item.affected,
+        command: item.command,
+        level: 'V2',
+        adapter: item.adapter,
+    }));
+    if (targeted.length === 0) {
+        stages.push(skippedStage('V2', 'targeted-tests', 'no_targeted_tests', 'No reliable targeted tests were found.', inputFingerprint));
     }
-    if (selected.length === 0) {
-        return skipped('no_validation_script', { output: selectedOutput, affectedPackages: summary });
+    else if (!await runCommands(targeted, root, inputFingerprint, signal, callbacks, stages, packageResults)) {
+        return finish(stages.at(-1)?.skipReason === 'permission_denied' ? 'permission_denied' : undefined);
     }
-    const commands = commandSummary(selected);
-    for (const item of selected) {
-        const relativeCwd = path.relative(root, item.command.cwd) || '.';
-        const permission = await checkPermission(runCommandTool, { command: item.command.command, path: relativeCwd }, signal, { projectRoot: root });
-        if (signal?.aborted) {
-            const state = getCurrentTurnMutationState();
+    const selected = [];
+    for (const item of affected.packages) {
+        const commands = discoverPackageValidationCommands(profile, item.package);
+        if (commands.length === 0) {
+            stages.push(skippedStage('V3', 'package-scripts', 'no_validation_script', 'Affected package has no typecheck, build, or test script.', inputFingerprint, item.package.name));
+            continue;
+        }
+        selected.push(...commands.map((command) => ({
+            affected: item,
+            command,
+            level: 'V3',
+            adapter: `package-${command.script}`,
+        })));
+    }
+    const scriptOrder = { typecheck: 0, build: 1, test: 2 };
+    selected.sort((left, right) => scriptOrder[left.command.script] - scriptOrder[right.command.script]);
+    if (selected.length === 0)
+        return finish('no_validation_script');
+    await runCommands(selected, root, inputFingerprint, signal, callbacks, stages, packageResults);
+    return finish(stages.at(-1)?.skipReason === 'permission_denied' ? 'permission_denied' : undefined);
+}
+/** Create a run-scoped verifier cache; identical content never repeats expensive validation. */
+export function createAutomaticValidator() {
+    const cache = new Map();
+    const failureCounts = new Map();
+    return async (signal, callbacks = {}) => {
+        const state = getCurrentTurnMutationState();
+        const root = path.resolve(getSandboxRoot() ?? process.cwd());
+        const changedFiles = state.changedFiles.map((item) => item.path);
+        const inputFingerprint = fingerprintFiles(root, changedFiles);
+        const cacheKey = `${root}\0${inputFingerprint}`;
+        const cached = cache.get(cacheKey);
+        if (cached) {
+            const count = cached.status === 'failed'
+                ? (failureCounts.get(cached.fingerprint) ?? 1) + 1
+                : 1;
+            if (cached.status === 'failed')
+                failureCounts.set(cached.fingerprint, count);
             return {
-                status: 'aborted',
-                command: commands,
-                output: selectedOutput,
+                ...cached,
+                output: `${cached.output}\n\n[validation cache] Identical inputs reused; failure occurrence ${count}.`,
+                stages: cached.stages.map((stage) => ({ ...stage, cached: true, durationMs: 0 })),
                 durationMs: 0,
-                affectedPackages: summary,
-                changedFiles: state.changedFiles.map((change) => change.path),
+                inputMutationVersion: state.version,
+                changedFiles,
                 mutationVersion: state.version,
             };
         }
-        if (permission === 'deny') {
-            return skipped('permission_denied', {
-                command: commands,
-                output: selectedOutput,
-                affectedPackages: summary,
-            });
-        }
-    }
-    const packageResults = [];
-    const capture = beginWorkspaceMutation();
-    try {
-        for (const item of selected) {
-            callbacks.onCommandStart?.(`[${item.affected.package.name}] ${item.command.command}`);
-            const raw = await runCommandRaw(item.command.command, 120000, signal, item.command.cwd);
-            const status = raw.status === 'passed'
-                ? 'passed'
-                : raw.status === 'aborted'
-                    ? 'aborted'
-                    : 'failed';
-            packageResults.push({
-                packageName: item.affected.package.name,
-                packageRoot: item.affected.package.root,
-                status,
-                script: item.command.script,
-                command: item.command.command,
-                exitCode: raw.exitCode,
-                output: formatCommandResult(raw),
-                durationMs: raw.durationMs,
-            });
-            if (status !== 'passed')
-                break;
+        const result = await runAutomaticValidation(signal, callbacks);
+        if (result.status === 'failed') {
+            const count = (failureCounts.get(result.fingerprint) ?? 0) + 1;
+            failureCounts.set(result.fingerprint, count);
+            if (count > 1) {
+                result.output += `\n\n[validation thrashing] The same failure fingerprint occurred ${count} times; change strategy before retrying.`;
+            }
         }
-    }
-    finally {
-        endWorkspaceMutation(capture, 'automatic_validation');
-    }
-    const after = getCurrentTurnMutationState();
-    const terminal = packageResults.find((item) => item.status !== 'passed')
-        ?? packageResults[packageResults.length - 1];
-    const output = [
-        selectedOutput,
-        ...packageResults.map((item) => `[${item.packageName}] ${item.command} (cwd: ${path.relative(root, item.packageRoot) || '.'})\n${item.output}`),
-    ].filter(Boolean).join('\n\n');
-    return {
-        status: terminal.status,
-        script: selected.length === 1 ? selected[0]?.command.script : undefined,
-        command: commands,
-        exitCode: terminal.exitCode,
-        output,
-        durationMs: packageResults.reduce((total, item) => total + item.durationMs, 0),
-        affectedPackages: summary,
-        packageResults,
-        changedFiles: after.changedFiles.map((item) => item.path),
-        mutationVersion: after.version,
+        cache.set(cacheKey, result);
+        return result;
     };
 }

package/dist/verification/postconditions.js

@@ -0,0 +1,98 @@
+import { createHash } from 'node:crypto';
+import { readFile, stat } from 'node:fs/promises';
+import path from 'node:path';
+function hash(value) {
+    return createHash('sha256').update(value).digest('hex');
+}
+function diagnostic(file, code, message) {
+    return {
+        level: 'V0',
+        source: 'postcondition',
+        severity: 'error',
+        code,
+        file,
+        message,
+    };
+}
+function parseJson(file, content) {
+    if (path.extname(file).toLowerCase() !== '.json')
+        return [];
+    try {
+        JSON.parse(content);
+        return [];
+    }
+    catch (error) {
+        return [diagnostic(file, 'INVALID_JSON', error instanceof Error ? error.message : String(error))];
+    }
+}
+/** Immediate read-after-write verification used by write_file and edit_file. */
+export async function verifyWrittenFile(file, expectedContent) {
+    const expectedHash = hash(Buffer.from(expectedContent, 'utf8'));
+    let actual;
+    try {
+        actual = await readFile(file);
+    }
+    catch (error) {
+        return {
+            status: 'failed',
+            expectedHash,
+            diagnostics: [diagnostic(file, 'POSTCONDITION_READ_FAILED', error instanceof Error ? error.message : String(error))],
+        };
+    }
+    const actualHash = hash(actual);
+    const diagnostics = actualHash === expectedHash
+        ? parseJson(file, actual.toString('utf8'))
+        : [diagnostic(file, 'CONTENT_HASH_MISMATCH', 'Content read after writing differs from the requested content.')];
+    return {
+        status: diagnostics.length === 0 ? 'passed' : 'failed',
+        expectedHash,
+        actualHash,
+        diagnostics,
+    };
+}
+/** Re-check current changed files before more expensive validation layers. */
+export async function runFilePostconditions(root, changedFiles, inputFingerprint) {
+    const startedAt = Date.now();
+    const diagnostics = [];
+    const hashes = [];
+    let checked = 0;
+    for (const changedFile of changedFiles) {
+        const absolute = path.resolve(process.cwd(), changedFile);
+        const relative = path.relative(root, absolute);
+        if (relative === '..' || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+            diagnostics.push(diagnostic(changedFile, 'OUTSIDE_PROJECT', 'Changed path is outside the project root.'));
+            continue;
+        }
+        try {
+            const fileStat = await stat(absolute);
+            if (!fileStat.isFile())
+                continue;
+            const content = await readFile(absolute);
+            checked += 1;
+            hashes.push(`${relative.replace(/\\/g, '/')}: ${hash(content)}`);
+            diagnostics.push(...parseJson(relative, content.toString('utf8')));
+        }
+        catch (error) {
+            const code = error.code;
+            if (code !== 'ENOENT') {
+                diagnostics.push(diagnostic(relative, 'POSTCONDITION_READ_FAILED', error instanceof Error ? error.message : String(error)));
+            }
+        }
+    }
+    const status = diagnostics.some((item) => item.severity === 'error') ? 'failed' : checked > 0 ? 'passed' : 'skipped';
+    return {
+        level: 'V0',
+        status,
+        adapter: 'file-postconditions',
+        diagnostics,
+        output: status === 'skipped' ? 'No current files require V0 postconditions.' : hashes.join('\n'),
+        durationMs: Date.now() - startedAt,
+        skipReason: status === 'skipped' ? 'no_current_files' : undefined,
+        inputFingerprint,
+    };
+}
+export function formatPostconditionFailure(result) {
+    return result.diagnostics
+        .map((item) => `[${item.code ?? 'V0_FAILED'}] ${item.file ?? ''}: ${item.message}`)
+        .join('\n');
+}

package/dist/verification/targeted-tests.js

@@ -0,0 +1,96 @@
+import { existsSync, statSync } from 'node:fs';
+import path from 'node:path';
+const TEST_FILE = /(?:^|[/\\])(?:__tests__[/\\].+|.+\.(?:test|spec))\.[cm]?[jt]sx?$/i;
+const SOURCE_EXTENSION = /\.[cm]?[jt]sx?$/i;
+function isFile(file) {
+    try {
+        return statSync(file).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function inside(root, candidate) {
+    const relative = path.relative(root, candidate);
+    return relative === '' || (!relative.startsWith(`..${path.sep}`) && relative !== '..' && !path.isAbsolute(relative));
+}
+function quoteArg(value) {
+    if (process.platform === 'win32')
+        return `"${value.replace(/%/g, '%%').replace(/"/g, '""')}"`;
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function adapterFor(script) {
+    if (/\bvitest\b/i.test(script))
+        return 'vitest';
+    if (/\bjest\b/i.test(script))
+        return 'jest';
+    if (/\bnode\s+--test\b/i.test(script))
+        return 'node-test';
+    return null;
+}
+function candidateTests(source) {
+    if (TEST_FILE.test(source))
+        return [source];
+    if (!SOURCE_EXTENSION.test(source) || source.endsWith('.d.ts'))
+        return [];
+    const extension = path.extname(source);
+    const stem = source.slice(0, -extension.length);
+    const base = path.basename(stem);
+    const directory = path.dirname(source);
+    return [
+        `${stem}.test${extension}`,
+        `${stem}.spec${extension}`,
+        path.join(directory, '__tests__', `${base}.test${extension}`),
+        path.join(directory, '__tests__', `${base}.spec${extension}`),
+    ];
+}
+function runnerArgs(adapter, script) {
+    if (adapter === 'vitest' && !/\bvitest\s+run\b/i.test(script))
+        return ['--run'];
+    if (adapter === 'jest')
+        return ['--runInBand'];
+    return [];
+}
+/** Discover reliable direct/co-located tests without crossing package boundaries. */
+export function discoverTargetedTestCommands(profile, affectedPackages) {
+    const selected = [];
+    for (const affected of affectedPackages) {
+        const script = affected.package.scripts.test;
+        if (typeof script !== 'string')
+            continue;
+        const adapter = adapterFor(script);
+        if (!adapter)
+            continue;
+        const files = new Set();
+        for (const reason of affected.reasons) {
+            if (reason.kind !== 'direct_change')
+                continue;
+            const changed = path.resolve(profile.root, reason.changedPath);
+            if (!inside(affected.package.root, changed))
+                continue;
+            for (const candidate of candidateTests(changed)) {
+                if (existsSync(candidate) && isFile(candidate) && inside(affected.package.root, candidate)) {
+                    files.add(candidate);
+                }
+            }
+        }
+        if (files.size === 0)
+            continue;
+        const relativeFiles = [...files]
+            .map((file) => path.relative(affected.package.root, file))
+            .sort();
+        const args = [...runnerArgs(adapter, script), ...relativeFiles].map(quoteArg).join(' ');
+        selected.push({
+            affected,
+            adapter,
+            files: relativeFiles,
+            command: {
+                script: 'test',
+                command: `${profile.packageManager} run test -- ${args}`,
+                packageManager: profile.packageManager,
+                cwd: affected.package.root,
+            },
+        });
+    }
+    return selected;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mocode-ai",
-  "version": "0.7.1",
+  "version": "0.7.2",
   "description": "终端编码 agent:LLM + tool-call 循环 + 流式输出(含思考)+ 16 个工具,接任意 OpenAI 兼容后端。",
   "type": "module",
   "bin": {