mocode-ai 0.7.0 → 0.7.2

package/dist/verification/affected.js

@@ -0,0 +1,149 @@
+import path from 'node:path';
+const isWindows = process.platform === 'win32';
+const ROOT_CONFIG_NAMES = new Set([
+    'package.json', 'pnpm-workspace.yaml', 'pnpm-workspace.yml',
+    'package-lock.json', 'pnpm-lock.yaml', 'yarn.lock', 'bun.lock', 'bun.lockb',
+]);
+function comparisonKey(value) {
+    const resolved = path.resolve(value);
+    return isWindows ? resolved.toLowerCase() : resolved;
+}
+function isInside(parent, child) {
+    const relative = path.relative(comparisonKey(parent), comparisonKey(child));
+    return relative === '' || (!relative.startsWith(`..${path.sep}`) && relative !== '..' && !path.isAbsolute(relative));
+}
+function toNativeSeparators(value) {
+    return value.replace(/[\\/]/g, path.sep);
+}
+function canonicalize(profile, input, base) {
+    if (!input.trim() || input.includes('\0'))
+        return { input, reason: 'invalid_path' };
+    try {
+        const absolute = path.resolve(base, toNativeSeparators(input));
+        if (!isInside(profile.root, absolute))
+            return { input, reason: 'outside_project' };
+        const relative = path.relative(profile.root, absolute);
+        return {
+            absolute,
+            key: comparisonKey(absolute),
+            display: relative === '' ? '.' : relative.split(path.sep).join('/'),
+        };
+    }
+    catch {
+        return { input, reason: 'invalid_path' };
+    }
+}
+function matchesAnyRoot(file, roots) {
+    return roots.some((root) => isInside(root, file));
+}
+function classify(file, owner) {
+    if (matchesAnyRoot(file, owner.fixtureRoots))
+        return 'fixture';
+    if (matchesAnyRoot(file, owner.generatedRoots))
+        return 'generated';
+    if (matchesAnyRoot(file, owner.vendorRoots))
+        return 'vendor';
+    if (matchesAnyRoot(file, owner.testRoots))
+        return 'test';
+    if (matchesAnyRoot(file, owner.sourceRoots))
+        return 'source';
+    return 'other';
+}
+function rootConfigReason(profile, file) {
+    const workspaceKeys = new Set(profile.workspaceConfigPaths.map(comparisonKey));
+    if (workspaceKeys.has(file.key))
+        return 'workspace_config_change';
+    const rootPackage = profile.packages.find((item) => comparisonKey(item.root) === comparisonKey(profile.root));
+    const configKeys = new Set([
+        ...(rootPackage?.tsconfigPaths ?? []),
+        ...(rootPackage?.testConfigPaths ?? []),
+        ...(rootPackage?.lintConfigPaths ?? []),
+    ].map(comparisonKey));
+    if (configKeys.has(file.key))
+        return 'root_config_change';
+    if (comparisonKey(path.dirname(file.absolute)) !== comparisonKey(profile.root))
+        return null;
+    const name = path.basename(file.absolute).toLowerCase();
+    if (ROOT_CONFIG_NAMES.has(name) || /^tsconfig(?:\..+)?\.json$/i.test(name)) {
+        return name.startsWith('pnpm-workspace') ? 'workspace_config_change' : 'root_config_change';
+    }
+    return null;
+}
+function addReason(selections, packageProfile, reason) {
+    const key = comparisonKey(packageProfile.root);
+    let selected = selections.get(key);
+    if (!selected) {
+        selected = { package: packageProfile, reasons: [] };
+        selections.set(key, selected);
+    }
+    if (!selected.reasons.some((item) => item.kind === reason.kind
+        && item.changedPath === reason.changedPath
+        && item.sourcePackage === reason.sourcePackage)) {
+        selected.reasons.push(reason);
+    }
+}
+/** Map changed paths to their longest matching package roots without touching the filesystem. */
+export function resolveAffectedPackages(profile, changedFiles, options) {
+    const canonicalByKey = new Map();
+    const rejected = [];
+    for (const input of changedFiles) {
+        const result = canonicalize(profile, input, path.resolve(options.changedFilesBase));
+        if ('reason' in result)
+            rejected.push(result);
+        else if (!canonicalByKey.has(result.key))
+            canonicalByKey.set(result.key, result);
+    }
+    const canonical = [...canonicalByKey.values()];
+    const packageByDepth = [...profile.packages].sort((left, right) => comparisonKey(right.root).length - comparisonKey(left.root).length);
+    const selections = new Map();
+    const unmatchedFiles = [];
+    let affectsAll = false;
+    for (const file of canonical) {
+        const configReason = rootConfigReason(profile, file);
+        if (configReason) {
+            affectsAll = true;
+            for (const packageProfile of profile.packages) {
+                addReason(selections, packageProfile, {
+                    kind: configReason,
+                    changedPath: file.display,
+                    classification: 'other',
+                });
+            }
+            continue;
+        }
+        const owner = packageByDepth.find((packageProfile) => isInside(packageProfile.root, file.absolute));
+        if (!owner) {
+            unmatchedFiles.push(file.display);
+            continue;
+        }
+        addReason(selections, owner, {
+            kind: 'direct_change',
+            changedPath: file.display,
+            classification: classify(file.absolute, owner),
+        });
+    }
+    if (!affectsAll && options.expandDependents && selections.size > 0) {
+        const direct = profile.packages.filter((item) => selections.has(comparisonKey(item.root)));
+        const sourcePackage = direct.map((item) => item.name).join(', ');
+        for (const expanded of options.expandDependents(direct, profile)) {
+            const packageProfile = profile.packages.find((item) => comparisonKey(item.root) === comparisonKey(expanded.root));
+            if (!packageProfile || selections.has(comparisonKey(packageProfile.root)))
+                continue;
+            addReason(selections, packageProfile, {
+                kind: 'dependent_change',
+                changedPath: canonical[0]?.display ?? '.',
+                classification: 'other',
+                sourcePackage,
+            });
+        }
+    }
+    return {
+        packages: profile.packages
+            .map((item) => selections.get(comparisonKey(item.root)))
+            .filter((item) => item !== undefined),
+        canonicalChangedFiles: canonical.map((item) => item.display),
+        rejected,
+        unmatchedFiles,
+        affectsAll,
+    };
+}

