@automaton-labs/aib 0.0.7 → 0.0.9

package/dist/mutation/package-manifest-impact.js

@@ -0,0 +1,176 @@
+"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.collectMutationPackageManifestImpacts = collectMutationPackageManifestImpacts;
+const path = __importStar(require("node:path"));
+function collectMutationPackageManifestImpacts(input) {
+    const sourceFile = path.resolve(input.sourceFile);
+    const targetFile = path.resolve(input.targetFile);
+    const sourcePackage = packageForFile(input.packageManifests, sourceFile);
+    const targetPackage = packageForFile(input.packageManifests, targetFile);
+    const impacts = [];
+    if (input.mutationKind === "file-move" && sourcePackage) {
+        for (const leaf of packageEntryLeaves(sourcePackage)) {
+            const sourceMatch = matchPackageTarget(sourcePackage.identity.lexicalPath, leaf.target, sourceFile);
+            if (!sourceMatch.matched)
+                continue;
+            const common = {
+                packageJson: sourcePackage.packageJson.lexicalPath,
+                ...(sourcePackage.name ? { packageName: sourcePackage.name } : {}),
+                sourceFile,
+                targetFile,
+                ...(leaf.exportKey ? { exportKey: leaf.exportKey } : {}),
+                ...(leaf.conditionPath.length > 0 ? { conditionPath: leaf.conditionPath } : {}),
+                currentTarget: leaf.target
+            };
+            if (!leaf.target.includes("*")) {
+                impacts.push({
+                    ...common,
+                    kind: "export-target-moved",
+                    confidence: "exact",
+                    candidateTarget: toPackageTarget(sourcePackage.identity.lexicalPath, targetFile)
+                });
+            }
+            else if (!matchPackageTarget(sourcePackage.identity.lexicalPath, leaf.target, targetFile).matched) {
+                impacts.push({
+                    ...common,
+                    kind: "export-pattern-no-longer-covers-target",
+                    confidence: "review"
+                });
+            }
+        }
+    }
+    if (input.mutationKind === "declaration-move" && targetPackage) {
+        const changedOutsideTarget = (input.changedFiles ?? []).some((file) => {
+            const owner = packageForFile(input.packageManifests, path.resolve(file));
+            return owner && owner.identity.key !== targetPackage.identity.key;
+        });
+        if (changedOutsideTarget && !packageExportsFile(targetPackage, targetFile)) {
+            impacts.push({
+                kind: "target-subpath-not-exported",
+                confidence: "review",
+                packageJson: targetPackage.packageJson.lexicalPath,
+                ...(targetPackage.name ? { packageName: targetPackage.name } : {}),
+                sourceFile,
+                targetFile
+            });
+        }
+        if (sourcePackage && sourcePackage.identity.key !== targetPackage.identity.key && targetPackage.name) {
+            for (const changedFile of input.changedFiles ?? []) {
+                const consumerPackage = packageForFile(input.packageManifests, path.resolve(changedFile));
+                if (!consumerPackage || consumerPackage.identity.key === targetPackage.identity.key || consumerPackage.dependencies.includes(targetPackage.name)) {
+                    continue;
+                }
+                impacts.push({
+                    kind: "cross-package-dependency-missing",
+                    confidence: "review",
+                    packageJson: targetPackage.packageJson.lexicalPath,
+                    packageName: targetPackage.name,
+                    sourceFile,
+                    targetFile,
+                    consumerPackageJson: consumerPackage.packageJson.lexicalPath
+                });
+            }
+        }
+    }
+    return uniqueImpacts(impacts);
+}
+function packageEntryLeaves(pkg) {
+    const leaves = collectExportLeaves(pkg.exports, undefined, []);
+    for (const [condition, target] of [["types", pkg.types], ["typings", pkg.typings], ["module", pkg.module], ["main", pkg.main]]) {
+        if (target)
+            leaves.push({ conditionPath: [condition], target });
+    }
+    return leaves;
+}
+function collectExportLeaves(value, exportKey, conditions) {
+    if (typeof value === "string") {
+        return [{ ...(exportKey ? { exportKey } : {}), conditionPath: conditions, target: value }];
+    }
+    if (Array.isArray(value)) {
+        return value.flatMap((item) => collectExportLeaves(item, exportKey, conditions));
+    }
+    if (!value || typeof value !== "object")
+        return [];
+    return Object.entries(value).flatMap(([key, nested]) => key.startsWith(".")
+        ? collectExportLeaves(nested, key, [])
+        : collectExportLeaves(nested, exportKey, [...conditions, key]));
+}
+function packageExportsFile(pkg, file) {
+    return packageEntryLeaves(pkg).some((leaf) => matchPackageTarget(pkg.identity.lexicalPath, leaf.target, file).matched);
+}
+function matchPackageTarget(root, rawTarget, file) {
+    if (path.isAbsolute(rawTarget) || rawTarget.startsWith("#"))
+        return { matched: false };
+    const normalizedTarget = rawTarget.replace(/\\/g, "/").replace(/^\.\//, "");
+    const relativeFile = path.relative(root, file).replace(/\\/g, "/");
+    if (relativeFile.startsWith("../") || path.isAbsolute(relativeFile))
+        return { matched: false };
+    const star = normalizedTarget.indexOf("*");
+    if (star < 0)
+        return { matched: normalizeComparable(relativeFile) === normalizeComparable(normalizedTarget) };
+    const prefix = normalizedTarget.slice(0, star);
+    const suffix = normalizedTarget.slice(star + 1);
+    if (!relativeFile.startsWith(prefix) || !relativeFile.endsWith(suffix))
+        return { matched: false };
+    return { matched: true, wildcard: relativeFile.slice(prefix.length, relativeFile.length - suffix.length) };
+}
+function packageForFile(packages, file) {
+    return [...packages]
+        .filter((pkg) => isInside(file, pkg.identity.lexicalPath))
+        .sort((left, right) => right.identity.lexicalPath.length - left.identity.lexicalPath.length)[0] ?? null;
+}
+function toPackageTarget(root, file) {
+    return `./${path.relative(root, file).replace(/\\/g, "/")}`;
+}
+function isInside(file, root) {
+    const relative = path.relative(root, file);
+    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+function normalizeComparable(file) {
+    return process.platform === "win32" ? file.toLowerCase() : file;
+}
+function uniqueImpacts(impacts) {
+    const seen = new Map();
+    for (const impact of impacts) {
+        const key = JSON.stringify(impact);
+        if (!seen.has(key))
+            seen.set(key, impact);
+    }
+    return [...seen.values()].sort((left, right) => left.packageJson.localeCompare(right.packageJson) ||
+        left.kind.localeCompare(right.kind) ||
+        (left.exportKey ?? "").localeCompare(right.exportKey ?? "") ||
+        (left.consumerPackageJson ?? "").localeCompare(right.consumerPackageJson ?? ""));
+}

package/dist/mutation/rename-owner-worker-child.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const rename_owner_worker_1 = require("./rename-owner-worker");
+process.once("message", (raw) => {
+    const request = readRequest(raw);
+    if (!request) {
+        send({ type: "ownersResult", id: "invalid", ok: false, error: "Invalid rename owner worker request." });
+        return;
+    }
+    try {
+        const evidence = (0, rename_owner_worker_1.buildRenameOwnerEvidence)(request.workspaceRoot, request.files);
+        send({
+            type: "ownersResult",
+            id: request.id,
+            ok: true,
+            ...evidence
+        });
+    }
+    catch (error) {
+        send({ type: "ownersResult", id: request.id, ok: false, error: error instanceof Error ? error.message : String(error) });
+    }
+});
+function readRequest(raw) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw))
+        return null;
+    const value = raw;
+    return value.type === "owners" && typeof value.id === "string" &&
+        typeof value.workspaceRoot === "string" && Array.isArray(value.files) &&
+        value.files.every((file) => typeof file === "string")
+        ? value
+        : null;
+}
+function send(message) {
+    const sendMessage = process.send;
+    if (sendMessage)
+        sendMessage.call(process, message, () => process.disconnect?.());
+}

