@automaton-labs/aib 0.0.6 → 0.0.8

package/dist/mutation/file-mutation-standalone-planner.js

@@ -0,0 +1,500 @@
+"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.planStandaloneFileMutation = planStandaloneFileMutation;
+const crypto = __importStar(require("node:crypto"));
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const typescript_1 = __importDefault(require("typescript"));
+const workspace_project_index_1 = require("../topology/workspace-project-index");
+const tsconfig_loader_1 = require("../topology/tsconfig-loader");
+const file_mutation_discovery_1 = require("./file-mutation-discovery");
+const file_mutation_tsserver_session_1 = require("./file-mutation-tsserver-session");
+const package_manifest_impact_1 = require("./package-manifest-impact");
+async function planStandaloneFileMutation(input, dependencies = { runSession: file_mutation_tsserver_session_1.runFileMutationTsServerSession }) {
+    const startedAt = Date.now();
+    const root = path.resolve(input.workspaceRoot);
+    const sourceFile = path.resolve(root, input.sourceFile);
+    const targetFile = path.resolve(root, input.targetFile);
+    const emptyHash = sha256("");
+    const emptyTargetSnapshot = { file: targetFile, exists: false, hash: null };
+    if (!input.discovery.complete) {
+        return incomplete("FILE_MUTATION_DISCOVERY_INCOMPLETE", "Consumer discovery is incomplete.", emptyHash, emptyHash);
+    }
+    if (!input.discovery.sourceFiles.some((file) => samePath(file, sourceFile))) {
+        return incomplete("FILE_MUTATION_SOURCE_MISMATCH", "Planner source is not a discovery source.", emptyHash, emptyHash);
+    }
+    let currentWorkspaceFingerprint;
+    try {
+        currentWorkspaceFingerprint = (0, file_mutation_discovery_1.computeFileMutationWorkspaceFingerprint)(root);
+    }
+    catch (error) {
+        return incomplete("FILE_MUTATION_DISCOVERY_SNAPSHOT_UNREADABLE", error instanceof Error ? error.message : String(error), emptyHash, emptyHash);
+    }
+    if (currentWorkspaceFingerprint !== input.discovery.workspaceFingerprint) {
+        return incomplete("FILE_MUTATION_DISCOVERY_STALE", "Workspace files, configs, or package metadata changed after consumer discovery.", emptyHash, emptyHash);
+    }
+    const relevantFiles = uniquePaths([sourceFile, ...input.discovery.consumerFiles]);
+    const expectedOwners = new Map(input.discovery.fileOwners.map((entry) => [pathKey(entry.file), entry.ownerConfigs]));
+    const index = new workspace_project_index_1.WorkspaceProjectIndex(root);
+    let structuralPaths;
+    try {
+        for (const file of relevantFiles) {
+            const actual = index.exactOwnersForFile(file)
+                .filter((owner) => owner.configRole === "project")
+                .map((owner) => owner.identity.lexicalPath)
+                .sort();
+            const expected = [...(expectedOwners.get(pathKey(file)) ?? [])].sort();
+            if (!equalPathSets(actual, expected)) {
+                return incomplete("FILE_MUTATION_OWNER_SET_CHANGED", `Exact project owners changed for ${file}.`, emptyHash, emptyHash);
+            }
+        }
+        const snapshot = index.snapshot;
+        structuralPaths = uniquePaths([
+            ...snapshot.configs.map((config) => config.identity.lexicalPath),
+            ...snapshot.packages.map((pkg) => pkg.packageJson.lexicalPath)
+        ]);
+    }
+    finally {
+        index.dispose();
+    }
+    let captured;
+    let structural;
+    let targetState;
+    try {
+        captured = captureFiles(relevantFiles);
+        structural = captureFiles(structuralPaths);
+        targetState = captureOptionalFile(targetFile);
+    }
+    catch (error) {
+        return incomplete("FILE_MUTATION_SNAPSHOT_FAILED", error instanceof Error ? error.message : String(error), emptyHash, emptyHash);
+    }
+    const snapshotHash = hashCapture(captured, targetFile, targetState);
+    const structuralHash = hashCapture(structural);
+    let ownerProjects;
+    try {
+        ownerProjects = buildOwnerProjects(input.discovery.ownerConfigs);
+    }
+    catch (error) {
+        return incomplete("FILE_MUTATION_OWNER_PROJECT_INVALID", error instanceof Error ? error.message : String(error), snapshotHash, structuralHash);
+    }
+    const openFiles = (input.testing?.openMode === "source-only" ? [sourceFile] : relevantFiles).map((file) => ({
+        file,
+        content: captured.get(pathKey(file)).text,
+        ownerConfig: expectedOwners.get(pathKey(file))[0]
+    }));
+    const session = await dependencies.runSession({
+        workspaceRoot: root,
+        sourceFile,
+        targetFile,
+        openFiles,
+        expectedOwnerConfigs: input.discovery.ownerConfigs,
+        ownerProjects: input.testing?.openMode === "source-only"
+            ? ownerProjects.map((project) => ({
+                ...project,
+                rootFiles: project.rootFiles.filter((file) => samePath(file, sourceFile))
+            }))
+            : ownerProjects,
+        deadlineMs: input.deadlineMs ?? 120_000,
+        ...(input.testing?.serverPath ? { serverPath: input.testing.serverPath } : {}),
+        ...(input.testing?.nodePath ? { nodePath: input.testing.nodePath } : {})
+    });
+    const drift = findSnapshotDrift(captured, structural, targetFile, targetState);
+    if (drift) {
+        return fromSessionFailure("FILE_MUTATION_SNAPSHOT_CHANGED", drift, snapshotHash, structuralHash, session, startedAt);
+    }
+    let finalWorkspaceFingerprint;
+    try {
+        finalWorkspaceFingerprint = (0, file_mutation_discovery_1.computeFileMutationWorkspaceFingerprint)(root);
+    }
+    catch (error) {
+        return fromSessionFailure("FILE_MUTATION_DISCOVERY_SNAPSHOT_UNREADABLE", error instanceof Error ? error.message : String(error), snapshotHash, structuralHash, session, startedAt);
+    }
+    if (finalWorkspaceFingerprint !== input.discovery.workspaceFingerprint) {
+        return fromSessionFailure("FILE_MUTATION_DISCOVERY_STALE", "Workspace files, configs, or package metadata changed during standalone planning.", snapshotHash, structuralHash, session, startedAt);
+    }
+    if (!session.ok) {
+        return fromSessionFailure(session.code, session.error, snapshotHash, structuralHash, session, startedAt);
+    }
+    if (session.missingOwnerConfigs.length > 0) {
+        return incompleteFromSuccess("FILE_MUTATION_OWNER_PROJECT_MISSING", "The official tsserver aggregate did not enable every exact owner project.", snapshotHash, structuralHash, session, [], startedAt);
+    }
+    const membership = session.memberships.map((item) => {
+        const exactOwners = expectedOwners.get(pathKey(item.file)) ?? [];
+        const exactOwner = item.success &&
+            item.configFileName !== null &&
+            exactOwners.some((owner) => samePath(owner, item.configFileName));
+        return {
+            file: path.normalize(item.file),
+            configFileName: item.configFileName,
+            exactOwner,
+            languageServiceDisabled: item.languageServiceDisabled
+        };
+    });
+    const invalidMembership = membership.find((item) => !item.exactOwner || item.languageServiceDisabled === true);
+    if (invalidMembership) {
+        return incompleteFromSuccess("FILE_MUTATION_PROJECT_MEMBERSHIP_UNPROVEN", `Configured-project membership is unproven for ${invalidMembership.file}.`, snapshotHash, structuralHash, session, membership, startedAt);
+    }
+    let edits;
+    try {
+        edits = convertEdits(session.edits, captured);
+    }
+    catch (error) {
+        return incompleteFromSuccess("FILE_MUTATION_TSSERVER_EDIT_INVALID", error instanceof Error ? error.message : String(error), snapshotHash, structuralHash, session, membership, startedAt);
+    }
+    const allowedKeys = new Set(relevantFiles.map(pathKey));
+    const unexpectedEditFiles = uniquePaths(edits
+        .map((edit) => edit.fileName)
+        .filter((file) => !allowedKeys.has(pathKey(file))));
+    const requiredEdges = requiredDirectEdges(input.discovery, sourceFile);
+    const missingRequiredEdges = requiredEdges
+        .filter((edge) => !edgeCovered(edge, edits, captured))
+        .map((edge) => ({ file: edge.fromFile, line: edge.line, moduleSpecifier: edge.moduleSpecifier }));
+    const observedTextChangeCount = edits.reduce((sum, edit) => sum + edit.textChanges.length, 0);
+    if (unexpectedEditFiles.length > 0 || missingRequiredEdges.length > 0) {
+        return {
+            complete: false,
+            code: unexpectedEditFiles.length > 0
+                ? "FILE_MUTATION_UNEXPECTED_EDIT_OUTSIDE_CLOSURE"
+                : "FILE_MUTATION_REQUIRED_EDIT_MISSING",
+            error: unexpectedEditFiles.length > 0
+                ? "tsserver returned edits outside the proven discovery closure."
+                : "tsserver omitted one or more directly required module-specifier edits.",
+            edits: [],
+            membership,
+            requiredEdgeCount: requiredEdges.length,
+            coveredRequiredEdgeCount: requiredEdges.length - missingRequiredEdges.length,
+            missingRequiredEdges,
+            unexpectedEditFiles,
+            observedEditFileCount: edits.length,
+            observedTextChangeCount,
+            snapshotHash,
+            structuralHash,
+            childPid: session.childPid,
+            childRssMiB: session.childRssMiB,
+            terminationConfirmed: session.terminationConfirmed,
+            openedFileCount: session.openedFileCount,
+            totalMs: Date.now() - startedAt,
+            renameMs: session.renameMs,
+            ownerResolutionCount: ownerResolutionCount(input.discovery),
+            enabledOwnerConfigs: session.enabledOwnerConfigs,
+            missingOwnerConfigs: session.missingOwnerConfigs,
+            diagnostics: [],
+            workspaceFingerprint: input.discovery.workspaceFingerprint,
+            fileSnapshots: [...captured.values()].map((item) => ({ file: item.file, hash: item.hash })),
+            targetSnapshot: { file: targetFile, ...targetState }
+        };
+    }
+    return {
+        complete: true,
+        code: "FILE_MUTATION_PLAN_COMPLETE",
+        edits,
+        membership,
+        requiredEdgeCount: requiredEdges.length,
+        coveredRequiredEdgeCount: requiredEdges.length,
+        missingRequiredEdges: [],
+        unexpectedEditFiles: [],
+        observedEditFileCount: edits.length,
+        observedTextChangeCount,
+        snapshotHash,
+        structuralHash,
+        childPid: session.childPid,
+        childRssMiB: session.childRssMiB,
+        terminationConfirmed: session.terminationConfirmed,
+        openedFileCount: session.openedFileCount,
+        totalMs: Date.now() - startedAt,
+        renameMs: session.renameMs,
+        ownerResolutionCount: ownerResolutionCount(input.discovery),
+        enabledOwnerConfigs: session.enabledOwnerConfigs,
+        missingOwnerConfigs: session.missingOwnerConfigs,
+        diagnostics: [],
+        workspaceFingerprint: input.discovery.workspaceFingerprint,
+        fileSnapshots: [...captured.values()].map((item) => ({ file: item.file, hash: item.hash })),
+        targetSnapshot: { file: targetFile, ...targetState },
+        packageManifestImpacts: (0, package_manifest_impact_1.collectMutationPackageManifestImpacts)({
+            mutationKind: "file-move",
+            sourceFile,
+            targetFile,
+            changedFiles: edits.map((edit) => edit.fileName),
+            packageManifests: input.discovery.packageManifests
+        })
+    };
+    function incomplete(code, error, sourceHash, configHash) {
+        return {
+            complete: false,
+            code,
+            error,
+            edits: [],
+            membership: [],
+            requiredEdgeCount: 0,
+            coveredRequiredEdgeCount: 0,
+            missingRequiredEdges: [],
+            unexpectedEditFiles: [],
+            observedEditFileCount: 0,
+            observedTextChangeCount: 0,
+            snapshotHash: sourceHash,
+            structuralHash: configHash,
+            childPid: null,
+            childRssMiB: null,
+            terminationConfirmed: true,
+            openedFileCount: 0,
+            totalMs: Date.now() - startedAt,
+            renameMs: null,
+            ownerResolutionCount: ownerResolutionCount(input.discovery),
+            enabledOwnerConfigs: [],
+            missingOwnerConfigs: [],
+            diagnostics: input.discovery.uncertainties.map((item) => `${item.kind}:${item.file}:${item.moduleSpecifier}`),
+            workspaceFingerprint: input.discovery.workspaceFingerprint,
+            fileSnapshots: [],
+            targetSnapshot: emptyTargetSnapshot
+        };
+    }
+}
+function incompleteFromSuccess(code, error, snapshotHash, structuralHash, session, membership, startedAt) {
+    return {
+        complete: false,
+        code,
+        error,
+        edits: [],
+        membership,
+        requiredEdgeCount: 0,
+        coveredRequiredEdgeCount: 0,
+        missingRequiredEdges: [],
+        unexpectedEditFiles: [],
+        observedEditFileCount: session.edits.length,
+        observedTextChangeCount: session.edits.reduce((sum, edit) => sum + edit.textChanges.length, 0),
+        snapshotHash,
+        structuralHash,
+        childPid: session.childPid,
+        childRssMiB: session.childRssMiB,
+        terminationConfirmed: session.terminationConfirmed,
+        openedFileCount: session.openedFileCount,
+        totalMs: Date.now() - startedAt,
+        renameMs: session.renameMs,
+        ownerResolutionCount: 0,
+        enabledOwnerConfigs: session.enabledOwnerConfigs,
+        missingOwnerConfigs: session.missingOwnerConfigs,
+        diagnostics: [],
+        workspaceFingerprint: "",
+        fileSnapshots: [],
+        targetSnapshot: { file: "", exists: false, hash: null }
+    };
+}
+function fromSessionFailure(code, error, snapshotHash, structuralHash, session, startedAt) {
+    return {
+        complete: false,
+        code,
+        error,
+        edits: [],
+        membership: [],
+        requiredEdgeCount: 0,
+        coveredRequiredEdgeCount: 0,
+        missingRequiredEdges: [],
+        unexpectedEditFiles: [],
+        observedEditFileCount: session.ok ? session.edits.length : 0,
+        observedTextChangeCount: session.ok ? session.edits.reduce((sum, edit) => sum + edit.textChanges.length, 0) : 0,
+        snapshotHash,
+        structuralHash,
+        childPid: session.childPid,
+        childRssMiB: session.childRssMiB,
+        terminationConfirmed: session.terminationConfirmed,
+        openedFileCount: session.openedFileCount,
+        totalMs: Date.now() - startedAt,
+        renameMs: session.ok ? session.renameMs : null,
+        ownerResolutionCount: 0,
+        enabledOwnerConfigs: session.ok ? session.enabledOwnerConfigs : [],
+        missingOwnerConfigs: session.ok ? session.missingOwnerConfigs : [],
+        diagnostics: session.stderrTail ? [session.stderrTail] : [],
+        workspaceFingerprint: "",
+        fileSnapshots: [],
+        targetSnapshot: { file: "", exists: false, hash: null }
+    };
+}
+function convertEdits(edits, captured) {
+    return edits.map((edit) => {
+        const source = captured.get(pathKey(edit.fileName));
+        if (!source) {
+            return {
+                fileName: path.normalize(edit.fileName),
+                textChanges: edit.textChanges.map((change) => ({ span: { start: 0, length: 0 }, newText: change.newText }))
+            };
+        }
+        return {
+            fileName: source.file,
+            textChanges: edit.textChanges.map((change) => {
+                const start = positionToOffset(source.text, change.start);
+                const end = positionToOffset(source.text, change.end);
+                if (end < start) {
+                    throw new Error(`Invalid edit range for ${source.file}.`);
+                }
+                return { span: { start, length: end - start }, newText: change.newText };
+            })
+        };
+    });
+}
+function positionToOffset(text, position) {
+    let line = 1;
+    let start = 0;
+    while (line < position.line) {
+        const newline = text.indexOf("\n", start);
+        if (newline < 0) {
+            throw new Error(`Line ${position.line} exceeds file length.`);
+        }
+        start = newline + 1;
+        line += 1;
+    }
+    const offset = start + position.offset - 1;
+    const lineEnd = text.indexOf("\n", start);
+    const max = lineEnd < 0 ? text.length : lineEnd;
+    if (offset < start || offset > max) {
+        throw new Error(`Offset ${position.offset} exceeds line ${position.line}.`);
+    }
+    return offset;
+}
+function requiredDirectEdges(discovery, sourceFile) {
+    const direct = new Set(discovery.directConsumerFiles.map(pathKey));
+    return discovery.edges.filter((edge) => direct.has(pathKey(edge.fromFile)) && samePath(edge.targetFile, sourceFile));
+}
+function edgeCovered(edge, edits, captured) {
+    const fileEdit = edits.find((edit) => samePath(edit.fileName, edge.fromFile));
+    const source = captured.get(pathKey(edge.fromFile));
+    if (!fileEdit || !source) {
+        return false;
+    }
+    const edgeEnd = edge.specifierStart + edge.specifierLength;
+    const contained = fileEdit.textChanges.filter((change) => {
+        const editEnd = change.span.start + change.span.length;
+        return change.span.start >= edge.specifierStart && editEnd <= edgeEnd;
+    });
+    if (contained.length === 0 || contained.some((change) => !isSaneModuleSpecifierEditText(change.newText))) {
+        return false;
+    }
+    const sorted = [...contained].sort((left, right) => right.span.start - left.span.start);
+    let previousStart = edgeEnd;
+    let updated = source.text.slice(edge.specifierStart, edgeEnd);
+    for (const change of sorted) {
+        const relativeStart = change.span.start - edge.specifierStart;
+        const relativeEnd = relativeStart + change.span.length;
+        if (relativeEnd > previousStart - edge.specifierStart) {
+            return false;
+        }
+        updated = `${updated.slice(0, relativeStart)}${change.newText}${updated.slice(relativeEnd)}`;
+        previousStart = change.span.start;
+    }
+    return updated !== source.text.slice(edge.specifierStart, edgeEnd) &&
+        updated.length > 0 &&
+        updated.trim() === updated &&
+        !/[\0\r\n'"`]/.test(updated);
+}
+function isSaneModuleSpecifierEditText(text) {
+    return !/[\0\r\n'"`]/.test(text);
+}
+function captureFiles(files) {
+    const result = new Map();
+    for (const file of files) {
+        const text = fs.readFileSync(file, "utf8");
+        result.set(pathKey(file), { file: path.normalize(file), text, hash: sha256(text) });
+    }
+    return result;
+}
+function buildOwnerProjects(configFiles) {
+    return uniquePaths(configFiles).map((configFile) => {
+        const diagnostics = [];
+        const parsed = (0, tsconfig_loader_1.parseTsConfig)(configFile, diagnostics);
+        if (!parsed) {
+            throw new Error(`Exact owner config could not be parsed: ${configFile}.`);
+        }
+        const options = { ...parsed.parsed.options };
+        delete options.configFile;
+        return {
+            configFile: path.normalize(configFile),
+            rootFiles: uniquePaths(parsed.parsed.fileNames),
+            options: JSON.parse(JSON.stringify(options))
+        };
+    });
+}
+function captureOptionalFile(file) {
+    return fs.existsSync(file)
+        ? { exists: true, hash: sha256(fs.readFileSync(file)) }
+        : { exists: false, hash: null };
+}
+function findSnapshotDrift(files, structural, targetFile, targetState) {
+    for (const item of [...files.values(), ...structural.values()]) {
+        try {
+            if (sha256(fs.readFileSync(item.file)) !== item.hash) {
+                return `Snapshot changed during planning: ${item.file}`;
+            }
+        }
+        catch {
+            return `Snapshot disappeared during planning: ${item.file}`;
+        }
+    }
+    const currentTarget = captureOptionalFile(targetFile);
+    return currentTarget.exists === targetState.exists && currentTarget.hash === targetState.hash
+        ? null
+        : `Target snapshot changed during planning: ${targetFile}`;
+}
+function hashCapture(capture, targetFile, targetState) {
+    const hash = crypto.createHash("sha256");
+    for (const item of [...capture.values()].sort((left, right) => left.file.localeCompare(right.file))) {
+        hash.update(item.file).update("\0").update(item.hash).update("\0");
+    }
+    if (targetFile && targetState) {
+        hash.update(path.normalize(targetFile)).update("\0").update(JSON.stringify(targetState));
+    }
+    return hash.digest("hex");
+}
+function ownerResolutionCount(discovery) {
+    return discovery.edges.reduce((sum, edge) => sum + edge.ownerResolutions.length, 0);
+}
+function equalPathSets(left, right) {
+    return left.length === right.length && left.every((file, index) => samePath(file, right[index]));
+}
+function uniquePaths(files) {
+    return [...new Map(files.map((file) => [pathKey(file), path.normalize(file)])).values()].sort();
+}
+function samePath(left, right) {
+    return pathKey(left) === pathKey(right);
+}
+function pathKey(file) {
+    const normalized = path.normalize(file);
+    return typescript_1.default.sys.useCaseSensitiveFileNames ? normalized : normalized.toLowerCase();
+}
+function sha256(value) {
+    return crypto.createHash("sha256").update(value).digest("hex");
+}