ast-mcp-server 0.5.1 → 0.7.0

package/dist/services/agent-setup.js

@@ -4,27 +4,9 @@ import { access, realpath, stat } from "node:fs/promises";
 import path from "node:path";
 import process from "node:process";
 import { installBundledSkill, SkillConflictError, } from "./skill-installer.js";
-import { AGENT_IDS } from "./setup-wizard.js";
-const MCP_SERVER_NAME = "ast";
+import { AGENT_IDS, getAgentTarget, MCP_SERVER_NAME, } from "./agent-targets.js";
 const DEFAULT_COMMAND_TIMEOUT_MS = 120_000;
 const MAX_COMMAND_OUTPUT_BYTES = 1024 * 1024;
-const EXPECTED_HERMES_TOOLS = [
-    "ast_list_files",
-    "ast_get_outline",
-    "ast_get_symbol_source",
-    "ast_search_symbols",
-    "ast_find_references",
-    "ast_get_diagnostics",
-    "ast_rename_symbol",
-    "ast_replace_symbol_body",
-    "ast_scaffold_class",
-    "ast_get_operation_preview",
-    "ast_apply_operation",
-];
-const AGENT_DEFINITIONS = {
-    claude: { label: "Claude Code", command: "claude" },
-    hermes: { label: "Hermes", command: "hermes" },
-};
 export class AgentSetupError extends Error {
     code;
     details;
@@ -128,102 +110,44 @@ async function runCommand(executable, args, options) {
 }
 function commandFailure(agent, operation, result) {
     const output = `${result.stdout}\n${result.stderr}`.trim().slice(0, 4000);
-    return new AgentSetupError(`${AGENT_DEFINITIONS[agent].label} ${operation} failed with exit code ${result.exitCode}.`, "AGENT_COMMAND_FAILED", { agent, operation, output });
+    return new AgentSetupError(`${getAgentTarget(agent).label} ${operation} failed with exit code ${result.exitCode}.`, "AGENT_COMMAND_FAILED", { agent, operation, output });
 }
-function isMissingClaudeMcp(output) {
-    return (/\bno\s+mcp\s+server\b/i.test(output) &&
-        /(?:\bfound\b|\bnamed?\b)/i.test(output) &&
-        /\bast\b/i.test(output));
-}
-async function inspectClaudeMcp(detection, serverEntryPath, nodeExecutable, environment, timeoutMs) {
-    const result = await runCommand(detection.executable, ["mcp", "get", MCP_SERVER_NAME], {
-        environment,
-        timeoutMs,
-    });
-    const output = `${result.stdout}\n${result.stderr}`;
-    if (result.exitCode !== 0) {
-        if (isMissingClaudeMcp(output)) {
-            return { agent: "claude", status: "missing" };
-        }
-        throw commandFailure("claude", "MCP inspection", result);
-    }
-    const fields = new Map();
-    for (const line of result.stdout.split(/\r?\n/)) {
-        const match = line.match(/^\s*(Status|Type|Command|Args):\s*(.*)$/i);
-        if (match !== null) {
-            fields.set(match[1].toLowerCase(), match[2].trim());
-        }
-    }
-    const current = /connected/i.test(fields.get("status") ?? "") &&
-        fields.get("type")?.toLowerCase() === "stdio" &&
-        fields.get("command") === nodeExecutable &&
-        fields.get("args") === serverEntryPath;
-    return current
-        ? { agent: "claude", status: "current" }
-        : {
-            agent: "claude",
-            status: "conflict",
-            detail: "The existing user-scoped 'ast' registration does not match this package.",
-        };
-}
-async function inspectHermesMcp(detection, environment, timeoutMs) {
-    const listed = await runCommand(detection.executable, ["mcp", "list"], {
-        environment,
-        timeoutMs,
-    });
-    if (listed.exitCode !== 0) {
-        throw commandFailure("hermes", "MCP list", listed);
-    }
-    if (!/^\s*ast(?:\s|$)/im.test(listed.stdout)) {
-        return { agent: "hermes", status: "missing" };
-    }
-    const tested = await runCommand(detection.executable, ["mcp", "test", MCP_SERVER_NAME], {
-        environment,
-        timeoutMs,
-    });
-    const current = tested.exitCode === 0 && EXPECTED_HERMES_TOOLS.every((tool) => tested.stdout.includes(tool));
-    return current
-        ? { agent: "hermes", status: "current" }
-        : {
-            agent: "hermes",
-            status: "conflict",
-            detail: "The existing 'ast' registration does not expose the expected structural tools.",
-        };
+function targetRuntime(detection, environment, timeoutMs) {
+    return {
+        run: (args, input) => runCommand(detection.executable, [...args], {
+            environment,
+            timeoutMs,
+            input,
+        }),
+    };
 }
 async function inspectMcp(agent, detection, serverEntryPath, nodeExecutable, environment, timeoutMs) {
-    return agent === "claude"
-        ? inspectClaudeMcp(detection, serverEntryPath, nodeExecutable, environment, timeoutMs)
-        : inspectHermesMcp(detection, environment, timeoutMs);
-}
-async function configureClaudeMcp(detection, serverEntryPath, nodeExecutable, environment, timeoutMs) {
-    const added = await runCommand(detection.executable, [
-        "mcp",
-        "add",
-        "--scope",
-        "user",
-        "--transport",
-        "stdio",
-        MCP_SERVER_NAME,
-        "--",
-        nodeExecutable,
+    const target = getAgentTarget(agent);
+    const inspection = await target.mcp.inspect(targetRuntime(detection, environment, timeoutMs), {
         serverEntryPath,
-    ], { environment, timeoutMs });
-    if (added.exitCode !== 0) {
-        throw commandFailure("claude", "MCP registration", added);
-    }
-    const verified = await inspectClaudeMcp(detection, serverEntryPath, nodeExecutable, environment, timeoutMs);
-    if (verified.status !== "current") {
-        throw new AgentSetupError("Claude Code saved the MCP registration but verification did not match.", "AGENT_VERIFICATION_FAILED", { agent: "claude", inspection: verified });
+        nodeExecutable,
+    });
+    if (inspection.status === "error") {
+        throw commandFailure(agent, inspection.operation, inspection.result);
     }
+    return {
+        agent,
+        status: inspection.status,
+        ...(inspection.detail ? { detail: inspection.detail } : {}),
+    };
 }
-async function configureHermesMcp(detection, serverEntryPath, nodeExecutable, environment, timeoutMs) {
-    const added = await runCommand(detection.executable, ["mcp", "add", MCP_SERVER_NAME, "--command", nodeExecutable, "--args", serverEntryPath], { environment, timeoutMs, input: "\n" });
-    if (added.exitCode !== 0 || !/saved\s+'ast'/i.test(added.stdout)) {
-        throw commandFailure("hermes", "MCP registration", added);
+async function configureMcp(agent, detection, serverEntryPath, nodeExecutable, environment, timeoutMs) {
+    const target = getAgentTarget(agent);
+    const added = await target.mcp.register(targetRuntime(detection, environment, timeoutMs), {
+        serverEntryPath,
+        nodeExecutable,
+    });
+    if (!target.mcp.registrationAccepted(added)) {
+        throw commandFailure(agent, "MCP registration", added);
     }
-    const verified = await inspectHermesMcp(detection, environment, timeoutMs);
+    const verified = await inspectMcp(agent, detection, serverEntryPath, nodeExecutable, environment, timeoutMs);
     if (verified.status !== "current") {
-        throw new AgentSetupError("Hermes saved the MCP registration but verification did not expose the expected tools.", "AGENT_VERIFICATION_FAILED", { agent: "hermes", inspection: verified });
+        throw new AgentSetupError(`${target.label} saved the MCP registration but verification did not match.`, "AGENT_VERIFICATION_FAILED", { agent, inspection: verified });
     }
 }
 async function assertRegularFile(filePath, label) {
@@ -248,7 +172,7 @@ export async function detectInstalledAgents(options = {}) {
     const environment = options.environment ?? process.env;
     const timeoutMs = options.commandTimeoutMs ?? 5000;
     return Promise.all(AGENT_IDS.map(async (id) => {
-        const definition = AGENT_DEFINITIONS[id];
+        const definition = getAgentTarget(id);
         const executable = await findExecutable(definition.command, environment);
         if (executable === undefined) {
             return { id, label: definition.label, installed: false };
@@ -282,7 +206,7 @@ export async function runAgentSetup(options) {
     for (const agent of requested) {
         const detection = detectionMap.get(agent);
         if (!detection?.installed || detection.executable === undefined) {
-            throw new AgentSetupError(`${AGENT_DEFINITIONS[agent].label} is not installed or is not available in PATH.`, "AGENT_NOT_INSTALLED", { agent });
+            throw new AgentSetupError(`${getAgentTarget(agent).label} is not installed or is not available in PATH.`, "AGENT_NOT_INSTALLED", { agent });
         }
     }
     await assertRegularFile(options.serverEntryPath, "MCP server entrypoint");
@@ -290,9 +214,9 @@ export async function runAgentSetup(options) {
     const inspections = await Promise.all(requested.map((agent) => inspectMcp(agent, detectionMap.get(agent), options.serverEntryPath, nodeExecutable, environment, timeoutMs)));
     const conflict = inspections.find((item) => item.status === "conflict");
     if (conflict !== undefined) {
-        throw new AgentSetupError(`Conflicting ${AGENT_DEFINITIONS[conflict.agent].label} MCP registration: ${conflict.detail}`, "AGENT_MCP_CONFLICT", { agent: conflict.agent });
+        throw new AgentSetupError(`Conflicting ${getAgentTarget(conflict.agent).label} MCP registration: ${conflict.detail}`, "AGENT_MCP_CONFLICT", { agent: conflict.agent });
     }
-    const skillTarget = requested.length === 2 ? "all" : requested[0];
+    const skillTarget = requested.length === AGENT_IDS.length ? "all" : getAgentTarget(requested[0]).skillTarget;
     const skillResult = await installBundledSkill({
         target: skillTarget,
         scope: "user",
@@ -312,12 +236,7 @@ export async function runAgentSetup(options) {
         const inspection = inspections.find((item) => item.agent === agent);
         try {
             if (inspection.status === "missing") {
-                if (agent === "claude") {
-                    await configureClaudeMcp(detection, options.serverEntryPath, nodeExecutable, environment, timeoutMs);
-                }
-                else {
-                    await configureHermesMcp(detection, options.serverEntryPath, nodeExecutable, environment, timeoutMs);
-                }
+                await configureMcp(agent, detection, options.serverEntryPath, nodeExecutable, environment, timeoutMs);
             }
             completed.push({
                 agent,

package/dist/services/agent-targets.js

@@ -0,0 +1,122 @@
+export const MCP_SERVER_NAME = "ast";
+const EXPECTED_HERMES_TOOLS = [
+    "ast_list_files",
+    "ast_get_outline",
+    "ast_get_symbol_source",
+    "ast_search_symbols",
+    "ast_find_references",
+    "ast_get_diagnostics",
+    "ast_rename_symbol",
+    "ast_replace_symbol_body",
+    "ast_scaffold_class",
+    "ast_get_operation_preview",
+    "ast_apply_operation",
+];
+function isMissingClaudeMcp(output) {
+    return (/\bno\s+mcp\s+server\b/i.test(output) &&
+        /(?:\bfound\b|\bnamed?\b)/i.test(output) &&
+        /\bast\b/i.test(output));
+}
+function inspectClaudeFields(stdout) {
+    const fields = new Map();
+    for (const line of stdout.split(/\r?\n/)) {
+        const match = line.match(/^\s*(Status|Type|Command|Args):\s*(.*)$/i);
+        if (match !== null)
+            fields.set(match[1].toLowerCase(), match[2].trim());
+    }
+    return fields;
+}
+const claudeMcp = {
+    async inspect(runtime, context) {
+        const result = await runtime.run(["mcp", "get", MCP_SERVER_NAME]);
+        const output = `${result.stdout}\n${result.stderr}`;
+        if (result.exitCode !== 0) {
+            return isMissingClaudeMcp(output)
+                ? { status: "missing" }
+                : { status: "error", operation: "MCP inspection", result };
+        }
+        const fields = inspectClaudeFields(result.stdout);
+        const current = /connected/i.test(fields.get("status") ?? "") &&
+            fields.get("type")?.toLowerCase() === "stdio" &&
+            fields.get("command") === context.nodeExecutable &&
+            fields.get("args") === context.serverEntryPath;
+        return current
+            ? { status: "current" }
+            : {
+                status: "conflict",
+                detail: "The existing user-scoped 'ast' registration does not match this package.",
+            };
+    },
+    register(runtime, context) {
+        return runtime.run([
+            "mcp",
+            "add",
+            "--scope",
+            "user",
+            "--transport",
+            "stdio",
+            MCP_SERVER_NAME,
+            "--",
+            context.nodeExecutable,
+            context.serverEntryPath,
+        ]);
+    },
+    registrationAccepted(result) {
+        return result.exitCode === 0;
+    },
+};
+const hermesMcp = {
+    async inspect(runtime) {
+        const listed = await runtime.run(["mcp", "list"]);
+        if (listed.exitCode !== 0) {
+            return { status: "error", operation: "MCP list", result: listed };
+        }
+        if (!/^\s*ast(?:\s|$)/im.test(listed.stdout))
+            return { status: "missing" };
+        const tested = await runtime.run(["mcp", "test", MCP_SERVER_NAME]);
+        const current = tested.exitCode === 0 && EXPECTED_HERMES_TOOLS.every((tool) => tested.stdout.includes(tool));
+        return current
+            ? { status: "current" }
+            : {
+                status: "conflict",
+                detail: "The existing 'ast' registration does not expose the expected structural tools.",
+            };
+    },
+    register(runtime, context) {
+        return runtime.run([
+            "mcp",
+            "add",
+            MCP_SERVER_NAME,
+            "--command",
+            context.nodeExecutable,
+            "--args",
+            context.serverEntryPath,
+        ], "\n");
+    },
+    registrationAccepted(result) {
+        return result.exitCode === 0 && /saved\s+'ast'/i.test(result.stdout);
+    },
+};
+export const AGENT_TARGETS = [
+    {
+        id: "claude",
+        label: "Claude Code",
+        command: "claude",
+        skillTarget: "claude",
+        mcp: claudeMcp,
+    },
+    {
+        id: "hermes",
+        label: "Hermes",
+        command: "hermes",
+        skillTarget: "hermes",
+        mcp: hermesMcp,
+    },
+];
+export const AGENT_IDS = AGENT_TARGETS.map((target) => target.id);
+export function getAgentTarget(id) {
+    const target = AGENT_TARGETS.find((candidate) => candidate.id === id);
+    if (target === undefined)
+        throw new Error(`Unsupported agent target: ${id}`);
+    return target;
+}

package/dist/services/context-builder.js

@@ -0,0 +1,262 @@
+import { Buffer } from "node:buffer";
+import path from "node:path";
+import { buildFileOutline, nodeSourceWithLocation } from "./outline.js";
+import { paginate } from "./pagination.js";
+import { isCooperativeInterruption, NO_REQUEST_CONTEXT, } from "./request-context.js";
+import { findDeclarationByName, getSourceFileOrThrow, reportSymbolIndexFailure, } from "./project.js";
+import { collectSymbolReferences } from "./references.js";
+import { searchProjectSymbolsPage, searchProjectSymbolsPageWithIndex, sourceFileSymbols, symbolMatchRank, } from "./symbols.js";
+export const EXPLORE_DEFAULT_LIMIT = 20;
+export const EXPLORE_DEFAULT_REFERENCE_LIMIT = 20;
+export const EXPLORE_DEFAULT_MAX_BYTES = 64 * 1024;
+export const EXPLORE_MAX_BYTES = 1024 * 1024;
+function matchesQuery(record, query) {
+    const normalizedQuery = query.toLowerCase();
+    return (record.name.toLowerCase().includes(normalizedQuery) ||
+        record.symbol_path.toLowerCase().includes(normalizedQuery) ||
+        record.selector.toLowerCase().includes(normalizedQuery));
+}
+function sortRecords(records, query) {
+    return records.sort((left, right) => {
+        if (query) {
+            const rank = symbolMatchRank(query, {
+                symbolPath: left.symbol_path,
+                name: left.name,
+                line: left.line,
+            }) -
+                symbolMatchRank(query, {
+                    symbolPath: right.symbol_path,
+                    name: right.name,
+                    line: right.line,
+                });
+            if (rank !== 0)
+                return rank;
+        }
+        return (left.file.localeCompare(right.file) ||
+            left.line - right.line ||
+            left.symbol_path.localeCompare(right.symbol_path) ||
+            left.kind.localeCompare(right.kind));
+    });
+}
+function recordFromOutlineSymbol(sourceFile, projectRoot, symbol) {
+    return {
+        file: path.relative(projectRoot, sourceFile.getFilePath()).replaceAll("\\", "/"),
+        symbol_path: symbol.symbolPath,
+        selector: `${symbol.symbolPath}@${symbol.startLine}`,
+        name: symbol.name,
+        kind: symbol.kind,
+        line: symbol.startLine,
+        signature: symbol.signature,
+    };
+}
+function fileRecords(sourceFile, projectRoot, requestContext) {
+    const outline = buildFileOutline(sourceFile, requestContext);
+    if (outline.symbols.length > 0) {
+        return outline.symbols.map((symbol) => recordFromOutlineSymbol(sourceFile, projectRoot, symbol));
+    }
+    return sourceFileSymbols(sourceFile, projectRoot, requestContext);
+}
+async function projectRecords(context, request, requestContext) {
+    const { project, projectRoot } = context;
+    if (request.filePath) {
+        const sourceFile = getSourceFileOrThrow(project, request.filePath);
+        const file = path.relative(projectRoot, sourceFile.getFilePath()).replaceAll("\\", "/");
+        const requestedSymbolPath = request.symbolPath;
+        if (requestedSymbolPath) {
+            const node = findDeclarationByName(sourceFile, requestedSymbolPath);
+            const record = fileRecords(sourceFile, projectRoot, requestContext).find((candidate) => candidate.symbol_path === requestedSymbolPath ||
+                candidate.selector === requestedSymbolPath ||
+                (candidate.symbol_path === requestedSymbolPath.split("@")[0] &&
+                    candidate.line === node.getStartLineNumber()));
+            if (!record) {
+                throw new Error(`Symbol "${requestedSymbolPath}" could not be projected from ${file}.`);
+            }
+            return {
+                context,
+                route: "symbol",
+                file,
+                symbol: record.selector,
+                records: [record],
+            };
+        }
+        const records = fileRecords(sourceFile, projectRoot, requestContext)
+            .filter((record) => !request.query || matchesQuery(record, request.query))
+            .filter((record) => !request.kinds || request.kinds.includes(record.kind));
+        return {
+            context,
+            route: "file",
+            file,
+            symbol: null,
+            records: sortRecords(records, request.query),
+        };
+    }
+    if (!request.query) {
+        throw new Error("ast_explore requires query, file_path, or both file_path and symbol_path.");
+    }
+    let effectiveContext = context;
+    const indexedPage = await searchProjectSymbolsPageWithIndex(project, projectRoot, context.status.project, context.symbolIndex, context.symbolIndexReady, {
+        query: request.query,
+        kinds: request.kinds,
+        fileFilter: request.fileFilter,
+    }, request.offset, request.limit, async (reason) => {
+        effectiveContext = (await reportSymbolIndexFailure(projectRoot, reason)) ?? effectiveContext;
+    }, requestContext);
+    return {
+        context: effectiveContext,
+        route: "query",
+        file: null,
+        symbol: null,
+        page: indexedPage ??
+            searchProjectSymbolsPage(effectiveContext.project, effectiveContext.projectRoot, {
+                query: request.query,
+                kinds: request.kinds,
+                fileFilter: request.fileFilter,
+            }, request.offset, request.limit, requestContext),
+        records: [],
+    };
+}
+function projectSymbol(detail, record) {
+    const base = { file: record.file, selector: record.selector, kind: record.kind };
+    if (detail === "selectors")
+        return base;
+    if (detail === "summary" || detail === "context") {
+        return { ...base, signature: record.signature };
+    }
+    return {
+        ...base,
+        symbol_path: record.symbol_path,
+        name: record.name,
+        line: record.line,
+        signature: record.signature,
+    };
+}
+function jsonBytes(value) {
+    return Buffer.byteLength(JSON.stringify(value), "utf8");
+}
+function effectiveExpansion(request) {
+    return {
+        source: request.includeSource ?? (request.detail === "context" || request.detail === "full"),
+        references: request.includeReferences ?? request.detail === "full",
+    };
+}
+export async function buildExploreContext(context, request, requestContext = NO_REQUEST_CONTEXT) {
+    requestContext.checkpoint();
+    const routed = await projectRecords(context, request, requestContext);
+    requestContext.checkpoint();
+    const effectiveContext = routed.context;
+    const page = routed.page ?? paginate(routed.records, request.offset, request.limit);
+    const expansion = effectiveExpansion(request);
+    const unresolved = [];
+    const evidence = [];
+    for (const record of page.items) {
+        requestContext.checkpoint();
+        let sourceFile;
+        try {
+            sourceFile = getSourceFileOrThrow(effectiveContext.project, record.file);
+        }
+        catch {
+            unresolved.push({ selector: record.selector, reason: "source_unresolved" });
+            continue;
+        }
+        let node;
+        try {
+            node = findDeclarationByName(sourceFile, record.selector);
+        }
+        catch {
+            unresolved.push({ selector: record.selector, reason: "source_unresolved" });
+            continue;
+        }
+        let source;
+        let references;
+        if (expansion.source) {
+            source = nodeSourceWithLocation(node, effectiveContext.projectRoot, requestContext);
+        }
+        if (expansion.references) {
+            try {
+                references = collectSymbolReferences(node, effectiveContext.projectRoot, record.selector, true, request.referenceDetail, 0, request.referenceLimit, requestContext);
+            }
+            catch (error) {
+                if (isCooperativeInterruption(error))
+                    throw error;
+                unresolved.push({ selector: record.selector, reason: "references_unresolved" });
+            }
+        }
+        if (source || references) {
+            evidence.push({
+                selector: record.selector,
+                ...(source ? { source } : {}),
+                ...(references ? { references } : {}),
+            });
+        }
+    }
+    const symbols = page.items.map((record) => projectSymbol(request.detail, record));
+    let returnedSymbols = [...symbols];
+    let returnedEvidence = [...evidence];
+    let reason = page.has_more ? "record_limit" : null;
+    let result = createResult(effectiveContext, request, routed.route, routed.file, routed.symbol, returnedSymbols, returnedEvidence, page.total, unresolved, reason);
+    while (jsonBytes(result) > request.maxBytes &&
+        (returnedEvidence.length > 0 || returnedSymbols.length > 0)) {
+        requestContext.checkpoint();
+        reason = "byte_limit";
+        if (returnedEvidence.length > 0) {
+            returnedEvidence = returnedEvidence.slice(0, -1);
+        }
+        else {
+            returnedSymbols = returnedSymbols.slice(0, -1);
+            const selectors = new Set(returnedSymbols.map((symbol) => symbol.selector));
+            returnedEvidence = returnedEvidence.filter((item) => selectors.has(item.selector));
+        }
+        result = createResult(effectiveContext, request, routed.route, routed.file, routed.symbol, returnedSymbols, returnedEvidence, page.total, unresolved, reason);
+    }
+    requestContext.checkpoint();
+    const usedBytes = jsonBytes(result);
+    return {
+        ...result,
+        budget: { ...result.budget, used_bytes: usedBytes },
+    };
+}
+function createResult(context, request, route, file, symbol, symbols, evidence, total, unresolved, reason) {
+    const hasMore = request.offset + symbols.length < total;
+    const nextOffset = hasMore ? request.offset + symbols.length : null;
+    const expansion = effectiveExpansion(request);
+    const evidenceComplete = unresolved.length === 0 &&
+        evidence.length >= (expansion.source || expansion.references ? symbols.length : 0);
+    const symbolsComplete = !hasMore;
+    return {
+        route,
+        query: request.query ?? null,
+        file,
+        symbol,
+        detail: request.detail,
+        symbols,
+        evidence,
+        offset: request.offset,
+        limit: request.limit,
+        total,
+        has_more: hasMore,
+        next_offset: nextOffset,
+        freshness: {
+            state: context.status.state,
+            causes: context.status.causes,
+            checked_at: context.status.lastSuccessfulSyncAt,
+        },
+        completeness: {
+            complete: symbolsComplete && evidenceComplete,
+            symbols_complete: symbolsComplete,
+            evidence_complete: evidenceComplete,
+            unresolved,
+        },
+        budget: {
+            max_records: request.limit,
+            max_bytes: request.maxBytes,
+            max_depth: null,
+            max_edges: null,
+            max_invocations: 1,
+            used_bytes: 0,
+        },
+        truncation: {
+            truncated: reason !== null || hasMore,
+            reason: reason ?? (hasMore ? "record_limit" : null),
+        },
+    };
+}

package/dist/services/diagnostics.js

@@ -1,6 +1,8 @@
 import path from "node:path";
 import { DiagnosticCategory, ts } from "ts-morph";
-export function normalizeDiagnostic(diagnostic, projectRoot) {
+import { NO_REQUEST_CONTEXT } from "./request-context.js";
+export function normalizeDiagnostic(diagnostic, projectRoot, requestContext = NO_REQUEST_CONTEXT) {
+    requestContext.checkpoint();
     const sourceFile = diagnostic.getSourceFile();
     const start = diagnostic.getStart();
     const location = sourceFile && start !== undefined ? sourceFile.getLineAndColumnAtPos(start) : undefined;
@@ -21,14 +23,16 @@ function identity(diagnostic) {
         diagnostic.message,
     ]);
 }
-function subtract(candidates, baseline) {
+function subtract(candidates, baseline, requestContext) {
     const counts = new Map();
     for (const diagnostic of baseline) {
+        requestContext.checkpoint();
         const key = identity(diagnostic);
         counts.set(key, (counts.get(key) ?? 0) + 1);
     }
     const difference = [];
     for (const diagnostic of candidates) {
+        requestContext.checkpoint();
         const key = identity(diagnostic);
         const remaining = counts.get(key) ?? 0;
         if (remaining > 0) {
@@ -40,9 +44,10 @@ function subtract(candidates, baseline) {
     }
     return difference;
 }
-export function compareDiagnostics(before, after) {
-    const added = subtract(after, before);
-    const removed = subtract(before, after);
+export function compareDiagnostics(before, after, requestContext = NO_REQUEST_CONTEXT) {
+    requestContext.checkpoint();
+    const added = subtract(after, before, requestContext);
+    const removed = subtract(before, after, requestContext);
     return {
         added,
         removed,