package/dist/verification/diagnostics.js

@@ -0,0 +1,108 @@
+import { createRequire } from 'node:module';
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+const SUPPORTED_EXTENSIONS = new Set([
+    '.ts', '.tsx', '.mts', '.cts', '.js', '.jsx', '.mjs', '.cjs',
+]);
+async function loadTypeScript(root) {
+    const candidates = [];
+    try {
+        candidates.push(createRequire(path.join(root, 'package.json')).resolve('typescript'));
+    }
+    catch {
+        // Target project may not depend on TypeScript; fall back to mocode's installation.
+    }
+    try {
+        candidates.push(createRequire(import.meta.url).resolve('typescript'));
+    }
+    catch {
+        // A production install may intentionally omit the optional parser.
+    }
+    for (const candidate of [...new Set(candidates)]) {
+        try {
+            const loaded = await import(pathToFileURL(candidate).href);
+            return loaded.default ?? loaded;
+        }
+        catch {
+            // Try the next resolution root.
+        }
+    }
+    return null;
+}
+function severity(category, ts) {
+    if (category === ts.DiagnosticCategory.Error)
+        return 'error';
+    if (category === ts.DiagnosticCategory.Warning)
+        return 'warning';
+    return 'info';
+}
+/** Parse only changed TS/JS files; package-wide semantic checking remains V3. */
+export async function runChangedFileDiagnostics(root, changedFiles, inputFingerprint) {
+    const startedAt = Date.now();
+    const files = [...new Set(changedFiles)]
+        .map((file) => path.resolve(process.cwd(), file))
+        .filter((file) => SUPPORTED_EXTENSIONS.has(path.extname(file).toLowerCase()));
+    if (files.length === 0) {
+        return {
+            level: 'V1', status: 'skipped', adapter: 'typescript-parser', diagnostics: [],
+            output: 'No changed TypeScript or JavaScript files.', durationMs: Date.now() - startedAt,
+            skipReason: 'unsupported_files', inputFingerprint,
+        };
+    }
+    const ts = await loadTypeScript(root);
+    if (!ts) {
+        return {
+            level: 'V1', status: 'skipped', adapter: 'typescript-parser', diagnostics: [],
+            output: 'TypeScript parser is unavailable.', durationMs: Date.now() - startedAt,
+            skipReason: 'typescript_unavailable', inputFingerprint,
+        };
+    }
+    const diagnostics = [];
+    for (const file of files) {
+        let source;
+        try {
+            source = await readFile(file, 'utf8');
+        }
+        catch (error) {
+            diagnostics.push({
+                level: 'V1', source: 'typescript', severity: 'error', code: 'READ_FAILED',
+                file: path.relative(root, file), message: error instanceof Error ? error.message : String(error),
+            });
+            continue;
+        }
+        const result = ts.transpileModule(source, {
+            fileName: file,
+            reportDiagnostics: true,
+            compilerOptions: {
+                allowJs: true,
+                jsx: ts.JsxEmit.Preserve,
+                module: ts.ModuleKind.ESNext,
+                target: ts.ScriptTarget.Latest,
+            },
+        });
+        for (const item of result.diagnostics ?? []) {
+            const location = item.file && item.start !== undefined
+                ? item.file.getLineAndCharacterOfPosition(item.start)
+                : undefined;
+            diagnostics.push({
+                level: 'V1',
+                source: 'typescript',
+                severity: severity(item.category, ts),
+                code: item.code,
+                file: item.file ? path.relative(root, item.file.fileName) : path.relative(root, file),
+                line: location ? location.line + 1 : undefined,
+                column: location ? location.character + 1 : undefined,
+                message: ts.flattenDiagnosticMessageText(item.messageText, '\n'),
+            });
+        }
+    }
+    const failed = diagnostics.some((item) => item.severity === 'error');
+    const output = diagnostics.length === 0
+        ? `Parsed ${files.length} changed TypeScript/JavaScript file(s).`
+        : diagnostics.map((item) => `${item.file ?? '<unknown>'}:${item.line ?? 0}:${item.column ?? 0} TS${item.code ?? ''} ${item.message}`).join('\n');
+    return {
+        level: 'V1', status: failed ? 'failed' : 'passed', adapter: 'typescript-parser',
+        diagnostics, output, durationMs: Date.now() - startedAt, inputFingerprint,
+    };
+}

