mocode-ai 0.7.0 → 0.7.1

package/dist/verification/index.js

@@ -0,0 +1,163 @@
+import path from 'node:path';
+import { getSandboxRoot } from '../sandbox/index.js';
+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 { discoverProjectProfile } from './profile.js';
+export { resolveAffectedPackages } from './affected.js';
+export { discoverPackageValidationCommand, 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',
+]);
+function isNonCodePath(file) {
+    return NON_CODE_EXTENSIONS.has(path.extname(file).toLowerCase());
+}
+function affectedSummary(affected) {
+    return affected.packages.map((item) => ({
+        name: item.package.name,
+        root: item.package.root,
+        reasons: item.reasons,
+    }));
+}
+function selectionOutput(affected) {
+    if (affected.packages.length === 0)
+        return '';
+    return [
+        'Affected packages:',
+        ...affected.packages.map((item) => {
+            const reasons = item.reasons.map((reason) => `${reason.kind}(${reason.changedPath})`).join(', ');
+            return `- ${item.package.name}: ${reasons}`;
+        }),
+    ].join('\n');
+}
+function skipped(reason, patch = {}) {
+    const state = getCurrentTurnMutationState();
+    return {
+        status: 'skipped',
+        output: '',
+        durationMs: 0,
+        skipReason: reason,
+        changedFiles: state.changedFiles.map((item) => item.path),
+        mutationVersion: state.version,
+        ...patch,
+    };
+}
+function commandSummary(selected) {
+    return selected.map((item) => `${item.affected.package.name}: ${item.command.command}`).join(' | ');
+}
+/** Run the lowest-cost validation command for each package affected by this turn's code changes. */
+export async function runAutomaticValidation(signal, callbacks = {}) {
+    const before = getCurrentTurnMutationState();
+    const changedPaths = before.changedFiles.map((item) => item.path);
+    if (changedPaths.length === 0)
+        return skipped('no_changes');
+    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 }] : [];
+        });
+    }
+    catch {
+        return skipped('no_validation_script');
+    }
+    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,
+        });
+    }
+    if (affected.packages.length === 0) {
+        return skipped('no_affected_package', { output: selectedOutput, affectedPackages: summary });
+    }
+    if (selected.length === 0) {
+        return skipped('no_validation_script', { output: selectedOutput, affectedPackages: summary });
+    }
+    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();
+            return {
+                status: 'aborted',
+                command: commands,
+                output: selectedOutput,
+                durationMs: 0,
+                affectedPackages: summary,
+                changedFiles: state.changedFiles.map((change) => change.path),
+                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;
+        }
+    }
+    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,
+    };
+}

package/dist/verification/profile.js

