@automaton-labs/aib 0.0.6 → 0.0.8

package/dist/mutation/semantic-move-metrics.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SEMANTIC_MOVE_METRIC_PHASES = void 0;
+exports.createSemanticMovePhaseMetrics = createSemanticMovePhaseMetrics;
+const central_metrics_1 = require("../metrics/central-metrics");
+exports.SEMANTIC_MOVE_METRIC_PHASES = [
+    "planner.discovery",
+    "planner.snapshot",
+    "planner.ownerWorkers",
+    "planner.merge",
+    "planner.validation",
+    "worker.spawn",
+    "worker.config",
+    "worker.program",
+    "worker.refactor",
+    "worker.cleanupScan",
+    "worker.cleanupRefresh",
+    "worker.cleanupOracle",
+    "worker.cleanupRender",
+    "worker.serialize",
+    "worker.terminate",
+    "transaction.prepare",
+    "transaction.apply",
+    "transaction.rollback",
+    "operation.total"
+];
+const defaultDependencies = {
+    now: () => Date.now(),
+    record: (event) => (0, central_metrics_1.recordCentralMetric)(event, { explicitlyEnabled: true })
+};
+function createSemanticMovePhaseMetrics(input, dependencies = defaultDependencies) {
+    if (!input.enabled)
+        return undefined;
+    const phases = new Map();
+    let workerCount = 0;
+    let peakWorkerRssMiB = 0;
+    let endingWorkerRssMiB = 0;
+    const unusedImportCleanup = { candidateFiles: 0, candidateBindings: 0, oracleFiles: 0, removedBindings: 0 };
+    const maxProgramFiles = { root: 0, total: 0, workspace: 0, declaration: 0, externalLibrary: 0 };
+    const ownerDivergence = Object.fromEntries(["multiOwnerFiles", "divergentProposalFiles", "policyResolvedDivergences", "unresolvedDivergences"]
+        .map((metric) => [metric, new Set()]));
+    let finished = false;
+    const add = (phase, durationMs) => {
+        if (!Number.isFinite(durationMs) || durationMs < 0)
+            return;
+        phases.set(phase, (phases.get(phase) ?? 0) + durationMs);
+    };
+    return {
+        start: () => dependencies.now(),
+        end(phase, startedAt) {
+            add(phase, Math.max(0, dependencies.now() - startedAt));
+        },
+        add,
+        observeWorker(observation) {
+            workerCount += 1;
+            add("worker.spawn", observation.spawnMs ?? 0);
+            add("worker.config", observation.phasesMs?.config ?? 0);
+            add("worker.program", observation.phasesMs?.program ?? 0);
+            add("worker.refactor", observation.phasesMs?.refactor ?? 0);
+            add("worker.cleanupScan", observation.phasesMs?.cleanupScan ?? 0);
+            add("worker.cleanupRefresh", observation.phasesMs?.cleanupRefresh ?? 0);
+            add("worker.cleanupOracle", observation.phasesMs?.cleanupOracle ?? 0);
+            add("worker.cleanupRender", observation.phasesMs?.cleanupRender ?? 0);
+            add("worker.serialize", observation.phasesMs?.serialize ?? 0);
+            add("worker.terminate", observation.terminateMs ?? 0);
+            peakWorkerRssMiB = Math.max(peakWorkerRssMiB, observation.peakRssMiB ?? 0);
+            endingWorkerRssMiB = Math.max(endingWorkerRssMiB, observation.endingRssMiB ?? 0);
+            if (observation.unusedImportCleanup) {
+                unusedImportCleanup.candidateFiles += observation.unusedImportCleanup.candidateFiles;
+                unusedImportCleanup.candidateBindings += observation.unusedImportCleanup.candidateBindings;
+                unusedImportCleanup.oracleFiles += observation.unusedImportCleanup.oracleFiles;
+                unusedImportCleanup.removedBindings += observation.unusedImportCleanup.removedBindings;
+            }
+            if (observation.programFiles) {
+                for (const key of Object.keys(maxProgramFiles)) {
+                    maxProgramFiles[key] = Math.max(maxProgramFiles[key], observation.programFiles[key]);
+                }
+            }
+        },
+        observeDivergence(metric, identity) {
+            ownerDivergence[metric].add(identity);
+        },
+        finish(finishInput) {
+            if (finished)
+                return;
+            finished = true;
+            const phaseMs = {};
+            for (const phase of exports.SEMANTIC_MOVE_METRIC_PHASES) {
+                const duration = phases.get(phase);
+                if (duration !== undefined)
+                    phaseMs[phase] = duration;
+            }
+            try {
+                dependencies.record({
+                    kind: "mutation.semanticMove.phases",
+                    operation: input.operation,
+                    cwd: input.cwd,
+                    ...(input.executionId ? { executionId: input.executionId } : {}),
+                    ok: finishInput.ok,
+                    code: finishInput.code,
+                    phaseMs,
+                    workerCount,
+                    ownerConfigCount: finishInput.ownerConfigCount,
+                    entityCount: finishInput.entityCount,
+                    editFileCount: finishInput.editFileCount,
+                    textChangeCount: finishInput.textChangeCount,
+                    ownerDivergence: Object.fromEntries(Object.entries(ownerDivergence).map(([metric, identities]) => [metric, identities.size])),
+                    unusedImportCleanup,
+                    ...(peakWorkerRssMiB > 0 ? { peakWorkerRssMiB } : {}),
+                    ...(endingWorkerRssMiB > 0 ? { endingWorkerRssMiB } : {}),
+                    ...(maxProgramFiles.total > 0 ? { maxProgramFiles } : {})
+                });
+            }
+            catch {
+                // Metrics must never change mutation behavior, even with an injected writer.
+            }
+        }
+    };
+}

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

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

