@automaton-labs/aib 0.0.6 → 0.0.8

package/dist/mutation/file-mutation-tsserver-session.js

@@ -0,0 +1,473 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runFileMutationTsServerSession = runFileMutationTsServerSession;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const MAX_PROTOCOL_HEADER_BYTES = 64 * 1024;
+const MAX_PROTOCOL_MESSAGE_BYTES = 16 * 1024 * 1024;
+const MAX_PROTOCOL_BUFFER_BYTES = MAX_PROTOCOL_HEADER_BYTES + MAX_PROTOCOL_MESSAGE_BYTES;
+const TERMINATE_GRACE_MS = 500;
+const TERMINATE_FORCE_MS = 2_000;
+async function runFileMutationTsServerSession(input) {
+    const startedAt = Date.now();
+    let stderrTail = "";
+    const serverPath = input.serverPath ?? require.resolve("typescript/lib/tsserver.js");
+    const nodePath = input.nodePath ?? process.execPath;
+    let child;
+    try {
+        child = (0, node_child_process_1.spawn)(nodePath, [serverPath, "--disableAutomaticTypingAcquisition"], {
+            cwd: input.workspaceRoot,
+            stdio: ["pipe", "pipe", "pipe"],
+            windowsHide: true,
+            // The file-mutation worker owns the POSIX process group. Keeping tsserver
+            // in that group lets an outer worker deadline reclaim both processes.
+            detached: false
+        });
+    }
+    catch (error) {
+        return failed("FILE_MUTATION_TSSERVER_START_FAILED", error instanceof Error ? error.message : String(error), null);
+    }
+    const childPid = child.pid ?? null;
+    if (!childPid) {
+        child.kill();
+        const termination = await terminateProcessTree(child, null);
+        return failed(termination.confirmed ? "FILE_MUTATION_TSSERVER_START_FAILED" : "FILE_MUTATION_TSSERVER_TERMINATION_FAILED", termination.confirmed ? "tsserver did not publish a child PID." : termination.error, null, null, termination.confirmed);
+    }
+    let sequence = 0;
+    let stdoutBuffer = Buffer.alloc(0);
+    let terminal = false;
+    let renameStartedAt = 0;
+    const pending = new Map();
+    let protocolFailed = false;
+    let rejectProtocolFatal;
+    const protocolFatal = new Promise((_resolve, reject) => {
+        rejectProtocolFatal = reject;
+    });
+    const finishFailure = async (code, error) => {
+        if (!terminal) {
+            terminal = true;
+            for (const item of pending.values()) {
+                item.reject(new Error(error));
+            }
+            pending.clear();
+        }
+        const rss = readProcessRssMiB(childPid);
+        const termination = await terminateProcessTree(child, childPid);
+        return failed(termination.confirmed ? code : "FILE_MUTATION_TSSERVER_TERMINATION_FAILED", termination.confirmed ? error : `${error} ${termination.error}`, childPid, rss, termination.confirmed);
+    };
+    const fatal = new Promise((_resolve, reject) => {
+        child.on("error", (error) => reject(new SessionFailure("FILE_MUTATION_TSSERVER_START_FAILED", error.message)));
+        child.on("exit", (code, signal) => {
+            if (!terminal) {
+                reject(new SessionFailure("FILE_MUTATION_TSSERVER_CRASHED", `tsserver exited before completion (code=${String(code)}, signal=${String(signal)}).`));
+            }
+        });
+    });
+    child.stderr.on("data", (chunk) => {
+        stderrTail = `${stderrTail}${chunk.toString("utf8")}`.slice(-4_000);
+    });
+    child.stdout.on("data", (chunk) => {
+        if (terminal) {
+            return;
+        }
+        if (stdoutBuffer.length + chunk.length > MAX_PROTOCOL_BUFFER_BYTES) {
+            const failure = new SessionFailure("FILE_MUTATION_TSSERVER_PROTOCOL_MALFORMED", `tsserver protocol buffer exceeded ${MAX_PROTOCOL_BUFFER_BYTES} bytes.`);
+            child.stdout.pause();
+            protocolFailed = true;
+            rejectProtocolFatal(failure);
+            for (const item of pending.values()) {
+                item.reject(failure);
+            }
+            pending.clear();
+            return;
+        }
+        stdoutBuffer = Buffer.concat([stdoutBuffer, chunk]);
+        try {
+            drainProtocolMessages();
+        }
+        catch (error) {
+            const failure = error instanceof SessionFailure
+                ? error
+                : new SessionFailure("FILE_MUTATION_TSSERVER_PROTOCOL_MALFORMED", error instanceof Error ? error.message : String(error));
+            for (const item of pending.values()) {
+                item.reject(failure);
+            }
+            pending.clear();
+            child.stdout.pause();
+            if (!protocolFailed) {
+                protocolFailed = true;
+                rejectProtocolFatal(failure);
+            }
+        }
+    });
+    const deadline = new Promise((_resolve, reject) => {
+        setTimeout(() => reject(new SessionFailure("FILE_MUTATION_TSSERVER_DEADLINE", `tsserver exceeded ${input.deadlineMs}ms deadline.`)), input.deadlineMs).unref();
+    });
+    try {
+        const work = (async () => {
+            const openProjectsResponse = await sendRequest("openExternalProjects", {
+                projects: input.ownerProjects.map((project) => ({
+                    projectFileName: project.configFile,
+                    rootFiles: project.rootFiles.map((fileName) => ({ fileName })),
+                    options: project.options
+                }))
+            });
+            if (openProjectsResponse.success !== true) {
+                throw new SessionFailure("FILE_MUTATION_TSSERVER_REQUEST_FAILED", openProjectsResponse.message ?? "openExternalProjects failed.");
+            }
+            for (const opened of input.openFiles) {
+                sendNotification("open", {
+                    file: opened.file,
+                    fileContent: opened.content,
+                    projectRootPath: input.workspaceRoot
+                });
+            }
+            const memberships = await Promise.all(input.openFiles.map(async (opened) => {
+                const response = await sendRequest("projectInfo", {
+                    file: opened.file,
+                    projectFileName: opened.ownerConfig,
+                    needFileNameList: false
+                });
+                const body = isRecord(response.body) ? response.body : {};
+                return {
+                    file: opened.file,
+                    success: response.success === true,
+                    configFileName: typeof body.configFileName === "string" ? path.normalize(body.configFileName) : null,
+                    languageServiceDisabled: typeof body.languageServiceDisabled === "boolean"
+                        ? body.languageServiceDisabled
+                        : null
+                };
+            }));
+            renameStartedAt = Date.now();
+            const response = await sendRequest("getEditsForFileRename", {
+                oldFilePath: input.sourceFile,
+                newFilePath: input.targetFile
+            });
+            if (response.success !== true || !Array.isArray(response.body)) {
+                throw new SessionFailure("FILE_MUTATION_TSSERVER_REQUEST_FAILED", response.message ?? "getEditsForFileRename failed.");
+            }
+            const projectListResponse = await sendRequest("synchronizeProjectList", {
+                knownProjects: [],
+                includeProjectReferenceRedirectInfo: false
+            });
+            if (projectListResponse.success !== true || !Array.isArray(projectListResponse.body)) {
+                throw new SessionFailure("FILE_MUTATION_TSSERVER_REQUEST_FAILED", projectListResponse.message ?? "synchronizeProjectList failed.");
+            }
+            const allEnabledConfiguredProjects = readEnabledConfiguredProjects(projectListResponse.body);
+            const enabledKeys = new Set(allEnabledConfiguredProjects.map(pathKey));
+            const expectedOwnerConfigs = uniquePaths(input.expectedOwnerConfigs);
+            const enabledOwnerConfigs = expectedOwnerConfigs.filter((config) => enabledKeys.has(pathKey(config)));
+            const missingOwnerConfigs = expectedOwnerConfigs
+                .filter((config) => !enabledKeys.has(pathKey(config)));
+            return { memberships, edits: readEdits(response.body), enabledOwnerConfigs, missingOwnerConfigs };
+        })();
+        const output = await Promise.race([work, fatal, protocolFatal, deadline]);
+        terminal = true;
+        const childRssMiB = readProcessRssMiB(childPid);
+        const termination = await terminateProcessTree(child, childPid);
+        if (!termination.confirmed) {
+            return failed("FILE_MUTATION_TSSERVER_TERMINATION_FAILED", termination.error, childPid, childRssMiB, false);
+        }
+        return {
+            ok: true,
+            edits: output.edits,
+            memberships: output.memberships,
+            enabledOwnerConfigs: output.enabledOwnerConfigs,
+            missingOwnerConfigs: output.missingOwnerConfigs,
+            childPid,
+            childRssMiB,
+            terminationConfirmed: true,
+            totalMs: Date.now() - startedAt,
+            renameMs: Date.now() - renameStartedAt,
+            openedFileCount: input.openFiles.length,
+            stderrTail
+        };
+    }
+    catch (error) {
+        const failure = error instanceof SessionFailure
+            ? error
+            : new SessionFailure("FILE_MUTATION_TSSERVER_REQUEST_FAILED", error instanceof Error ? error.message : String(error));
+        return finishFailure(failure.code, failure.message);
+    }
+    function sendNotification(command, args) {
+        child.stdin.write(`${JSON.stringify({ seq: ++sequence, type: "request", command, arguments: args })}\n`);
+    }
+    function sendRequest(command, args) {
+        const seq = ++sequence;
+        const promise = new Promise((resolve, reject) => {
+            pending.set(seq, { command, resolve, reject });
+        });
+        child.stdin.write(`${JSON.stringify({ seq, type: "request", command, arguments: args })}\n`);
+        return promise;
+    }
+    function drainProtocolMessages() {
+        while (true) {
+            const headerEnd = stdoutBuffer.indexOf("\r\n\r\n");
+            if (headerEnd < 0) {
+                if (stdoutBuffer.length > MAX_PROTOCOL_HEADER_BYTES) {
+                    throw new SessionFailure("FILE_MUTATION_TSSERVER_PROTOCOL_MALFORMED", `Unframed tsserver output exceeded ${MAX_PROTOCOL_HEADER_BYTES} bytes.`);
+                }
+                return;
+            }
+            if (headerEnd > MAX_PROTOCOL_HEADER_BYTES) {
+                throw new SessionFailure("FILE_MUTATION_TSSERVER_PROTOCOL_MALFORMED", `tsserver protocol header exceeded ${MAX_PROTOCOL_HEADER_BYTES} bytes.`);
+            }
+            const header = stdoutBuffer.subarray(0, headerEnd).toString("utf8");
+            const match = /Content-Length:\s*(\d+)/i.exec(header);
+            if (!match) {
+                throw new SessionFailure("FILE_MUTATION_TSSERVER_PROTOCOL_MALFORMED", "tsserver response omitted Content-Length.");
+            }
+            const length = Number(match[1]);
+            if (!Number.isSafeInteger(length) || length < 0 || length > MAX_PROTOCOL_MESSAGE_BYTES) {
+                throw new SessionFailure("FILE_MUTATION_TSSERVER_PROTOCOL_MALFORMED", `tsserver Content-Length ${String(match[1])} exceeds the supported limit.`);
+            }
+            const bodyStart = headerEnd + 4;
+            if (stdoutBuffer.length < bodyStart + length) {
+                return;
+            }
+            const body = stdoutBuffer.subarray(bodyStart, bodyStart + length).toString("utf8");
+            stdoutBuffer = stdoutBuffer.subarray(bodyStart + length);
+            let message;
+            try {
+                message = JSON.parse(body);
+            }
+            catch (error) {
+                throw new SessionFailure("FILE_MUTATION_TSSERVER_PROTOCOL_MALFORMED", `Invalid tsserver JSON: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            if (message.type !== "response" || typeof message.request_seq !== "number") {
+                continue;
+            }
+            const request = pending.get(message.request_seq);
+            if (!request) {
+                continue;
+            }
+            pending.delete(message.request_seq);
+            if (message.command !== request.command) {
+                request.reject(new SessionFailure("FILE_MUTATION_TSSERVER_PROTOCOL_MALFORMED", `tsserver response command mismatch: expected ${request.command}, got ${String(message.command)}.`));
+                continue;
+            }
+            request.resolve(message);
+        }
+    }
+    function failed(code, error, pid, rss = null, terminationConfirmed = pid === null) {
+        return {
+            ok: false,
+            code,
+            error,
+            childPid: pid,
+            childRssMiB: rss,
+            terminationConfirmed,
+            totalMs: Date.now() - startedAt,
+            openedFileCount: input.openFiles.length,
+            stderrTail
+        };
+    }
+}
+class SessionFailure extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+}
+function readEdits(value) {
+    const edits = [];
+    for (const item of value) {
+        if (!isRecord(item) || typeof item.fileName !== "string" || !Array.isArray(item.textChanges)) {
+            throw new SessionFailure("FILE_MUTATION_TSSERVER_PROTOCOL_MALFORMED", "Malformed file rename edit record.");
+        }
+        const textChanges = item.textChanges.map((change) => {
+            if (!isRecord(change) || !isLocation(change.start) || !isLocation(change.end) || typeof change.newText !== "string") {
+                throw new SessionFailure("FILE_MUTATION_TSSERVER_PROTOCOL_MALFORMED", "Malformed file rename text change.");
+            }
+            return { start: change.start, end: change.end, newText: change.newText };
+        });
+        edits.push({ fileName: path.normalize(item.fileName), textChanges });
+    }
+    return edits.sort((left, right) => left.fileName.localeCompare(right.fileName));
+}
+function isLocation(value) {
+    return isRecord(value) &&
+        typeof value.line === "number" && Number.isInteger(value.line) && value.line > 0 &&
+        typeof value.offset === "number" && Number.isInteger(value.offset) && value.offset > 0;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readEnabledConfiguredProjects(value) {
+    const result = [];
+    for (const item of value) {
+        if (!isRecord(item) || !isRecord(item.info)) {
+            throw new SessionFailure("FILE_MUTATION_TSSERVER_PROTOCOL_MALFORMED", "Malformed synchronizeProjectList project record.");
+        }
+        const info = item.info;
+        if (typeof info.projectName !== "string" || typeof info.isInferred !== "boolean") {
+            throw new SessionFailure("FILE_MUTATION_TSSERVER_PROTOCOL_MALFORMED", "Malformed synchronizeProjectList project info.");
+        }
+        if (!info.isInferred && info.languageServiceDisabled !== true) {
+            result.push(path.normalize(info.projectName));
+        }
+    }
+    return uniquePaths(result);
+}
+async function terminateProcessTree(child, pid) {
+    try {
+        child.stdin.end();
+    }
+    catch {
+        // Continue with owned-process termination.
+    }
+    if (pid === null) {
+        try {
+            child.kill("SIGKILL");
+        }
+        catch {
+            // A PID-less child may already be gone.
+        }
+        const confirmed = await waitForChildExit(child, TERMINATE_FORCE_MS);
+        destroyChildStreams(child);
+        return {
+            confirmed,
+            error: confirmed ? "" : "tsserver PID-less child exit could not be confirmed."
+        };
+    }
+    if (!isProcessTreeAlive(child, pid)) {
+        destroyChildStreams(child);
+        return { confirmed: true, error: "" };
+    }
+    if (process.platform === "win32") {
+        (0, node_child_process_1.spawnSync)("taskkill.exe", ["/PID", String(pid), "/T", "/F"], {
+            stdio: "ignore",
+            windowsHide: true,
+            timeout: TERMINATE_FORCE_MS
+        });
+        const confirmed = await waitForProcessTreeExit(child, pid, TERMINATE_FORCE_MS);
+        destroyChildStreams(child);
+        return {
+            confirmed,
+            error: confirmed ? "" : `taskkill did not confirm tsserver process-tree exit for PID ${pid}.`
+        };
+    }
+    signalProcessTree(pid, "SIGTERM");
+    if (await waitForProcessTreeExit(child, pid, TERMINATE_GRACE_MS)) {
+        destroyChildStreams(child);
+        return { confirmed: true, error: "" };
+    }
+    signalProcessTree(pid, "SIGKILL");
+    const confirmed = await waitForProcessTreeExit(child, pid, TERMINATE_FORCE_MS);
+    destroyChildStreams(child);
+    return {
+        confirmed,
+        error: confirmed ? "" : `SIGKILL did not confirm tsserver process-group exit for PID ${pid}.`
+    };
+}
+function signalProcessTree(pid, signal) {
+    try {
+        process.kill(pid, signal);
+    }
+    catch {
+        // Already exited.
+    }
+}
+async function waitForProcessTreeExit(child, pid, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() <= deadline) {
+        if (!isProcessTreeAlive(child, pid)) {
+            return true;
+        }
+        await delay(20);
+    }
+    return !isProcessTreeAlive(child, pid);
+}
+async function waitForChildExit(child, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() <= deadline) {
+        if (child.exitCode !== null || child.signalCode !== null) {
+            return true;
+        }
+        await delay(20);
+    }
+    return child.exitCode !== null || child.signalCode !== null;
+}
+function isProcessTreeAlive(child, pid) {
+    if (process.platform === "win32") {
+        return child.exitCode === null && child.signalCode === null && isPidAlive(pid);
+    }
+    return child.exitCode === null && child.signalCode === null && isPidAlive(pid);
+}
+function isPidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return isPermissionError(error);
+    }
+}
+function isPermissionError(error) {
+    return isRecord(error) && error.code === "EPERM";
+}
+function destroyChildStreams(child) {
+    child.stdin.destroy();
+    child.stdout.destroy();
+    child.stderr.destroy();
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function uniquePaths(files) {
+    return [...new Map(files.map((file) => [pathKey(file), path.normalize(file)])).values()].sort();
+}
+function pathKey(file) {
+    const normalized = path.normalize(file);
+    return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}
+function readProcessRssMiB(pid) {
+    if (process.platform === "win32") {
+        const result = (0, node_child_process_1.spawnSync)("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", `(Get-Process -Id ${pid} -ErrorAction Stop).WorkingSet64`], { encoding: "utf8", windowsHide: true, timeout: 5_000 });
+        const bytes = Number(result.stdout.trim());
+        return Number.isFinite(bytes) ? bytes / 1024 / 1024 : null;
+    }
+    try {
+        const status = fs.readFileSync(`/proc/${pid}/status`, "utf8");
+        const match = /^VmRSS:\s+(\d+)\s+kB$/m.exec(status);
+        return match ? Number(match[1]) / 1024 : null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/mutation/mutation-estimate.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.estimateMutationPlanDurationMs = estimateMutationPlanDurationMs;
+function estimateMutationPlanDurationMs(input) {
+    const estimate = readEstimate(input);
+    const rowCount = readCount(estimate.rowCount);
+    const baseMs = 12_000;
+    const groupMs = readCount(estimate.groupCount) * 1_500;
+    const selectedSemanticMs = readCount(estimate.semanticSelectedDurationMs);
+    const hasSelectedSemanticEstimate = selectedSemanticMs > 0;
+    const semanticMs = hasSelectedSemanticEstimate ? selectedSemanticMs : readCount(estimate.semanticRowCount) * 6_000;
+    const selectedFileMs = readCount(estimate.fileSelectedDurationMs);
+    const hasSelectedFileEstimate = selectedFileMs > 0;
+    const fileMs = hasSelectedFileEstimate ? selectedFileMs : readCount(estimate.fileRowCount) * 110_000;
+    const modulePlanMs = hasSelectedSemanticEstimate ? 0 : readCount(estimate.modulePlanRowCount) * 180_000;
+    const providerMs = readCount(estimate.providerRequestCount) * 2_000;
+    const fileOperationMs = hasSelectedFileEstimate ? 0 : readCount(estimate.fileOperationCount) * 2_000;
+    const targetDirMs = hasSelectedFileEstimate ? 0 : readCount(estimate.targetDirCount) * 1_000;
+    const postProcessMs = readCount(estimate.postProcessPhaseCount) * 5_000;
+    const operationFloorMs = Math.max(1, rowCount) * 5_000;
+    return clampMs(baseMs +
+        groupMs +
+        semanticMs +
+        fileMs +
+        modulePlanMs +
+        providerMs +
+        fileOperationMs +
+        targetDirMs +
+        postProcessMs, Math.max(8_000, operationFloorMs), 300_000);
+}
+function readEstimate(input) {
+    if (isObject(input) && "estimate" in input && isObject(input.estimate)) {
+        return input.estimate;
+    }
+    return input;
+}
+function readCount(value) {
+    return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
+}
+function clampMs(value, minMs, maxMs) {
+    return Math.min(maxMs, Math.max(minMs, Math.round(value)));
+}
+function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}