ast-mcp-server 0.13.0 → 0.14.0

package/dist/services/compiler-worker-protocol.js

@@ -1,11 +1,79 @@
 import { Buffer } from "node:buffer";
+export const COMPILER_WORKER_MAX_FRAME_BYTES = 256 * 1024;
+export const COMPILER_WORKER_MAX_REQUEST_ID_BYTES = 8 * 1024;
+export const COMPILER_WORKER_JSONRPC_ENVELOPE_RESERVE_BYTES = 16 * 1024;
+export const COMPILER_WORKER_MAX_RESULT_BYTES = COMPILER_WORKER_MAX_FRAME_BYTES - COMPILER_WORKER_JSONRPC_ENVELOPE_RESERVE_BYTES;
 const FIELDS = new Set(["v", "generation", "sequence", "type", "payload"]);
 const TYPES = new Set(["handshake", "snapshot", "shutdown", "ready", "settled", "lease", "exit"]);
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+export function isCompilerWorkerRequestIdWithinBudget(id) {
+    try {
+        return Buffer.byteLength(JSON.stringify(id)) <= COMPILER_WORKER_MAX_REQUEST_ID_BYTES;
+    }
+    catch {
+        return false;
+    }
+}
+export function fitsCompilerWorkerResponseResult(result) {
+    try {
+        const frame = JSON.stringify({
+            jsonrpc: "2.0",
+            id: "x".repeat(COMPILER_WORKER_MAX_REQUEST_ID_BYTES - 2),
+            result,
+        });
+        return Buffer.byteLength(frame) <= COMPILER_WORKER_MAX_FRAME_BYTES;
+    }
+    catch {
+        return false;
+    }
+}
+export function decodeCompilerWorkerResponse(frame) {
+    if (Buffer.byteLength(frame) > COMPILER_WORKER_MAX_FRAME_BYTES) {
+        return { ok: false, reason: "oversized" };
+    }
+    let value;
+    try {
+        value = JSON.parse(frame);
+    }
+    catch {
+        return { ok: false, reason: "malformed" };
+    }
+    if (!isRecord(value) || value.jsonrpc !== "2.0") {
+        return { ok: false, reason: "invalid_response" };
+    }
+    if (Object.hasOwn(value, "method") && !Object.hasOwn(value, "id")) {
+        if (typeof value.method !== "string" ||
+            Object.keys(value).some((key) => !["jsonrpc", "method", "params"].includes(key))) {
+            return { ok: false, reason: "invalid_notification" };
+        }
+        return { ok: true, kind: "notification", value };
+    }
+    if (Object.keys(value).some((key) => !["jsonrpc", "id", "result", "error"].includes(key))) {
+        return { ok: false, reason: "unknown_field" };
+    }
+    if (!(typeof value.id === "string" || typeof value.id === "number") ||
+        !isCompilerWorkerRequestIdWithinBudget(value.id)) {
+        return { ok: false, reason: "invalid_id" };
+    }
+    const hasResult = Object.hasOwn(value, "result");
+    const hasError = Object.hasOwn(value, "error");
+    if (hasResult === hasError)
+        return { ok: false, reason: "invalid_response" };
+    if (hasError) {
+        const error = value.error;
+        if (!isRecord(error) ||
+            typeof error.code !== "number" ||
+            !Number.isSafeInteger(error.code) ||
+            typeof error.message !== "string") {
+            return { ok: false, reason: "invalid_error" };
+        }
+    }
+    return { ok: true, kind: "response", value };
+}
 export function decodeCompilerWorkerEnvelope(frame) {
-    if (Buffer.byteLength(frame) > 256 * 1024) {
+    if (Buffer.byteLength(frame) > COMPILER_WORKER_MAX_FRAME_BYTES) {
         return { ok: false, reason: "oversized" };
     }
     let value;
@@ -47,7 +115,7 @@ export function validateInitializationReplay(frames) {
         "id" in notification) {
         return { ok: false, reason: "missing_replay" };
     }
-    if (Buffer.byteLength(JSON.stringify(frames)) > 256 * 1024) {
+    if (Buffer.byteLength(JSON.stringify(frames)) > COMPILER_WORKER_MAX_FRAME_BYTES) {
         return { ok: false, reason: "oversized_replay" };
     }
     return { ok: true, frames: [request, notification] };

package/dist/services/context-builder.js

@@ -167,7 +167,8 @@ export async function buildExploreContext(context, request, requestContext = NO_
             max_depth: request.callSpines.maxDepth,
             max_nodes: request.callSpines.maxNodes,
             max_edges: request.callSpines.maxEdges,
-            discovery_complete: !projected.incomplete,
+            discovery_complete: !projected.bounded_incomplete,
+            unfinished_gaps: projected.unfinished_gaps,
             freshness,
         });
     }

package/dist/services/diagnostics.js

@@ -56,20 +56,222 @@ export function buildDiagnosticAggregates(diagnostics, requestContext = NO_REQUE
         files: { ...files, unfiled_diagnostic_count: unfiled },
     };
 }