package/dist/mutation/semantic-move-owner-authority.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.createSemanticMoveOwnerAuthority = createSemanticMoveOwnerAuthority;
+const path = __importStar(require("node:path"));
+const tsconfig_loader_1 = require("../topology/tsconfig-loader");
+function createSemanticMoveOwnerAuthority(discovery) {
+    const declarationBuildMappings = collectDeclarationBuildMappings(discovery.ownerConfigs);
+    return {
+        roleForConsumer(input) {
+            const edges = discovery.edges.filter((edge) => samePath(edge.fromFile, input.consumerFile));
+            if (edges.length === 0)
+                return "unproven";
+            let projectionCount = 0;
+            for (const edge of edges) {
+                const resolution = edge.ownerResolutions.find((item) => samePath(item.configFile, input.ownerConfig));
+                if (!resolution || !["resolved", "missing-generated-projection"].includes(resolution.status) || !resolution.targetFile) {
+                    return "unproven";
+                }
+                const resolvedTarget = resolution.targetFile;
+                if (samePath(resolvedTarget, edge.targetFile))
+                    return "source-authority";
+                if (!edge.alternateTargetFiles?.some((file) => samePath(file, resolvedTarget))) {
+                    return "unproven";
+                }
+                if (!declarationBuildMappings.some((mapping) => provesDeclarationProjection(mapping, edge.targetFile, resolvedTarget))) {
+                    return "unproven";
+                }
+                projectionCount += 1;
+            }
+            return projectionCount === edges.length
+                ? "generated-declaration-projection"
+                : "unproven";
+        }
+    };
+}
+function collectDeclarationBuildMappings(configFiles) {
+    const mappings = [];
+    for (const configFile of configFiles) {
+        const diagnostics = [];
+        const parsed = (0, tsconfig_loader_1.parseTsConfig)(configFile, diagnostics);
+        if (!parsed || diagnostics.length > 0)
+            continue;
+        const options = parsed.parsed.options;
+        // Require an explicit reversible source-to-output mapping. Config names and the mere presence
+        // of a .d.ts file are deliberately not evidence that the declaration is generated.
+        const declarationDir = options.declarationDir ?? options.outDir;
+        if (!options.rootDir || !declarationDir || options.noEmit === true ||
+            (options.declaration !== true && options.composite !== true)) {
+            continue;
+        }
+        mappings.push({
+            rootDir: path.resolve(options.rootDir),
+            declarationDir: path.resolve(declarationDir),
+            sourceFiles: new Set(parsed.parsed.fileNames.map(pathKey))
+        });
+    }
+    return mappings;
+}
+function provesDeclarationProjection(mapping, sourceFile, declarationFile) {
+    const source = path.resolve(sourceFile);
+    if (!mapping.sourceFiles.has(pathKey(source)))
+        return false;
+    const relative = path.relative(mapping.rootDir, source);
+    if (!relative || relative.startsWith("..") || path.isAbsolute(relative))
+        return false;
+    const declarationRelative = declarationPath(relative);
+    if (!declarationRelative)
+        return false;
+    return samePath(path.join(mapping.declarationDir, declarationRelative), declarationFile);
+}
+function declarationPath(relativeSource) {
+    const normalized = relativeSource.replace(/\\/g, "/");
+    if (/\.d\.(?:ts|mts|cts)$/i.test(normalized))
+        return null;
+    if (/\.mts$/i.test(normalized))
+        return normalized.replace(/\.mts$/i, ".d.mts");
+    if (/\.cts$/i.test(normalized))
+        return normalized.replace(/\.cts$/i, ".d.cts");
+    if (/\.(?:tsx?|jsx?)$/i.test(normalized))
+        return normalized.replace(/\.(?:tsx?|jsx?)$/i, ".d.ts");
+    return null;
+}
+function samePath(left, right) {
+    return pathKey(left) === pathKey(right);
+}
+function pathKey(file) {
+    const normalized = path.normalize(path.resolve(file));
+    return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}

