mocode-ai 0.7.1 → 0.7.2

package/dist/tools/resource-lock.js

@@ -0,0 +1,148 @@
+import { normalize } from 'node:path';
+import { jailResolve } from '../sandbox/index.js';
+function abortError() {
+    const error = new Error('Resource lock acquisition aborted');
+    error.name = 'AbortError';
+    return error;
+}
+function requestConflicts(a, b) {
+    if (a.scope === 'workspace' || b.scope === 'workspace') {
+        if (a.mode === 'write' || b.mode === 'write')
+            return true;
+        return false;
+    }
+    return a.key === b.key && (a.mode === 'write' || b.mode === 'write');
+}
+function claimsConflict(a, b) {
+    return a.requests.some((left) => b.requests.some((right) => requestConflicts(left, right)));
+}
+/** Fair, abort-aware multi-resource read/write lock shared by all agent loops. */
+export class ResourceLockManager {
+    active = new Set();
+    waiting = [];
+    acquire(requests, signal) {
+        if (signal?.aborted)
+            return Promise.reject(abortError());
+        const normalized = dedupeRequests(requests);
+        if (normalized.length === 0)
+            return Promise.resolve(() => undefined);
+        return new Promise((resolve, reject) => {
+            const waiter = { requests: normalized, resolve, reject, signal };
+            if (signal) {
+                waiter.onAbort = () => {
+                    const index = this.waiting.indexOf(waiter);
+                    if (index < 0)
+                        return;
+                    this.waiting.splice(index, 1);
+                    signal.removeEventListener('abort', waiter.onAbort);
+                    reject(abortError());
+                    this.dispatch();
+                };
+                signal.addEventListener('abort', waiter.onAbort, { once: true });
+            }
+            this.waiting.push(waiter);
+            this.dispatch();
+        });
+    }
+    async withLocks(requests, signal, action) {
+        const release = await this.acquire(requests, signal);
+        try {
+            return await action();
+        }
+        finally {
+            release();
+        }
+    }
+    dispatch() {
+        const blocked = [];
+        for (let index = 0; index < this.waiting.length;) {
+            const waiter = this.waiting[index];
+            const conflictsActive = [...this.active].some((claim) => claimsConflict(waiter, claim));
+            const conflictsEarlier = blocked.some((claim) => claimsConflict(waiter, claim));
+            if (conflictsActive || conflictsEarlier) {
+                blocked.push(waiter);
+                index++;
+                continue;
+            }
+            this.waiting.splice(index, 1);
+            if (waiter.onAbort)
+                waiter.signal?.removeEventListener('abort', waiter.onAbort);
+            const claim = { requests: waiter.requests };
+            this.active.add(claim);
+            let released = false;
+            waiter.resolve(() => {
+                if (released)
+                    return;
+                released = true;
+                this.active.delete(claim);
+                this.dispatch();
+            });
+        }
+    }
+}
+function dedupeRequests(requests) {
+    const byKey = new Map();
+    for (const request of requests) {
+        const identity = `${request.scope}:${request.key}`;
+        const existing = byKey.get(identity);
+        if (!existing || request.mode === 'write')
+            byKey.set(identity, request);
+    }
+    return [...byKey.values()].sort((a, b) => `${a.scope}:${a.key}`.localeCompare(`${b.scope}:${b.key}`));
+}
+/** Stable lock identity: sandbox realpath plus Windows case/separator normalization. */
+export function canonicalFileResourceKey(input) {
+    let canonical = normalize(jailResolve(input));
+    if (process.platform === 'win32')
+        canonical = canonical.toLowerCase();
+    return `file:${canonical}`;
+}
+function modeFor(effect) {
+    return effect === 'read' ? 'read' : 'write';
+}
+const workspaceWrite = () => [{
+        key: 'workspace',
+        scope: 'workspace',
+        mode: 'write',
+    }];
+/** Resolve declared logical resources. Any ambiguity fails closed to a workspace write lock. */
+export function resolveResourceLockRequests(capabilities, args) {
+    if (capabilities.delegatesResourceLocks)
+        return [];
+    if (capabilities.effect === 'process' || capabilities.effect === 'unknown') {
+        return workspaceWrite();
+    }
+    let keys;
+    try {
+        keys = capabilities.resources?.(args) ?? [];
+    }
+    catch {
+        return workspaceWrite();
+    }
+    if (keys.length === 0) {
+        return capabilities.effect === 'network' ? [] : workspaceWrite();
+    }
+    const mode = modeFor(capabilities.effect);
+    const requests = [];
+    try {
+        for (const key of keys) {
+            if (typeof key !== 'string' || key.trim().length === 0)
+                return workspaceWrite();
+            if (key === 'workspace') {
+                requests.push({ key, scope: 'workspace', mode });
+            }
+            else if (key.startsWith('file:') && key.length > 5) {
+                requests.push({ key: canonicalFileResourceKey(key.slice(5)), scope: 'resource', mode });
+            }
+            else {
+                // Non-file logical resources are still lockable, but never treated as filesystem paths.
+                requests.push({ key, scope: 'resource', mode });
+            }
+        }
+    }
+    catch {
+        return workspaceWrite();
+    }
+    return dedupeRequests(requests);
+}
+export const toolResourceLockManager = new ResourceLockManager();

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

@@ -1,7 +1,8 @@
 import { existsSync } from 'node:fs';
 import path from 'node:path';
 import { discoverProjectProfile } from './profile.js';
-const SCRIPT_PRIORITY = ['typecheck', 'test', 'build'];
+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);
@@ -10,11 +11,7 @@ function samePath(left, right) {
         ? normalizedLeft.toLowerCase() === normalizedRight.toLowerCase()
         : normalizedLeft === normalizedRight;
 }
-/** Discover one lowest-cost validation command for a package in a project profile. */
-export function discoverPackageValidationCommand(profile, packageProfile) {
-    const script = SCRIPT_PRIORITY.find((name) => typeof packageProfile.scripts[name] === 'string');
-    if (!script)
-        return null;
+function commandFor(profile, packageProfile, script) {
     return {
         script,
         command: `${profile.packageManager} run ${script}`,
@@ -22,6 +19,17 @@ export function discoverPackageValidationCommand(profile, packageProfile) {
         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);

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) : '',
+    }));
+}