mocode-ai 0.7.1 → 0.7.3

package/dist/tools/registry.js

@@ -1,6 +1,9 @@
 import { builtinTools } from './builtins/index.js';
 import { beginPathMutation, beginWorkspaceMutation, endPathMutation, endWorkspaceMutation, getCurrentTurnMutationState, } from '../rollback/index.js';
 import { enforceSandbox } from '../sandbox/index.js';
+import { resolveResourceLockRequests, toolResourceLockManager } from './resource-lock.js';
+import { executeWithToolRetry } from './retry.js';
+import { validateToolArguments } from './validation.js';
 import { t } from '../i18n/index.js';
 import { isToolErrorOutput } from './result.js';
 /**
@@ -66,7 +69,7 @@ function isStructuredOutcome(value) {
         typeof value.status === 'string' && typeof value.code === 'string' &&
         typeof value.retryable === 'boolean' && typeof value.output === 'string';
 }
-function normalizeOutcome(value, capabilities, durationMs, changedFiles) {
+function normalizeOutcome(value, durationMs, changedFiles) {
     if (isStructuredOutcome(value)) {
         return {
             ...value,
@@ -78,7 +81,8 @@ function normalizeOutcome(value, capabilities, durationMs, changedFiles) {
     return {
         status: failed ? 'error' : 'success',
         code: failed ? 'EXECUTION_ERROR' : 'OK',
-        retryable: failed && capabilities.retry !== 'never',
+        // Legacy string errors carry no transient classification and are never retried blindly.
+        retryable: false,
         output: value,
         changedFiles,
         durationMs,
@@ -94,6 +98,106 @@ function terminalOutcome(status, code, output, startedAt, changedFiles = []) {
         durationMs: Date.now() - startedAt,
     };
 }
+function isTransientExecutionError(error) {
+    if (!error || typeof error !== 'object')
+        return false;
+    const value = error;
+    if (value.name === 'AbortError' || value.name === 'APIUserAbortError')
+        return false;
+    if (value.status === 408 || value.status === 429 ||
+        (typeof value.status === 'number' && value.status >= 500))
+        return true;
+    if (['ETIMEDOUT', 'ECONNRESET', 'ENOTFOUND', 'EAI_AGAIN', 'ECONNREFUSED', 'EPIPE']
+        .includes(value.code ?? ''))
+        return true;
+    return value.name === 'APIConnectionError' ||
+        value.name === 'APIConnectionTimeoutError' ||
+        (typeof value.message === 'string' && /\btime(?:d)?\s*out\b|ETIMEDOUT/i.test(value.message));
+}
+function executionErrorOutcome(name, error, startedAt, changedFiles) {
+    const transient = isTransientExecutionError(error);
+    const value = error;
+    const timeout = transient && (value?.code === 'ETIMEDOUT' ||
+        value?.name === 'APIConnectionTimeoutError' ||
+        (error instanceof Error && /\btime(?:d)?\s*out\b|ETIMEDOUT/i.test(error.message)));
+    return {
+        status: 'error',
+        code: timeout ? 'TIMEOUT' : transient ? 'NETWORK_ERROR' : 'EXECUTION_ERROR',
+        retryable: transient,
+        output: t('toolError.execution', {
+            name,
+            message: error instanceof Error ? error.message : String(error),
+        }),
+        changedFiles,
+        durationMs: Date.now() - startedAt,
+    };
+}
+/** One complete attempt: acquire/release locks and capture rollback independently. */
+async function executeToolAttempt(tool, args, signal, opts, notifyLockAcquired) {
+    const startedAt = Date.now();
+    const capabilities = getToolCapabilities(tool);
+    let mutationVersionBefore;
+    let capturedPath;
+    try {
+        const requests = resolveResourceLockRequests(capabilities, args);
+        return await toolResourceLockManager.withLocks(requests, signal, async () => {
+            if (notifyLockAcquired)
+                opts?.onLockAcquired?.(args);
+            const mutationBefore = getCurrentTurnMutationState();
+            mutationVersionBefore = mutationBefore.version;
+            const pathCapture = isFileMutationTool(tool.name) && typeof args.path === 'string' && args.path
+                ? beginPathMutation(args.path)
+                : null;
+            capturedPath = pathCapture?.path;
+            const workspaceCapture = capabilities.effect === 'process' || capabilities.effect === 'unknown'
+                ? beginWorkspaceMutation()
+                : null;
+            let raw;
+            try {
+                raw = await tool.execute(args, { signal, dropContext: opts?.dropContext });
+            }
+            finally {
+                if (pathCapture)
+                    endPathMutation(pathCapture, tool.name);
+                if (workspaceCapture)
+                    endWorkspaceMutation(workspaceCapture, tool.name);
+            }
+            const mutationAfter = getCurrentTurnMutationState();
+            const changedFiles = mutationAfter.version !== mutationBefore.version
+                ? pathCapture
+                    ? mutationAfter.changedFiles.filter((item) => item.path === pathCapture.path).map((item) => item.path)
+                    : mutationAfter.changedFiles.map((item) => item.path)
+                : [];
+            if (signal?.aborted) {
+                return terminalOutcome('aborted', 'ABORTED', String(isStructuredOutcome(raw) ? raw.output : raw), startedAt, changedFiles);
+            }
+            return normalizeOutcome(raw, Date.now() - startedAt, changedFiles);
+        });
+    }
+    catch (error) {
+        const mutationAfter = getCurrentTurnMutationState();
+        const changedFiles = mutationVersionBefore !== undefined && mutationAfter.version !== mutationVersionBefore
+            ? capturedPath
+                ? mutationAfter.changedFiles.filter((item) => item.path === capturedPath).map((item) => item.path)
+                : mutationAfter.changedFiles.map((item) => item.path)
+            : [];
+        if (signal?.aborted || (error instanceof Error && error.name === 'AbortError')) {
+            return terminalOutcome('aborted', 'ABORTED', t('command.interrupted'), startedAt, changedFiles);
+        }
+        return executionErrorOutcome(tool.name, error, startedAt, changedFiles);
+    }
+}
+function stableJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map(stableJson).join(',')}]`;
+    if (value && typeof value === 'object') {
+        return `{${Object.entries(value)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, item]) => `${JSON.stringify(key)}:${stableJson(item)}`)
+            .join(',')}}`;
+    }
+    return JSON.stringify(value) ?? 'null';
+}
 /**
  * 结构化工具调度入口。永不抛错；旧字符串工具在此归一化为 ToolOutcome。
  * 权限仍由 Agent 在展示工具头之前预检，保持现有交互时序。
@@ -107,61 +211,32 @@ export async function executeToolOutcome(name, argsRaw, signal, opts) {
     if (!tool) {
         return terminalOutcome('error', 'UNKNOWN_TOOL', t('toolError.unknown', { name }), startedAt);
     }
-    let args;
+    let parsed;
     try {
-        args = argsRaw.trim() ? JSON.parse(argsRaw) : {};
+        parsed = argsRaw.trim() ? JSON.parse(argsRaw) : {};
     }
     catch {
         return terminalOutcome('error', 'INVALID_JSON', t('toolError.invalidJson', { name, arguments: argsRaw }), startedAt);
     }
+    const validation = validateToolArguments(tool, parsed);
+    if (!validation.valid) {
+        return terminalOutcome('error', validation.code, `错误:工具 ${name} 参数无效: ${validation.message}`, startedAt);
+    }
+    const args = parsed;
+    const fingerprint = `${name}\x00${stableJson(args)}`;
+    const sandboxError = enforceSandbox(name, args);
+    if (sandboxError) {
+        return terminalOutcome('denied', 'SANDBOX_DENIED', sandboxError, startedAt);
+    }
     const capabilities = getToolCapabilities(tool);
-    const mutationBefore = getCurrentTurnMutationState();
     try {
-        const sandboxError = enforceSandbox(name, args);
-        if (sandboxError) {
-            return terminalOutcome('denied', 'SANDBOX_DENIED', sandboxError, startedAt);
-        }
-        const pathCapture = isFileMutationTool(name) && typeof args.path === 'string' && args.path
-            ? beginPathMutation(args.path)
-            : null;
-        // 进程和未知扩展可能间接改动任意文件；已声明 write 的非文件工具自行管理其状态。
-        const workspaceCapture = capabilities.effect === 'process' || capabilities.effect === 'unknown'
-            ? beginWorkspaceMutation()
-            : null;
-        let raw;
-        try {
-            raw = await tool.execute(args, {
-                signal,
-                dropContext: opts?.dropContext,
-            });
-        }
-        finally {
-            if (pathCapture)
-                endPathMutation(pathCapture, name);
-            if (workspaceCapture)
-                endWorkspaceMutation(workspaceCapture, name);
-        }
-        const mutationAfter = getCurrentTurnMutationState();
-        const changedFiles = mutationAfter.version !== mutationBefore.version
-            ? mutationAfter.changedFiles.map((item) => item.path)
-            : [];
-        if (signal?.aborted) {
-            return terminalOutcome('aborted', 'ABORTED', String(isStructuredOutcome(raw) ? raw.output : raw), startedAt, changedFiles);
-        }
-        return normalizeOutcome(raw, capabilities, Date.now() - startedAt, changedFiles);
+        return await executeWithToolRetry(capabilities, fingerprint, signal, (attempt) => executeToolAttempt(tool, args, signal, opts, attempt === 1), opts?.onRetry);
     }
     catch (error) {
-        const mutationAfter = getCurrentTurnMutationState();
-        const changedFiles = mutationAfter.version !== mutationBefore.version
-            ? mutationAfter.changedFiles.map((item) => item.path)
-            : [];
         if (signal?.aborted || (error instanceof Error && error.name === 'AbortError')) {
-            return terminalOutcome('aborted', 'ABORTED', t('command.interrupted'), startedAt, changedFiles);
+            return terminalOutcome('aborted', 'ABORTED', t('command.interrupted'), startedAt);
         }
-        return terminalOutcome('error', 'EXECUTION_ERROR', t('toolError.execution', {
-            name,
-            message: error instanceof Error ? error.message : String(error),
-        }), startedAt, changedFiles);
+        return executionErrorOutcome(name, error, startedAt, []);
     }
 }
 /** 字符串兼容入口：现有调用方、TUI 和 LLM history 无需同步迁移。 */

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/tools/retry.js

@@ -0,0 +1,105 @@
+export const TOOL_RETRY_MAX_ATTEMPTS = 3;
+export const TOOL_RETRY_BASE_MS = 250;
+export const TOOL_RETRY_MAX_MS = 1_000;
+export const TOOL_RETRY_TOTAL_BUDGET_MS = 15_000;
+export const TOOL_RETRY_SAME_ARGS_WINDOW_MS = 60_000;
+export const TOOL_RETRY_SAME_ARGS_BUDGET = 2;
+const NEVER_RETRY_CODES = new Set([
+    'INVALID_JSON',
+    'INVALID_ARGUMENTS',
+    'INVALID_TOOL_SCHEMA',
+    'UNKNOWN_TOOL',
+    'SANDBOX_DENIED',
+    'PERMISSION_DENIED',
+    'TOOL_DISABLED',
+    'MODE_DENIED',
+    'ABORTED',
+    'EDIT_CONFLICT',
+    'POSTCONDITION_FAILED',
+    'PROCESS_FAILED',
+    'MCP_ERROR',
+]);
+const fingerprintBudgets = new Map();
+const MAX_TRACKED_FINGERPRINTS = 512;
+function reserveFingerprintRetry(fingerprint, now) {
+    let budget = fingerprintBudgets.get(fingerprint);
+    if (!budget || now - budget.startedAt >= TOOL_RETRY_SAME_ARGS_WINDOW_MS) {
+        budget = { startedAt: now, retries: 0 };
+        fingerprintBudgets.set(fingerprint, budget);
+    }
+    if (budget.retries >= TOOL_RETRY_SAME_ARGS_BUDGET)
+        return false;
+    budget.retries++;
+    if (fingerprintBudgets.size > MAX_TRACKED_FINGERPRINTS) {
+        const oldest = fingerprintBudgets.keys().next().value;
+        if (oldest)
+            fingerprintBudgets.delete(oldest);
+    }
+    return true;
+}
+function shouldRetry(outcome, capabilities) {
+    return capabilities.retry !== 'never' &&
+        outcome.status === 'error' &&
+        outcome.retryable === true &&
+        !NEVER_RETRY_CODES.has(outcome.code);
+}
+function backoff(attempt) {
+    return Math.min(TOOL_RETRY_MAX_MS, TOOL_RETRY_BASE_MS * 2 ** (attempt - 1));
+}
+function abortError() {
+    const error = new Error('Tool retry aborted');
+    error.name = 'AbortError';
+    return error;
+}
+function sleep(ms, signal) {
+    if (signal?.aborted)
+        return Promise.reject(abortError());
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            signal?.removeEventListener('abort', onAbort);
+            resolve();
+        }, ms);
+        const onAbort = () => {
+            clearTimeout(timer);
+            signal?.removeEventListener('abort', onAbort);
+            reject(abortError());
+        };
+        signal?.addEventListener('abort', onAbort, { once: true });
+    });
+}
+/** Retry safe/idempotent transient outcomes; each execute call owns one complete lock attempt. */
+export async function executeWithToolRetry(capabilities, fingerprint, signal, execute, onRetry) {
+    const startedAt = Date.now();
+    let retryDelayMs = 0;
+    for (let attempt = 1; attempt <= TOOL_RETRY_MAX_ATTEMPTS; attempt++) {
+        const outcome = await execute(attempt);
+        const elapsed = Date.now() - startedAt;
+        const waitMs = backoff(attempt);
+        const canRetry = attempt < TOOL_RETRY_MAX_ATTEMPTS &&
+            shouldRetry(outcome, capabilities) &&
+            elapsed + waitMs <= TOOL_RETRY_TOTAL_BUDGET_MS &&
+            !signal?.aborted &&
+            reserveFingerprintRetry(fingerprint, Date.now());
+        if (!canRetry) {
+            return {
+                ...outcome,
+                durationMs: elapsed,
+                attempts: attempt,
+                retryDelayMs,
+            };
+        }
+        try {
+            onRetry?.({ attempt, nextAttempt: attempt + 1, waitMs, code: outcome.code });
+        }
+        catch {
+            // Retry telemetry is best-effort and must never change tool execution.
+        }
+        await sleep(waitMs, signal);
+        retryDelayMs += waitMs;
+    }
+    throw new Error('unreachable tool retry state');
+}
+/** Test/session reset seam; production never needs to clear the bounded TTL map. */
+export function resetToolRetryBudgets() {
+    fingerprintBudgets.clear();
+}

package/dist/tools/validation.js

@@ -0,0 +1,80 @@
+import Ajv from 'ajv';
+import Ajv2020 from 'ajv/dist/2020.js';
+const options = {
+    allErrors: true,
+    strict: false,
+    coerceTypes: false,
+    useDefaults: false,
+    removeAdditional: false,
+    validateFormats: false,
+    allowUnionTypes: true,
+};
+const draft7 = new Ajv(options);
+const draft2020 = new Ajv2020(options);
+const cache = new WeakMap();
+function compile(schema) {
+    const cached = cache.get(schema);
+    if (cached)
+        return cached;
+    const preferred = typeof schema.$schema === 'string' && schema.$schema.includes('2020-12')
+        ? [draft2020, draft7]
+        : [draft7, draft2020];
+    let lastError;
+    for (const ajv of preferred) {
+        try {
+            const result = { valid: true, validate: ajv.compile(schema) };
+            cache.set(schema, result);
+            return result;
+        }
+        catch (error) {
+            lastError = error;
+        }
+    }
+    const result = {
+        valid: false,
+        message: lastError instanceof Error ? lastError.message : String(lastError),
+    };
+    cache.set(schema, result);
+    return result;
+}
+function formatErrors(errors) {
+    if (!errors?.length)
+        return '参数不符合 JSON Schema';
+    return errors.slice(0, 5).map((error) => {
+        const location = error.instancePath || '/';
+        if (error.keyword === 'required') {
+            const property = String(error.params.missingProperty ?? '?');
+            return `${location} 缺少必填字段 ${JSON.stringify(property)}`;
+        }
+        if (error.keyword === 'additionalProperties') {
+            const property = String(error.params.additionalProperty ?? '?');
+            return `${location} 含未知字段 ${JSON.stringify(property)}`;
+        }
+        return `${location} ${error.message ?? error.keyword}`;
+    }).join('; ');
+}
+/** Validate without coercing, defaulting, removing, or otherwise mutating model arguments. */
+export function validateToolArguments(tool, args) {
+    if (!args || typeof args !== 'object' || Array.isArray(args)) {
+        return {
+            valid: false,
+            code: 'INVALID_ARGUMENTS',
+            message: '参数根节点必须是 JSON object',
+        };
+    }
+    const compiled = compile(tool.parameters);
+    if (!compiled.valid) {
+        return {
+            valid: false,
+            code: 'INVALID_TOOL_SCHEMA',
+            message: `工具 schema 无法编译: ${compiled.message}`,
+        };
+    }
+    if (compiled.validate(args))
+        return { valid: true };
+    return {
+        valid: false,
+        code: 'INVALID_ARGUMENTS',
+        message: formatErrors(compiled.validate.errors),
+    };
+}

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