package/dist/mutation/semantic-move-owner-candidates.js

@@ -0,0 +1,300 @@
+"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.createSemanticMoveModuleSpecifierResolver = createSemanticMoveModuleSpecifierResolver;
+exports.createSemanticMoveCanonicalModuleResolver = createSemanticMoveCanonicalModuleResolver;
+exports.reconcileSemanticMoveNewTargetCandidates = reconcileSemanticMoveNewTargetCandidates;
+exports.reconcileSemanticMoveOwnerCandidates = reconcileSemanticMoveOwnerCandidates;
+const path = __importStar(require("node:path"));
+const typescript_1 = __importDefault(require("typescript"));
+const tsconfig_loader_1 = require("../topology/tsconfig-loader");
+function createSemanticMoveModuleSpecifierResolver() {
+    const ownerOptions = new Map();
+    return (input) => input.ownerConfigs.every((configFile) => {
+        const key = pathKey(configFile);
+        let options = ownerOptions.get(key);
+        if (options === undefined) {
+            options = readOwnerOptions(configFile);
+            ownerOptions.set(key, options);
+        }
+        return options !== null && resolvesToExactVirtualTarget({
+            specifier: input.specifier,
+            containingFile: input.containingFile,
+            targetFile: input.targetFile,
+            options
+        });
+    });
+}
+function createSemanticMoveCanonicalModuleResolver() {
+    const ownerOptions = new Map();
+    return (input) => {
+        const resolvedTargets = new Set();
+        for (const configFile of input.ownerConfigs) {
+            const key = pathKey(configFile);
+            let options = ownerOptions.get(key);
+            if (options === undefined) {
+                options = readOwnerOptions(configFile);
+                ownerOptions.set(key, options);
+            }
+            if (!options)
+                return null;
+            const resolved = resolveModuleTarget({
+                specifier: input.specifier,
+                containingFile: input.containingFile,
+                options
+            });
+            if (!resolved)
+                return null;
+            resolvedTargets.add(pathKey(resolved));
+        }
+        return resolvedTargets.size === 1 ? [...resolvedTargets][0] : null;
+    };
+}
+function reconcileSemanticMoveNewTargetCandidates(input) {
+    const candidates = uniqueFinalTextCandidates("", input.observations, true);
+    if (candidates.length === 0)
+        return { status: "not-module-specifier-only" };
+    if (candidates.length === 1)
+        return { status: "selected", edit: candidates[0].edit };
+    const first = candidates[0].view;
+    if (candidates.some((candidate) => candidate.view.skeleton !== first.skeleton ||
+        candidate.view.specifiers.length !== first.specifiers.length)) {
+        return { status: "not-module-specifier-only" };
+    }
+    const differingIndices = first.specifiers
+        .map((_, index) => index)
+        .filter((index) => new Set(candidates.map((candidate) => candidate.view.specifiers[index])).size > 1);
+    if (differingIndices.length === 0)
+        return { status: "not-module-specifier-only" };
+    const resolves = input.resolver ?? createSemanticMoveCanonicalModuleResolver();
+    const sourceSpecifiers = moduleSpecifierView(input.sourceFile, input.sourceText)?.specifiers ?? [];
+    let valid = candidates;
+    for (const index of differingIndices) {
+        const resolvedByCandidate = valid.map((candidate) => {
+            const specifier = candidate.view.specifiers[index];
+            return {
+                candidate,
+                target: specifier === undefined ? null : resolves({
+                    specifier,
+                    containingFile: input.fileName,
+                    ownerConfigs: input.ownerConfigs
+                })
+            };
+        });
+        const resolved = resolvedByCandidate.filter((item) => item.target !== null);
+        if (resolved.length === 0)
+            return { status: "none-valid" };
+        valid = resolved.map((item) => item.candidate);
+        if (valid.length === 1)
+            continue;
+        const target = resolved[0].target;
+        if (resolved.some((item) => item.target !== target)) {
+            return { status: "not-module-specifier-only" };
+        }
+        const preferredEnding = input.preferredEnding && input.preferredEnding !== "auto"
+            ? input.preferredEnding
+            : sourceEndingForTarget({
+                sourceFile: input.sourceFile,
+                sourceSpecifiers,
+                target,
+                ownerConfigs: input.ownerConfigs,
+                resolver: resolves
+            });
+        if (!preferredEnding) {
+            return { status: "ambiguous", validCandidateCount: valid.length, edit: valid[0].edit };
+        }
+        valid = valid.filter((candidate) => importEnding(candidate.view.specifiers[index]) === preferredEnding);
+        if (valid.length === 0)
+            return { status: "none-valid" };
+    }
+    return valid.length === 1
+        ? { status: "selected", edit: valid[0].edit }
+        : { status: "ambiguous", validCandidateCount: valid.length, edit: valid[0].edit };
+}
+function reconcileSemanticMoveOwnerCandidates(input) {
+    const candidates = uniqueFinalTextCandidates(input.expectedText, input.observations);
+    if (candidates.length === 0)
+        return { status: "not-module-specifier-only" };
+    if (candidates.length === 1)
+        return { status: "selected", edit: candidates[0].edit };
+    const first = candidates[0].view;
+    if (candidates.some((candidate) => candidate.view.skeleton !== first.skeleton ||
+        candidate.view.specifiers.length !== first.specifiers.length)) {
+        return { status: "not-module-specifier-only" };
+    }
+    const differingIndices = first.specifiers
+        .map((_, index) => index)
+        .filter((index) => new Set(candidates.map((candidate) => candidate.view.specifiers[index])).size > 1);
+    if (differingIndices.length === 0)
+        return { status: "not-module-specifier-only" };
+    const resolves = input.resolver ?? createSemanticMoveModuleSpecifierResolver();
+    const valid = candidates.filter((candidate) => differingIndices.every((index) => {
+        const specifier = candidate.view.specifiers[index];
+        return specifier !== undefined && resolves({
+            specifier,
+            containingFile: input.fileName,
+            targetFile: input.targetFile,
+            ownerConfigs: input.ownerConfigs
+        });
+    }));
+    if (valid.length === 1)
+        return { status: "selected", edit: valid[0].edit };
+    return valid.length === 0
+        ? { status: "none-valid" }
+        : { status: "ambiguous", validCandidateCount: valid.length, edit: valid[0].edit };
+}
+function uniqueFinalTextCandidates(expectedText, observations, allowNewFile = false) {
+    const candidates = new Map();
+    for (const edit of observations) {
+        if (edit.isNewFile !== allowNewFile)
+            return [];
+        const finalText = applyTextChanges(expectedText, edit.textChanges);
+        if (candidates.has(finalText))
+            continue;
+        const view = moduleSpecifierView(edit.fileName, finalText);
+        if (!view)
+            return [];
+        candidates.set(finalText, { edit, finalText, view });
+    }
+    return [...candidates.values()];
+}
+function sourceEndingForTarget(input) {
+    const endings = new Set(input.sourceSpecifiers.flatMap((specifier) => input.resolver({
+        specifier,
+        containingFile: input.sourceFile,
+        ownerConfigs: input.ownerConfigs
+    }) === input.target
+        ? [importEnding(specifier)]
+        : []));
+    return endings.size === 1 ? [...endings][0] : null;
+}
+function importEnding(specifier) {
+    return /\.(?:[cm]?js|jsx)$/i.test(specifier) ? "js" : "minimal";
+}
+function moduleSpecifierView(fileName, text) {
+    const source = typescript_1.default.createSourceFile(fileName, text, typescript_1.default.ScriptTarget.Latest, true, scriptKindForFile(fileName));
+    const parseDiagnostics = source.parseDiagnostics ?? [];
+    if (parseDiagnostics.length > 0)
+        return null;
+    const literals = [];
+    const add = (node) => {
+        if (node && typescript_1.default.isStringLiteralLike(node))
+            literals.push(node);
+    };
+    const visit = (node) => {
+        if (typescript_1.default.isImportDeclaration(node) || typescript_1.default.isExportDeclaration(node)) {
+            add(node.moduleSpecifier);
+        }
+        else if (typescript_1.default.isImportEqualsDeclaration(node) && typescript_1.default.isExternalModuleReference(node.moduleReference)) {
+            add(node.moduleReference.expression);
+        }
+        else if (typescript_1.default.isImportTypeNode(node)) {
+            add(typescript_1.default.isLiteralTypeNode(node.argument) ? node.argument.literal : undefined);
+        }
+        else if (typescript_1.default.isCallExpression(node) && node.arguments.length === 1 &&
+            (node.expression.kind === typescript_1.default.SyntaxKind.ImportKeyword ||
+                typescript_1.default.isIdentifier(node.expression) && node.expression.text === "require")) {
+            add(node.arguments[0]);
+        }
+        typescript_1.default.forEachChild(node, visit);
+    };
+    visit(source);
+    const ordered = literals
+        .map((literal) => ({ start: literal.getStart(source) + 1, length: literal.text.length, text: literal.text }))
+        .sort((left, right) => left.start - right.start);
+    let cursor = 0;
+    let skeleton = "";
+    for (const [index, literal] of ordered.entries()) {
+        skeleton += `${text.slice(cursor, literal.start)}<aib-module-${index}>`;
+        cursor = literal.start + literal.length;
+    }
+    skeleton += text.slice(cursor);
+    return { skeleton, specifiers: ordered.map((literal) => literal.text) };
+}
+function readOwnerOptions(configFile) {
+    const diagnostics = [];
+    const parsed = (0, tsconfig_loader_1.parseTsConfig)(configFile, diagnostics);
+    return parsed && diagnostics.length === 0 ? parsed.parsed.options : null;
+}
+function resolvesToExactVirtualTarget(input) {
+    const target = path.resolve(input.targetFile);
+    const resolved = resolveModuleTarget(input);
+    return Boolean(resolved && samePath(resolved, target));
+}
+function resolveModuleTarget(input) {
+    const target = input.targetFile ? path.resolve(input.targetFile) : null;
+    const host = {
+        fileExists: (file) => Boolean(target && samePath(file, target)) || typescript_1.default.sys.fileExists(file),
+        readFile: (file) => target && samePath(file, target) ? "" : typescript_1.default.sys.readFile(file),
+        directoryExists: typescript_1.default.sys.directoryExists,
+        getCurrentDirectory: typescript_1.default.sys.getCurrentDirectory,
+        getDirectories: typescript_1.default.sys.getDirectories,
+        realpath: (file) => target && samePath(file, target) ? target : typescript_1.default.sys.realpath?.(file) ?? file
+    };
+    const resolved = typescript_1.default.resolveModuleName(input.specifier, input.containingFile, input.options, host).resolvedModule?.resolvedFileName;
+    return resolved ? path.resolve(resolved) : null;
+}
+function applyTextChanges(text, changes) {
+    const ordered = [...changes].sort((left, right) => left.span.start - right.span.start || left.span.length - right.span.length);
+    let cursor = 0;
+    let output = "";
+    for (const change of ordered) {
+        if (change.span.start < cursor || change.span.start + change.span.length > text.length)
+            return "";
+        output += text.slice(cursor, change.span.start) + change.newText;
+        cursor = change.span.start + change.span.length;
+    }
+    return output + text.slice(cursor);
+}
+function scriptKindForFile(file) {
+    switch (path.extname(file).toLowerCase()) {
+        case ".tsx": return typescript_1.default.ScriptKind.TSX;
+        case ".jsx": return typescript_1.default.ScriptKind.JSX;
+        case ".js":
+        case ".mjs":
+        case ".cjs": return typescript_1.default.ScriptKind.JS;
+        default: return typescript_1.default.ScriptKind.TS;
+    }
+}
+function samePath(left, right) {
+    return pathKey(left) === pathKey(right);
+}
+function pathKey(file) {
+    const resolved = path.resolve(file);
+    return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+}