package/dist/mutation/rename-owner-worker.js

@@ -0,0 +1,122 @@
+"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.buildRenameOwnerEvidence = buildRenameOwnerEvidence;
+const crypto = __importStar(require("node:crypto"));
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const workspace_project_index_1 = require("../topology/workspace-project-index");
+function buildRenameOwnerEvidence(workspaceRoot, files) {
+    const index = new workspace_project_index_1.WorkspaceProjectIndex(workspaceRoot);
+    try {
+        const snapshot = index.snapshot;
+        const owners = files.map((file) => ({
+            file: path.normalize(file),
+            configs: index.exactOwnersForFile(file)
+                .filter((owner) => owner.configRole === "project")
+                .map((owner) => owner.identity.lexicalPath)
+                .sort()
+        }));
+        if (owners.some((item) => item.configs.length === 0)) {
+            throw new Error("At least one rename consumer has no exact project owner.");
+        }
+        return {
+            configs: [...new Set(owners.flatMap((item) => item.configs))].sort(),
+            owners,
+            structuralFingerprint: buildStructuralFingerprint(workspaceRoot, snapshot)
+        };
+    }
+    finally {
+        index.dispose();
+    }
+}
+function buildStructuralFingerprint(workspaceRoot, snapshot) {
+    const structuralFiles = new Map();
+    for (const file of [
+        ...snapshot.configs.map((config) => config.identity.lexicalPath),
+        ...snapshot.packages.map((pkg) => pkg.packageJson.lexicalPath),
+        ...discoverMetadataFiles(workspaceRoot)
+    ]) {
+        structuralFiles.set(fileKey(file), path.normalize(file));
+    }
+    const manifest = {
+        configs: snapshot.configs.map((config) => ({
+            file: relative(workspaceRoot, config.identity.lexicalPath),
+            role: config.configRole,
+            compilerOptionsFingerprint: config.compilerOptionsFingerprint,
+            fileSetFingerprint: config.fileSetFingerprint,
+            sourceFileCount: config.sourceFileCount,
+            extends: config.extends?.key ?? null,
+            references: config.projectReferences.map((reference) => reference.key).sort()
+        })).sort((left, right) => left.file.localeCompare(right.file)),
+        packages: snapshot.packages.map((pkg) => ({
+            file: relative(workspaceRoot, pkg.packageJson.lexicalPath),
+            fingerprint: pkg.fingerprint
+        })).sort((left, right) => left.file.localeCompare(right.file)),
+        files: [...structuralFiles.values()].sort().map((file) => ({ file: relative(workspaceRoot, file), hash: hashFile(file) }))
+    };
+    return crypto.createHash("sha256").update(JSON.stringify(manifest)).digest("hex");
+}
+function discoverMetadataFiles(root) {
+    const result = [];
+    const excluded = new Set([".git", ".tmp", "node_modules", "dist", "out", "build"]);
+    const names = new Set(["aib.json", "package.json", "package-lock.json", "pnpm-lock.yaml", "yarn.lock", "bun.lock", "bun.lockb"]);
+    const visit = (directory) => {
+        for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+            if (entry.isSymbolicLink())
+                continue;
+            const file = path.join(directory, entry.name);
+            if (entry.isDirectory()) {
+                if (!excluded.has(entry.name))
+                    visit(file);
+            }
+            else if (entry.isFile() && (names.has(entry.name) || /^tsconfig(?:\.[^.]+)*\.json$/i.test(entry.name))) {
+                result.push(file);
+            }
+        }
+    };
+    visit(root);
+    return result;
+}
+function hashFile(file) {
+    return crypto.createHash("sha256").update(fs.readFileSync(file)).digest("hex");
+}
+function fileKey(file) {
+    const normalized = path.normalize(file);
+    return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}
+function relative(root, file) {
+    return path.relative(root, file).replace(/\\/g, "/");
+}