package/dist/verification/discovery.js

@@ -0,0 +1,48 @@
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { discoverProjectProfile } from './profile.js';
+const COMPATIBILITY_PRIORITY = ['typecheck', 'test', 'build'];
+const LAYERED_ORDER = ['typecheck', 'build', 'test'];
+const isWindows = process.platform === 'win32';
+function samePath(left, right) {
+    const normalizedLeft = path.resolve(left);
+    const normalizedRight = path.resolve(right);
+    return isWindows
+        ? normalizedLeft.toLowerCase() === normalizedRight.toLowerCase()
+        : normalizedLeft === normalizedRight;
+}
+function commandFor(profile, packageProfile, script) {
+    return {
+        script,
+        command: `${profile.packageManager} run ${script}`,
+        packageManager: profile.packageManager,
+        cwd: packageProfile.root,
+    };
+}
+/** Discover every available V3 command in increasing-cost order. */
+export function discoverPackageValidationCommands(profile, packageProfile) {
+    return LAYERED_ORDER
+        .filter((script) => typeof packageProfile.scripts[script] === 'string')
+        .map((script) => commandFor(profile, packageProfile, script));
+}
+/** Compatibility API retained for callers that intentionally want one command. */
+export function discoverPackageValidationCommand(profile, packageProfile) {
+    const script = COMPATIBILITY_PRIORITY.find((name) => typeof packageProfile.scripts[name] === 'string');
+    return script ? commandFor(profile, packageProfile, script) : null;
+}
+/** Compatibility wrapper that discovers the root package validation command. */
+export function discoverValidationCommand(root) {
+    const resolvedRoot = path.resolve(root);
+    if (!existsSync(path.join(resolvedRoot, 'package.json'))) {
+        return { command: null, reason: 'no_package_json' };
+    }
+    try {
+        const profile = discoverProjectProfile(resolvedRoot);
+        const rootPackage = profile.packages.find((item) => samePath(item.root, resolvedRoot));
+        const command = rootPackage ? discoverPackageValidationCommand(profile, rootPackage) : null;
+        return command ? { command } : { command: null, reason: 'no_validation_script' };
+    }
+    catch {
+        return { command: null, reason: 'no_validation_script' };
+    }
+}

package/dist/verification/fingerprint.js

@@ -0,0 +1,54 @@
+import { createHash } from 'node:crypto';
+import { readFileSync, statSync } from 'node:fs';
+import path from 'node:path';
+function sha256(value) {
+    return createHash('sha256').update(value).digest('hex');
+}
+function normalizeText(value, root) {
+    const normalizedRoot = path.resolve(root).replace(/\\/g, '/');
+    return value
+        .replace(/\u001b\[[0-9;]*m/g, '')
+        .replace(/\\/g, '/')
+        .replaceAll(normalizedRoot, '<root>')
+        .replace(/\r\n?/g, '\n')
+        .trim();
+}
+/** Fingerprint the relevant on-disk inputs, so rewriting identical content can reuse validation. */
+export function fingerprintFiles(root, files) {
+    const entries = [...new Set(files)].sort().map((file) => {
+        const absolute = path.resolve(process.cwd(), file);
+        const display = path.relative(root, absolute).replace(/\\/g, '/');
+        try {
+            const stat = statSync(absolute);
+            if (!stat.isFile())
+                return `${display}\0<${stat.isDirectory() ? 'directory' : 'other'}>`;
+            return `${display}\0${sha256(readFileSync(absolute))}`;
+        }
+        catch {
+            return `${display}\0<missing>`;
+        }
+    });
+    return sha256(entries.join('\n'));
+}
+export function fingerprintValidation(input) {
+    const diagnostics = [...input.diagnostics]
+        .map((item) => ({
+        source: item.source,
+        severity: item.severity,
+        code: item.code ?? '',
+        file: item.file ? normalizeText(item.file, input.root) : '',
+        line: item.line ?? 0,
+        column: item.column ?? 0,
+        message: normalizeText(item.message, input.root),
+        packageName: item.packageName ?? '',
+    }))
+        .sort((left, right) => JSON.stringify(left).localeCompare(JSON.stringify(right)));
+    return sha256(JSON.stringify({
+        level: input.level ?? '',
+        status: input.status,
+        adapter: input.adapter ?? '',
+        command: input.command ? normalizeText(input.command, input.root) : '',
+        diagnostics,
+        output: diagnostics.length === 0 ? normalizeText(input.output ?? '', input.root) : '',
+    }));
+}