@automaton-labs/aib 0.0.7 → 0.0.9

package/dist/mutation/semantic-rename-locations.js

@@ -0,0 +1,192 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expandSemanticRenameLocations = expandSemanticRenameLocations;
+exports.serializeSemanticRenameLocation = serializeSemanticRenameLocation;
+exports.semanticRenameReplacement = semanticRenameReplacement;
+const path = __importStar(require("node:path"));
+const typescript_1 = __importDefault(require("typescript"));
+function expandSemanticRenameLocations(languageService, renameLocations) {
+    const program = languageService.getProgram();
+    if (!program)
+        return [...renameLocations];
+    const expanded = [...renameLocations];
+    const seen = new Set(expanded.map(renameLocationKey));
+    const candidateResults = new Map();
+    const candidateLists = new Map();
+    const identifierIndexes = new Map();
+    const identifierFor = (location) => {
+        const sourceFile = findProgramSourceFile(program, location.fileName);
+        if (!sourceFile)
+            return null;
+        const key = pathKey(sourceFile.fileName);
+        const index = identifierIndexes.get(key) ?? buildIdentifierSpanIndex(sourceFile);
+        identifierIndexes.set(key, index);
+        return index.get(`${location.textSpan.start}:${location.textSpan.length}`) ?? null;
+    };
+    const declarations = renameLocations.filter((location) => {
+        const identifier = identifierFor(location);
+        return identifier ? isDeclarationIdentifier(identifier) : false;
+    });
+    for (const location of renameLocations) {
+        const identifier = identifierFor(location);
+        if (!identifier || !typescript_1.default.isShorthandPropertyAssignment(identifier.parent))
+            continue;
+        const candidates = candidateLists.get(identifier.text) ?? findPropertyRenameCandidates(program, identifier.text);
+        candidateLists.set(identifier.text, candidates);
+        for (const candidate of candidates) {
+            if (sameFilePosition(candidate, location))
+                continue;
+            const candidateKey = `${pathKey(candidate.sourceFile.fileName)}:${candidate.position}`;
+            const propertyLocations = candidateResults.get(candidateKey) ?? languageService.findRenameLocations(candidate.sourceFile.fileName, candidate.position, false, false, false) ?? [];
+            candidateResults.set(candidateKey, propertyLocations);
+            if (!propertyLocations.some((item) => sameSpan(item, location)))
+                continue;
+            if (declarations.some((declaration) => propertyLocations.some((item) => sameSpan(item, declaration))))
+                continue;
+            if (!propertyLocations.some((item) => !seen.has(renameLocationKey(item))))
+                continue;
+            for (const item of propertyLocations) {
+                const key = renameLocationKey(item);
+                if (!seen.has(key)) {
+                    seen.add(key);
+                    expanded.push(item);
+                }
+            }
+            break;
+        }
+    }
+    return expanded;
+}
+function serializeSemanticRenameLocation(program, location) {
+    return {
+        fileName: path.normalize(location.fileName),
+        start: location.textSpan.start,
+        length: location.textSpan.length,
+        ...(location.prefixText ? { prefixText: location.prefixText } : {}),
+        ...(location.suffixText ? { suffixText: location.suffixText } : {}),
+        classification: classifyLocation(program, location)
+    };
+}
+function semanticRenameReplacement(location, newName) {
+    return `${location.prefixText ?? ""}${newName}${location.suffixText ?? ""}`;
+}
+function classifyLocation(program, location) {
+    const source = findProgramSourceFile(program, location.fileName);
+    if (!source)
+        return "other";
+    let node = tokenAt(source, location.textSpan.start);
+    while (node) {
+        if (typescript_1.default.isExportSpecifier(node))
+            return "exportSpecifier";
+        if (typescript_1.default.isImportSpecifier(node))
+            return "importSpecifier";
+        if (typescript_1.default.isShorthandPropertyAssignment(node) || (typescript_1.default.isBindingElement(node) && !node.propertyName))
+            return "shorthand";
+        if (typescript_1.default.isPropertyAccessExpression(node))
+            return "property";
+        node = node.parent;
+    }
+    return "other";
+}
+function findPropertyRenameCandidates(program, propertyName) {
+    const properties = [];
+    const bindings = [];
+    for (const sourceFile of program.getSourceFiles()) {
+        if (sourceFile.isDeclarationFile)
+            continue;
+        const visit = (node) => {
+            if (typescript_1.default.isPropertyAccessExpression(node) && node.name.text === propertyName) {
+                properties.push({ sourceFile, position: node.name.getStart(sourceFile) });
+                return;
+            }
+            if (typescript_1.default.isBindingElement(node) && !node.propertyName && typescript_1.default.isIdentifier(node.name) &&
+                node.name.text === propertyName && typescript_1.default.isObjectBindingPattern(node.parent)) {
+                bindings.push({ sourceFile, position: node.name.getStart(sourceFile) });
+            }
+            typescript_1.default.forEachChild(node, visit);
+        };
+        visit(sourceFile);
+    }
+    return [...properties, ...bindings];
+}
+function buildIdentifierSpanIndex(sourceFile) {
+    const result = new Map();
+    const visit = (node) => {
+        if (typescript_1.default.isIdentifier(node))
+            result.set(`${node.getStart(sourceFile)}:${node.getWidth(sourceFile)}`, node);
+        typescript_1.default.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return result;
+}
+function isDeclarationIdentifier(identifier) {
+    const parent = identifier.parent;
+    return (typescript_1.default.isVariableDeclaration(parent) || typescript_1.default.isFunctionDeclaration(parent) || typescript_1.default.isClassDeclaration(parent) ||
+        typescript_1.default.isInterfaceDeclaration(parent) || typescript_1.default.isTypeAliasDeclaration(parent) || typescript_1.default.isEnumDeclaration(parent) ||
+        typescript_1.default.isModuleDeclaration(parent)) && parent.name === identifier;
+}
+function tokenAt(source, position) {
+    let found = source;
+    const visit = (node) => {
+        if (position < node.getStart(source) || position >= node.getEnd())
+            return;
+        found = node;
+        typescript_1.default.forEachChild(node, visit);
+    };
+    visit(source);
+    return found;
+}
+function findProgramSourceFile(program, fileName) {
+    const expected = pathKey(fileName);
+    return program.getSourceFiles().find((source) => pathKey(source.fileName) === expected) ?? null;
+}
+function sameSpan(left, right) {
+    return pathKey(left.fileName) === pathKey(right.fileName) &&
+        left.textSpan.start === right.textSpan.start && left.textSpan.length === right.textSpan.length;
+}
+function sameFilePosition(candidate, location) {
+    return pathKey(candidate.sourceFile.fileName) === pathKey(location.fileName) && candidate.position === location.textSpan.start;
+}
+function renameLocationKey(location) {
+    return `${pathKey(location.fileName)}:${location.textSpan.start}:${location.textSpan.length}:${location.prefixText ?? ""}\0${location.suffixText ?? ""}`;
+}
+function pathKey(file) {
+    const normalized = path.normalize(file);
+    return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}

package/dist/mutation/semantic-rename-model.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/mutation/semantic-rename-process.js

@@ -0,0 +1,217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SEMANTIC_RENAME_PROCESS_TESTING = void 0;
+exports.runSemanticRenameConfigWorker = runSemanticRenameConfigWorker;
+const node_child_process_1 = require("node:child_process");
+const semantic_worker_retry_1 = require("./semantic-worker-retry");
+const EXIT_GRACE_MS = 1_000;
+const EXIT_FORCE_MS = 2_000;
+async function runSemanticRenameConfigWorker(input) {
+    return (0, semantic_worker_retry_1.runSemanticWorkerWithRetry)(() => runSemanticRenameConfigWorkerAttempt(input));
+}
+async function runSemanticRenameConfigWorkerAttempt(input) {
+    const startedAt = Date.now();
+    const child = (0, node_child_process_1.fork)(input.modulePath, [], {
+        windowsHide: true,
+        detached: false,
+        stdio: ["ignore", "ignore", "ignore", "ipc"],
+        env: { ...process.env, ELECTRON_RUN_AS_NODE: "1" }
+    });
+    const pid = child.pid ?? null;
+    if (!pid) {
+        const terminationConfirmed = await terminateChild(child, null);
+        throw workerError(terminationConfirmed ? "SEMANTIC_RENAME_WORKER_START_FAILED" : "SEMANTIC_RENAME_WORKER_TERMINATION_FAILED", terminationConfirmed ? "Semantic rename config worker did not publish a PID." : "PID-less worker exit was not confirmed.");
+    }
+    let timer = null;
+    try {
+        const result = await new Promise((resolve, reject) => {
+            let settled = false;
+            const settle = (error, value) => {
+                if (settled)
+                    return;
+                settled = true;
+                if (timer)
+                    clearTimeout(timer);
+                child.removeAllListeners("message");
+                child.removeAllListeners("error");
+                child.removeAllListeners("exit");
+                if (error)
+                    reject(error);
+                else
+                    resolve(value);
+            };
+            timer = setTimeout(() => settle(workerError("SEMANTIC_RENAME_WORKER_DEADLINE", `Semantic rename config worker exceeded ${input.deadlineMs}ms.`)), input.deadlineMs);
+            timer.unref();
+            child.once("error", (error) => settle(workerError("SEMANTIC_RENAME_WORKER_START_FAILED", error.message)));
+            child.once("exit", (code, signal) => settle(workerError("SEMANTIC_RENAME_WORKER_CRASHED", `Semantic rename config worker exited before a result (code=${String(code)}, signal=${String(signal)}).`)));
+            child.once("message", (raw) => {
+                if (!isCompatibleResult(raw, input.request, pid)) {
+                    settle(workerError("SEMANTIC_RENAME_WORKER_PROTOCOL", "Semantic rename config worker returned malformed or mismatched evidence."));
+                    return;
+                }
+                settle(null, raw);
+            });
+            child.send(input.request, (error) => {
+                if (error)
+                    settle(workerError("SEMANTIC_RENAME_WORKER_START_FAILED", error.message));
+            });
+        });
+        const terminationConfirmed = await terminateChild(child, pid);
+        if (!terminationConfirmed) {
+            throw workerError("SEMANTIC_RENAME_WORKER_TERMINATION_FAILED", `Worker process-tree exit was not confirmed for PID ${pid}.`);
+        }
+        return { result, durationMs: Date.now() - startedAt, terminationConfirmed: true };
+    }
+    catch (error) {
+        const terminationConfirmed = await terminateChild(child, pid);
+        if (!terminationConfirmed) {
+            throw workerError("SEMANTIC_RENAME_WORKER_TERMINATION_FAILED", `Worker failure was followed by unconfirmed process-tree exit for PID ${pid}.`);
+        }
+        throw error;
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+    }
+}
+function isCompatibleResult(raw, request, pid) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw))
+        return false;
+    const value = raw;
+    return value.type === "semanticRenameConfigResult" && value.id === request.id &&
+        value.configFilePath === request.configFilePath && value.pid === pid &&
+        typeof value.ok === "boolean" && Array.isArray(value.rootFiles) && value.rootFiles.every((item) => typeof item === "string") &&
+        Array.isArray(value.intents) && value.intents.every(isCompatibleIntent) &&
+        Array.isArray(value.starProofs) && value.starProofs.every(isCompatibleStarProof) &&
+        Array.isArray(value.collisionProofs) && value.collisionProofs.every(isCompatibleCollisionProof) &&
+        Array.isArray(value.commonJsBlockers) && value.commonJsBlockers.every(isCompatibleCommonJsBlocker) &&
+        isStringRecord(value.beforeHashes) &&
+        typeof value.configHash === "string" && typeof value.rssMiB === "number";
+}
+function isCompatibleIntent(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const intent = value;
+    return typeof intent.id === "string" && typeof intent.canRename === "boolean" &&
+        Array.isArray(intent.completeLocations) && intent.completeLocations.every(isCompatibleLocation) &&
+        Array.isArray(intent.preserveLocations) && intent.preserveLocations.every(isCompatibleLocation) &&
+        (intent.error === undefined || typeof intent.error === "string");
+}
+function isCompatibleLocation(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const location = value;
+    return typeof location.fileName === "string" && Number.isSafeInteger(location.start) && location.start >= 0 &&
+        Number.isSafeInteger(location.length) && location.length > 0 &&
+        ["exportSpecifier", "importSpecifier", "shorthand", "property", "other"].includes(location.classification) &&
+        (location.prefixText === undefined || typeof location.prefixText === "string") &&
+        (location.suffixText === undefined || typeof location.suffixText === "string");
+}
+function isCompatibleStarProof(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const proof = value;
+    return typeof proof.id === "string" && ["proven", "notPresent", "collision", "divergent", "unresolved"].includes(proof.status) &&
+        (proof.error === undefined || typeof proof.error === "string");
+}
+function isCompatibleCollisionProof(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const proof = value;
+    return typeof proof.id === "string" && ["proven", "collision", "unresolved"].includes(proof.status) &&
+        (proof.error === undefined || typeof proof.error === "string") &&
+        (proof.blocker === undefined || isCompatibleCollisionBlocker(proof.blocker));
+}
+function isCompatibleCollisionBlocker(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const blocker = value;
+    return blocker.kind === "targetCollision" && blocker.reason === "targetAlreadyBound" &&
+        typeof blocker.intentId === "string" && typeof blocker.oldName === "string" && typeof blocker.newName === "string" &&
+        typeof blocker.fileName === "string" && Number.isSafeInteger(blocker.start) && blocker.start >= 0 &&
+        Number.isSafeInteger(blocker.length) && blocker.length > 0 && typeof blocker.surface === "string";
+}
+function isCompatibleCommonJsBlocker(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const blocker = value;
+    return blocker.kind === "commonJsReference" && blocker.reason === "referenceShapeUnproven" &&
+        typeof blocker.intentId === "string" && typeof blocker.oldName === "string" && typeof blocker.newName === "string" &&
+        typeof blocker.fileName === "string" && Number.isSafeInteger(blocker.start) && blocker.start >= 0 &&
+        Number.isSafeInteger(blocker.length) && blocker.length > 0 && blocker.surface === "rawRequire";
+}
+function isStringRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value) &&
+        Object.values(value).every((item) => typeof item === "string");
+}
+async function terminateChild(child, pid) {
+    if (child.connected)
+        child.disconnect();
+    if (pid === null) {
+        try {
+            child.kill("SIGKILL");
+        }
+        catch { /* already gone */ }
+        return waitForExit(child, EXIT_FORCE_MS);
+    }
+    if (!isAlive(pid) && hasExited(child))
+        return true;
+    if (process.platform === "win32") {
+        (0, node_child_process_1.spawnSync)("taskkill.exe", ["/PID", String(pid), "/T", "/F"], {
+            windowsHide: true,
+            stdio: "ignore",
+            timeout: EXIT_FORCE_MS
+        });
+        return waitForDead(child, pid, EXIT_FORCE_MS);
+    }
+    try {
+        child.kill("SIGTERM");
+    }
+    catch { /* already gone */ }
+    if (await waitForDead(child, pid, EXIT_GRACE_MS))
+        return true;
+    try {
+        child.kill("SIGKILL");
+    }
+    catch { /* already gone */ }
+    return waitForDead(child, pid, EXIT_FORCE_MS);
+}
+async function waitForDead(child, pid, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() <= deadline) {
+        if (!isAlive(pid) && hasExited(child))
+            return true;
+        await delay(20);
+    }
+    return !isAlive(pid) && hasExited(child);
+}
+async function waitForExit(child, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() <= deadline) {
+        if (hasExited(child))
+            return true;
+        await delay(20);
+    }
+    return hasExited(child);
+}
+function hasExited(child) {
+    return child.exitCode !== null || child.signalCode !== null;
+}
+function isAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function workerError(code, message) {
+    return Object.assign(new Error(message), { code });
+}
+exports.SEMANTIC_RENAME_PROCESS_TESTING = {
+    hasExited
+};