package/dist/mutation/runtime-cycle-query.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.queryRuntimeCycleEvidence = queryRuntimeCycleEvidence;
+function queryRuntimeCycleEvidence(edges, focusFiles) {
+    const runtimeEdges = edges.filter((edge) => edge.kind === "runtime" || edge.kind === "require")
+        .sort(compareEdges);
+    const adjacency = new Map();
+    for (const edge of runtimeEdges) {
+        adjacency.set(edge.fromFile, [...(adjacency.get(edge.fromFile) ?? []), edge]);
+    }
+    const cycles = [];
+    for (const focusFile of [...new Set(focusFiles)].sort()) {
+        let best = null;
+        for (const first of adjacency.get(focusFile) ?? []) {
+            const tail = findShortestRuntimePath(first.toFile, focusFile, adjacency);
+            if (!tail) {
+                continue;
+            }
+            const candidate = {
+                focusFile,
+                files: [focusFile, ...tail.files],
+                edges: [first, ...tail.edges]
+            };
+            if (!best || candidate.edges.length < best.edges.length ||
+                candidate.edges.length === best.edges.length && candidate.files.join("\0").localeCompare(best.files.join("\0")) < 0) {
+                best = candidate;
+            }
+        }
+        if (best) {
+            cycles.push(best);
+        }
+    }
+    return { status: "available", focusFiles: [...new Set(focusFiles)].sort(), cycles };
+}
+function findShortestRuntimePath(from, to, adjacency) {
+    if (from === to) {
+        return { files: [to], edges: [] };
+    }
+    const queue = [{
+            file: from,
+            files: [from],
+            edges: []
+        }];
+    const visited = new Set([from]);
+    for (let index = 0; index < queue.length; index += 1) {
+        const current = queue[index];
+        for (const edge of adjacency.get(current.file) ?? []) {
+            if (edge.toFile === to) {
+                return { files: [...current.files, to], edges: [...current.edges, edge] };
+            }
+            if (!visited.has(edge.toFile)) {
+                visited.add(edge.toFile);
+                queue.push({
+                    file: edge.toFile,
+                    files: [...current.files, edge.toFile],
+                    edges: [...current.edges, edge]
+                });
+            }
+        }
+    }
+    return null;
+}
+function compareEdges(left, right) {
+    return left.fromFile.localeCompare(right.fromFile) || left.toFile.localeCompare(right.toFile) ||
+        left.specifier.localeCompare(right.specifier) || left.kind.localeCompare(right.kind);
+}