-export function normalizeDiagnostic(diagnostic, projectRoot, requestContext = NO_REQUEST_CONTEXT) {
+export function observeDiagnostic(diagnostic, projectRoot, ordinal = 0, requestContext = NO_REQUEST_CONTEXT) {
     requestContext.checkpoint();
     const sourceFile = diagnostic.getSourceFile();
-    const start = diagnostic.getStart();
-    const location = sourceFile && start !== undefined ? sourceFile.getLineAndColumnAtPos(start) : undefined;
+    const start = diagnostic.getStart() ?? null;
+    const length = diagnostic.getLength() ?? null;
+    const location = sourceFile && start !== null ? sourceFile.getLineAndColumnAtPos(start) : undefined;
     return {
-        code: diagnostic.getCode(),
-        category: DiagnosticCategory[diagnostic.getCategory()] ?? String(diagnostic.getCategory()),
-        file: sourceFile ? path.relative(projectRoot, sourceFile.getFilePath()) : null,
-        line: location?.line ?? null,
-        column: location?.column ?? null,
-        message: ts.flattenDiagnosticMessageText(diagnostic.compilerObject.messageText, "\n"),
+        public: {
+            code: diagnostic.getCode(),
+            category: DiagnosticCategory[diagnostic.getCategory()] ?? String(diagnostic.getCategory()),
+            file: sourceFile ? path.relative(projectRoot, sourceFile.getFilePath()) : null,
+            line: location?.line ?? null,
+            column: location?.column ?? null,
+            message: ts.flattenDiagnosticMessageText(diagnostic.compilerObject.messageText, "\n"),
+        },
+        start,
+        length,
+        ordinal,
     };
 }
+export function normalizeDiagnostic(diagnostic, projectRoot, requestContext = NO_REQUEST_CONTEXT) {
+    return observeDiagnostic(diagnostic, projectRoot, 0, requestContext).public;
+}
+const DEFAULT_EDIT_BUDGET = { frontierSteps: 1_000_000, traceCells: 250_000, hunks: 10_000 };
+const BUDGET_EXCEEDED = Symbol("edit-budget-exceeded");
+const EDIT_CHECKPOINT_INTERVAL = 4_096;
+function createEditWorkTracker(budget) {
+    return { budget, work: 0, traceCells: 0, hunks: 0, exhausted: false };
+}
+function exhaust(tracker) {
+    tracker.exhausted = true;
+    throw BUDGET_EXCEEDED;
+}
+function chargeWork(tracker, requestContext) {
+    if (tracker.exhausted || tracker.work >= tracker.budget.frontierSteps)
+        exhaust(tracker);
+    tracker.work += 1;
+    if (tracker.work % EDIT_CHECKPOINT_INTERVAL === 0)
+        requestContext.checkpoint();
+}
+function chargeTraceCell(tracker) {
+    if (tracker.exhausted || tracker.traceCells >= tracker.budget.traceCells)
+        exhaust(tracker);
+    tracker.traceCells += 1;
+}
+function chargeHunk(tracker, requestContext) {
+    chargeWork(tracker, requestContext);
+    if (tracker.hunks >= tracker.budget.hunks)
+        exhaust(tracker);
+    tracker.hunks += 1;
+}
+function coarseContext(oldLength, newLength, prefix, suffix) {
+    const runs = [];
+    if (prefix > 0)
+        runs.push({ oldStart: 0, oldEnd: prefix, newStart: 0, newEnd: prefix });
+    if (suffix > 0) {
+        runs.push({
+            oldStart: oldLength - suffix,
+            oldEnd: oldLength,
+            newStart: newLength - suffix,
+            newEnd: newLength,
+        });
+    }
+    return {
+        coarse: true,
+        runs,
+        hunks: [
+            {
+                oldStart: prefix,
+                oldEnd: oldLength - suffix,
+                newStart: prefix,
+                newEnd: newLength - suffix,
+            },
+        ],
+    };
+}
+function backtrack(trace, depth, oldLength, newLength, tracker, requestContext) {
+    const reversed = [];
+    let x = oldLength;
+    let y = newLength;
+    for (let d = depth; d > 0; d -= 1) {
+        requestContext.checkpoint();
+        const previous = trace[d - 1];
+        const diagonal = x - y;
+        const left = previous.get(diagonal - 1) ?? Number.NEGATIVE_INFINITY;
+        const right = previous.get(diagonal + 1) ?? Number.NEGATIVE_INFINITY;
+        const previousDiagonal = diagonal === -d || (diagonal !== d && left < right) ? diagonal + 1 : diagonal - 1;
+        const previousX = previous.get(previousDiagonal);
+        const previousY = previousX - previousDiagonal;
+        while (x > previousX && y > previousY) {
+            chargeWork(tracker, requestContext);
+            reversed.push("equal");
+            x -= 1;
+            y -= 1;
+        }
+        chargeWork(tracker, requestContext);
+        if (x === previousX) {
+            reversed.push("insert");
+            y -= 1;
+        }
+        else {
+            reversed.push("delete");
+            x -= 1;
+        }
+    }
+    while (x > 0 && y > 0) {
+        chargeWork(tracker, requestContext);
+        reversed.push("equal");
+        x -= 1;
+        y -= 1;
+    }
+    return reversed.reverse();
+}
+function emitContext(operations, prefix, tracker, requestContext) {
+    const runs = [];
+    const hunks = [];
+    let oldPosition = prefix;
+    let newPosition = prefix;
+    if (prefix > 0)
+        runs.push({ oldStart: 0, oldEnd: prefix, newStart: 0, newEnd: prefix });
+    for (let index = 0; index < operations.length;) {
+        requestContext.checkpoint();
+        const equal = operations[index] === "equal";
+        const oldStart = oldPosition;
+        const newStart = newPosition;
+        while (index < operations.length && (operations[index] === "equal") === equal) {
+            chargeWork(tracker, requestContext);
+            if (operations[index] !== "insert")
+                oldPosition += 1;
+            if (operations[index] !== "delete")
+                newPosition += 1;
+            index += 1;
+        }
+        const span = { oldStart, oldEnd: oldPosition, newStart, newEnd: newPosition };
+        if (equal)
+            runs.push(span);
+        else {
+            chargeHunk(tracker, requestContext);
+            hunks.push(span);
+        }
+    }
+    return { coarse: false, runs, hunks };
+}
+function buildEditContextWithTracker(oldText, newText, tracker, requestContext) {
+    requestContext.checkpoint();
+    let prefix = 0;
+    let suffix = 0;
+    try {
+        while (prefix < oldText.length && prefix < newText.length) {
+            chargeWork(tracker, requestContext);
+            if (oldText[prefix] !== newText[prefix])
+                break;
+            prefix += 1;
+        }
+        while (suffix < oldText.length - prefix && suffix < newText.length - prefix) {
+            chargeWork(tracker, requestContext);
+            if (oldText[oldText.length - suffix - 1] !== newText[newText.length - suffix - 1])
+                break;
+            suffix += 1;
+        }
+        if (prefix === oldText.length && prefix === newText.length) {
+            return {
+                coarse: false,
+                runs: prefix === 0 ? [] : [{ oldStart: 0, oldEnd: prefix, newStart: 0, newEnd: prefix }],
+                hunks: [],
+            };
+        }
+        const oldMiddle = oldText.slice(prefix, oldText.length - suffix);
+        const newMiddle = newText.slice(prefix, newText.length - suffix);
+        const trace = [];
+        let previous = new Map([[1, 0]]);
+        for (let depth = 0; depth <= oldMiddle.length + newMiddle.length; depth += 1) {
+            const current = new Map();
+            for (let diagonal = -depth; diagonal <= depth; diagonal += 2) {
+                requestContext.checkpoint();
+                chargeWork(tracker, requestContext);
+                chargeTraceCell(tracker);
+                const left = previous.get(diagonal - 1) ?? Number.NEGATIVE_INFINITY;
+                const right = previous.get(diagonal + 1) ?? Number.NEGATIVE_INFINITY;
+                let x = diagonal === -depth || (diagonal !== depth && left < right) ? right : left + 1;
+                let y = x - diagonal;
+                while (x < oldMiddle.length && y < newMiddle.length) {
+                    chargeWork(tracker, requestContext);
+                    if (oldMiddle[x] !== newMiddle[y])
+                        break;
+                    x += 1;
+                    y += 1;
+                }
+                current.set(diagonal, x);
+                if (x >= oldMiddle.length && y >= newMiddle.length) {
+                    trace.push(current);
+                    const context = emitContext(backtrack(trace, depth, oldMiddle.length, newMiddle.length, tracker, requestContext), prefix, tracker, requestContext);
+                    if (suffix > 0)
+                        context.runs.push({
+                            oldStart: oldText.length - suffix,
+                            oldEnd: oldText.length,
+                            newStart: newText.length - suffix,
+                            newEnd: newText.length,
+                        });
+                    return context;
+                }
+            }
+            trace.push(current);
+            previous = current;
+        }
+        throw new Error("Myers alignment did not terminate.");
+    }
+    catch (error) {
+        if (error !== BUDGET_EXCEEDED)
+            throw error;
+        return coarseContext(oldText.length, newText.length, prefix, suffix);
+    }
+}
+export function buildEditContext(oldText, newText, budget = DEFAULT_EDIT_BUDGET, requestContext = NO_REQUEST_CONTEXT) {
+    return buildEditContextWithTracker(oldText, newText, createEditWorkTracker(budget), requestContext);
+}
 function identity(diagnostic) {
     return JSON.stringify([
         diagnostic.code,
@@ -78,6 +280,88 @@ function identity(diagnostic) {
         diagnostic.message,
     ]);
 }
+function touchesHunk(start, length, hunks, side) {
+    const end = start + length;
+    return hunks.some((hunk) => {
+        const hunkStart = side === "old" ? hunk.oldStart : hunk.newStart;
+        const hunkEnd = side === "old" ? hunk.oldEnd : hunk.newEnd;
+        return end >= hunkStart && start <= hunkEnd;
+    });
+}
+function observationKey(observation, change, side) {
+    const diagnostic = observation.public;
+    if (diagnostic.file === null) {
+        return JSON.stringify([identity(diagnostic), diagnostic.line, diagnostic.column]);
+    }
+    if (!change) {
+        return JSON.stringify([identity(diagnostic), observation.start, observation.length]);
+    }
+    if (change.beforeText === null ||
+        change.afterText === null ||
+        observation.start === null ||
+        observation.length === null ||
+        !change.context ||
+        touchesHunk(observation.start, observation.length, change.context.hunks, side)) {
+        return null;
+    }
+    const run = change.context.runs.find((candidate) => {
+        const runStart = side === "old" ? candidate.oldStart : candidate.newStart;
+        const runEnd = side === "old" ? candidate.oldEnd : candidate.newEnd;
+        return observation.start >= runStart && observation.start + observation.length <= runEnd;
+    });
+    if (!run)
+        return null;
+    const mappedStart = side === "old" ? run.newStart + observation.start - run.oldStart : observation.start;
+    return JSON.stringify([identity(diagnostic), mappedStart, observation.length]);
+}
+export function compareObservedDiagnostics(before, after, changes, requestContext = NO_REQUEST_CONTEXT) {
+    requestContext.checkpoint();
+    const edits = new Map();
+    const tracker = createEditWorkTracker(DEFAULT_EDIT_BUDGET);
+    for (const change of changes) {
+        requestContext.checkpoint();
+        edits.set(change.file, {
+            ...change,
+            context: change.beforeText === null || change.afterText === null
+                ? null
+                : buildEditContextWithTracker(change.beforeText, change.afterText, tracker, requestContext),
+        });
+    }
+    const queues = new Map();
+    for (let index = 0; index < before.length; index += 1) {
+        requestContext.checkpoint();
+        const observation = before[index];
+        const key = observationKey(observation, observation.public.file === null ? undefined : edits.get(observation.public.file), "old");
+        if (key !== null) {
+            const queue = queues.get(key) ?? { indices: [], cursor: 0 };
+            queue.indices.push(index);
+            queues.set(key, queue);
+        }
+    }
+    const matchedBefore = new Set();
+    const matchedAfter = new Set();
+    for (let index = 0; index < after.length; index += 1) {
+        requestContext.checkpoint();
+        const observation = after[index];
+        const key = observationKey(observation, observation.public.file === null ? undefined : edits.get(observation.public.file), "new");
+        const queue = key === null ? undefined : queues.get(key);
+        if (queue && queue.cursor < queue.indices.length) {
+            matchedBefore.add(queue.indices[queue.cursor++]);
+            matchedAfter.add(index);
+        }
+    }
+    const added = after
+        .filter((_, index) => !matchedAfter.has(index))
+        .map(({ public: value }) => value);
+    const removed = before
+        .filter((_, index) => !matchedBefore.has(index))
+        .map(({ public: value }) => value);
+    return {
+        added,
+        removed,
+        addedErrors: added.filter((diagnostic) => diagnostic.category === "Error"),
+    };
+}
 function subtract(candidates, baseline, requestContext) {
     const counts = new Map();
     for (const diagnostic of baseline) {