@@ -0,0 +1,237 @@
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import path from 'node:path';
+import fg from 'fast-glob';
+const cache = new Map();
+const ROOT_INPUTS = [
+    'package.json', 'pnpm-workspace.yaml', 'pnpm-workspace.yml',
+    'package-lock.json', 'pnpm-lock.yaml', 'yarn.lock', 'bun.lock', 'bun.lockb',
+];
+const SOURCE_DIRS = ['src', 'lib', 'app'];
+const TEST_DIRS = ['test', 'tests', '__tests__', 'spec', 'src/test', 'src/tests', 'src/__tests__'];
+const GENERATED_DIRS = ['generated', 'gen', 'dist', 'build', 'coverage', 'src/generated', 'src/gen'];
+const VENDOR_DIRS = ['vendor', 'vendors', 'third_party', 'third-party', 'node_modules'];
+const FIXTURE_DIRS = ['fixture', 'fixtures', '__fixtures__', 'test/fixtures', 'tests/fixtures'];
+const ALL_MARKED_DIRS = [...SOURCE_DIRS, ...TEST_DIRS, ...GENERATED_DIRS, ...VENDOR_DIRS, ...FIXTURE_DIRS];
+const TSCONFIG_GLOBS = ['tsconfig*.json', '{config,configs}/tsconfig*.json'];
+const TEST_CONFIG_GLOBS = [
+    '{vitest,jest,playwright,cypress}.config.{js,cjs,mjs,ts,cts,mts,json}',
+    '.mocharc.{js,cjs,mjs,json,yaml,yml}',
+];
+const LINT_CONFIG_GLOBS = [
+    'eslint.config.{js,cjs,mjs,ts,cts,mts}',
+    '.eslintrc',
+    '.eslintrc.{js,cjs,json,yaml,yml}',
+    'biome.json',
+    'biome.jsonc',
+];
+const GLOB_OPTIONS = {
+    absolute: true,
+    onlyFiles: true,
+    unique: true,
+    followSymbolicLinks: false,
+    suppressErrors: true,
+    ignore: ['**/node_modules/**', '**/.git/**'],
+};
+function readManifest(file) {
+    const parsed = JSON.parse(readFileSync(file, 'utf8'));
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error(`Invalid package manifest: ${file}`);
+    }
+    return parsed;
+}
+function packageManagerFromField(value) {
+    if (typeof value !== 'string')
+        return null;
+    const match = /^(npm|pnpm|yarn|bun)(?:@|$)/.exec(value.trim());
+    return match ? match[1] : null;
+}
+function detectPackageManager(root, field) {
+    const declared = packageManagerFromField(field);
+    if (declared)
+        return declared;
+    if (existsSync(path.join(root, 'pnpm-lock.yaml')))
+        return 'pnpm';
+    if (existsSync(path.join(root, 'yarn.lock')))
+        return 'yarn';
+    if (existsSync(path.join(root, 'bun.lock')) || existsSync(path.join(root, 'bun.lockb')))
+        return 'bun';
+    return 'npm';
+}
+function manifestWorkspacePatterns(value) {
+    const patterns = Array.isArray(value)
+        ? value
+        : value && typeof value === 'object'
+            ? value.packages
+            : [];
+    return Array.isArray(patterns)
+        ? patterns.filter((item) => typeof item === 'string' && item.trim().length > 0)
+        : [];
+}
+function cleanYamlValue(value) {
+    const withoutComment = value.replace(/\s+#.*$/, '').trim();
+    const unquoted = withoutComment.replace(/^(['"])(.*)\1$/, '$2').trim();
+    return unquoted || null;
+}
+function pnpmWorkspacePatterns(file) {
+    if (!existsSync(file))
+        return [];
+    const lines = readFileSync(file, 'utf8').split(/\r?\n/);
+    const result = [];
+    let packageIndent = null;
+    for (const line of lines) {
+        const declaration = /^(\s*)packages\s*:\s*(.*)$/.exec(line);
+        if (declaration) {
+            packageIndent = declaration[1]?.length ?? 0;
+            const inline = declaration[2]?.trim();
+            if (inline?.startsWith('[') && inline.endsWith(']')) {
+                for (const item of inline.slice(1, -1).split(',')) {
+                    const value = cleanYamlValue(item);
+                    if (value)
+                        result.push(value);
+                }
+            }
+            continue;
+        }
+        if (packageIndent === null || /^\s*(?:#.*)?$/.test(line))
+            continue;
+        const indent = /^\s*/.exec(line)?.[0].length ?? 0;
+        if (indent <= packageIndent)
+            break;
+        const item = /^\s*-\s*(.+?)\s*$/.exec(line);
+        if (item?.[1]) {
+            const value = cleanYamlValue(item[1]);
+            if (value)
+                result.push(value);
+        }
+    }
+    return result;
+}
+function uniqueSorted(values) {
+    return [...new Set(values)].sort((left, right) => left.localeCompare(right));
+}
+function workspaceManifestGlobs(patterns) {
+    return patterns.map((raw) => {
+        const negative = raw.startsWith('!');
+        const value = (negative ? raw.slice(1) : raw).replace(/[\\/]+$/, '');
+        const manifest = value.endsWith('package.json') ? value : `${value}/package.json`;
+        return negative ? `!${manifest}` : manifest;
+    });
+}
+function isInside(root, candidate) {
+    const relative = path.relative(root, candidate);
+    return relative === '' || (!relative.startsWith(`..${path.sep}`) && relative !== '..' && !path.isAbsolute(relative));
+}
+function discoverManifestPaths(root, patterns) {
+    const rootManifest = path.join(root, 'package.json');
+    const matches = fg.sync(workspaceManifestGlobs(patterns), { cwd: root, ...GLOB_OPTIONS });
+    const paths = [
+        ...(existsSync(rootManifest) ? [rootManifest] : []),
+        ...matches.map((item) => path.resolve(item)),
+    ].filter((item) => isInside(root, item));
+    return uniqueSorted(paths.map((item) => path.resolve(item)));
+}
+function discoverConfigPaths(root, patterns) {
+    return uniqueSorted(fg.sync(patterns, { cwd: root, ...GLOB_OPTIONS }).map((item) => path.resolve(item)));
+}
+function existingDirectories(root, relativePaths) {
+    return relativePaths.map((item) => path.resolve(root, item)).filter((item) => {
+        try {
+            return statSync(item).isDirectory();
+        }
+        catch {
+            return false;
+        }
+    });
+}
+function scriptsFromManifest(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return {};
+    return Object.fromEntries(Object.entries(value).filter((entry) => typeof entry[1] === 'string'));
+}
+function createPackageProfile(manifestPath) {
+    const root = path.dirname(manifestPath);
+    const manifest = readManifest(manifestPath);
+    return {
+        name: typeof manifest.name === 'string' && manifest.name ? manifest.name : path.basename(root),
+        root,
+        scripts: scriptsFromManifest(manifest.scripts),
+        sourceRoots: existingDirectories(root, SOURCE_DIRS),
+        testRoots: existingDirectories(root, TEST_DIRS),
+        tsconfigPaths: discoverConfigPaths(root, TSCONFIG_GLOBS),
+        testConfigPaths: discoverConfigPaths(root, TEST_CONFIG_GLOBS),
+        lintConfigPaths: discoverConfigPaths(root, LINT_CONFIG_GLOBS),
+        generatedRoots: existingDirectories(root, GENERATED_DIRS),
+        vendorRoots: existingDirectories(root, VENDOR_DIRS),
+        fixtureRoots: existingDirectories(root, FIXTURE_DIRS),
+    };
+}
+function inputSignatures(root, workspacePatterns) {
+    const manifestPaths = discoverManifestPaths(root, workspacePatterns);
+    const packageRoots = uniqueSorted([root, ...manifestPaths.map((item) => path.dirname(item))]);
+    const configPaths = packageRoots.flatMap((packageRoot) => [
+        ...discoverConfigPaths(packageRoot, TSCONFIG_GLOBS),
+        ...discoverConfigPaths(packageRoot, TEST_CONFIG_GLOBS),
+        ...discoverConfigPaths(packageRoot, LINT_CONFIG_GLOBS),
+    ]);
+    const directoryPaths = packageRoots.flatMap((packageRoot) => ALL_MARKED_DIRS.map((item) => path.resolve(packageRoot, item)));
+    const candidates = uniqueSorted([
+        ...ROOT_INPUTS.map((item) => path.join(root, item)),
+        ...manifestPaths,
+        ...configPaths,
+        ...directoryPaths,
+    ]);
+    return candidates.flatMap((item) => {
+        try {
+            const stat = statSync(item);
+            return [`${item}\0${stat.isDirectory() ? 'd' : 'f'}\0${stat.size}\0${stat.mtimeMs}`];
+        }
+        catch {
+            return [];
+        }
+    });
+}
+function sameSignatures(left, right) {
+    return left.length === right.length && left.every((item, index) => item === right[index]);
+}
+/**
+ * Build a safe, cached description of a package project. Manifests are parsed strictly as JSON;
+ * package scripts and configuration files are never imported or executed.
+ */
+export function discoverProjectProfile(projectRoot) {
+    const root = path.resolve(projectRoot);
+    const cached = cache.get(root);
+    if (cached) {
+        const current = inputSignatures(root, cached.workspacePatterns);
+        if (sameSignatures(current, cached.signatures))
+            return cached.profile;
+    }
+    const rootManifestPath = path.join(root, 'package.json');
+    const rootManifest = existsSync(rootManifestPath) ? readManifest(rootManifestPath) : {};
+    const pnpmFiles = ['pnpm-workspace.yaml', 'pnpm-workspace.yml']
+        .map((item) => path.join(root, item))
+        .filter((item) => existsSync(item));
+    const explicitPatterns = [
+        ...manifestWorkspacePatterns(rootManifest.workspaces),
+        ...pnpmFiles.flatMap((item) => pnpmWorkspacePatterns(item)),
+    ];
+    const workspacePatterns = uniqueSorted(explicitPatterns.length > 0 ? explicitPatterns : ['packages/*']);
+    const profile = {
+        root,
+        packageManager: detectPackageManager(root, rootManifest.packageManager),
+        workspaceConfigPaths: uniqueSorted([
+            ...(manifestWorkspacePatterns(rootManifest.workspaces).length > 0 ? [rootManifestPath] : []),
+            ...pnpmFiles,
+        ]),
+        workspacePatterns,
+        packages: discoverManifestPaths(root, workspacePatterns).map(createPackageProfile),
+    };
+    cache.set(root, { profile, workspacePatterns, signatures: inputSignatures(root, workspacePatterns) });
+    return profile;
+}
+/** Clear one cached project profile, or all profiles when no root is provided. */
+export function clearProjectProfileCache(projectRoot) {
+    if (projectRoot === undefined)
+        cache.clear();
+    else
+        cache.delete(path.resolve(projectRoot));
+}

package/dist/verification/types.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mocode-ai",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "description": "终端编码 agent:LLM + tool-call 循环 + 流式输出(含思考)+ 16 个工具,接任意 OpenAI 兼容后端。",
   "type": "module",
   "bin": {
@@ -20,7 +20,10 @@
   "scripts": {
     "start": "tsx src/index.ts",
     "build": "tsc -p tsconfig.build.json",
-    "typecheck": "tsc --noEmit",
+    "typecheck": "tsc --noEmit && tsc -p evals/tsconfig.json",
+    "eval:smoke": "tsx evals/smoke.ts && tsx evals/coding/smoke.ts",
+    "eval:coding": "tsx evals/coding/runner.ts",
+    "eval:coding:list": "tsx evals/coding/runner.ts --list",
     "prepare": "npm run build"
   },
   "dependencies": {