package/dist/mutation/semantic-execution-progress.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSemanticExecutionProgressTracker = createSemanticExecutionProgressTracker;
+function createSemanticExecutionProgressTracker(builtBatch) {
+    const operationIds = readObjects(builtBatch.payload.operations)
+        .map((operation) => readString(operation.id))
+        .filter((id) => Boolean(id));
+    const operationIdSet = new Set(operationIds);
+    const coveredIds = new Set();
+    const sourceRows = readObjects(builtBatch.summary.rows).flatMap((row) => {
+        const ids = readObjects(row.builtRows)
+            .map((builtRow) => readString(builtRow.id))
+            .filter((id) => id !== null && operationIdSet.has(id));
+        for (const id of ids)
+            coveredIds.add(id);
+        return ids.length > 0 ? [ids] : [];
+    });
+    for (const id of operationIds) {
+        if (!coveredIds.has(id))
+            sourceRows.push([id]);
+    }
+    const finalizedIds = new Set();
+    const failedIds = new Set();
+    const finalizedSourceRows = new Set();
+    return {
+        finalize(items) {
+            let finalizedDeclarations = 0;
+            let failedDeclarations = 0;
+            for (const item of items) {
+                if (!operationIdSet.has(item.id) || finalizedIds.has(item.id))
+                    continue;
+                finalizedIds.add(item.id);
+                finalizedDeclarations += 1;
+                if (item.failed) {
+                    failedIds.add(item.id);
+                    failedDeclarations += 1;
+                }
+            }
+            let finalizedRows = 0;
+            let failedRows = 0;
+            for (const [index, ids] of sourceRows.entries()) {
+                if (finalizedSourceRows.has(index) || !ids.every((id) => finalizedIds.has(id)))
+                    continue;
+                finalizedSourceRows.add(index);
+                finalizedRows += 1;
+                if (ids.some((id) => failedIds.has(id)))
+                    failedRows += 1;
+            }
+            if (finalizedDeclarations === 0 && finalizedRows === 0)
+                return null;
+            return { finalizedRows, finalizedDeclarations, failedRows, failedDeclarations };
+        }
+    };
+}
+function readObjects(value) {
+    return Array.isArray(value) ? value.filter(isObject) : [];
+}
+function readString(value) {
+    return typeof value === "string" && value.length > 0 ? value : null;
+}
+function isObject(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}