@automaton-labs/aib 0.0.7 → 0.0.8

package/dist/alias-advisor/exact-text-cost.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.estimateAliasExactTextCost = estimateAliasExactTextCost;
+function estimateAliasExactTextCost(input) {
+    const occurrenceSavings = new Map();
+    let sourceCurrent = 0;
+    let sourceProjected = 0;
+    for (let index = 0; index < input.currentSpecifiers.length; index += 1) {
+        const currentSpecifier = input.currentSpecifiers[index] ?? "";
+        const projectedSpecifier = input.projectedSpecifiers[index] ?? currentSpecifier;
+        const currentLiteral = input.currentLiterals[index] ?? JSON.stringify(currentSpecifier);
+        const projectedLiteral = rewriteLiteral(currentLiteral, projectedSpecifier);
+        sourceCurrent += currentLiteral.length;
+        sourceProjected += projectedLiteral.length;
+        occurrenceSavings.set(input.occurrenceIds[index] ?? String(index), currentLiteral.length - projectedLiteral.length);
+    }
+    const byTsconfig = input.intent === "createAlias"
+        ? input.applicableTsconfigs
+            .filter((config) => Boolean(config.mappingTarget))
+            .map((config) => {
+            const snippet = `${JSON.stringify(input.alias)}: [${JSON.stringify(config.mappingTarget)}]`;
+            return { tsconfig: config.tsconfig, snippet, characters: snippet.length };
+        })
+        : [];
+    const resolverMirrors = input.resolverMirror ? (() => {
+        const snippet = `${JSON.stringify(input.alias)}: ${JSON.stringify(input.resolverMirror.target)}`;
+        return [{ kind: "package-imports", status: "required", snippet, characters: snippet.length }];
+    })() : [];
+    const oneTimeTotal = byTsconfig.reduce((sum, item) => sum + item.characters, 0)
+        + resolverMirrors.reduce((sum, item) => sum + item.characters, 0);
+    const sourceReduction = sourceCurrent - sourceProjected;
+    const netReduction = sourceReduction - oneTimeTotal;
+    const positiveSavings = [...occurrenceSavings.values()].filter((value) => value > 0);
+    const averageSaving = positiveSavings.length > 0
+        ? positiveSavings.reduce((sum, value) => sum + value, 0) / positiveSavings.length
+        : 0;
+    return {
+        cost: {
+            boundary: "source-module-specifier-literals-and-proposed-config-snippets",
+            sourceLiterals: {
+                current: sourceCurrent,
+                projected: sourceProjected,
+                reduction: sourceReduction,
+                relativeReduction: ratio(sourceReduction, sourceCurrent)
+            },
+            oneTimeConfigCharacters: {
+                total: oneTimeTotal,
+                byTsconfig,
+                resolverMirrors
+            },
+            netReduction: {
+                absolute: netReduction,
+                relative: ratio(netReduction, sourceCurrent)
+            },
+            paybackOccurrences: averageSaving > 0 ? Math.ceil(oneTimeTotal / averageSaving) : null
+        },
+        occurrenceSavings
+    };
+}
+function rewriteLiteral(currentLiteral, projectedSpecifier) {
+    const quote = currentLiteral.startsWith("'") ? "'" : currentLiteral.startsWith('"') ? '"' : null;
+    if (!quote || !currentLiteral.endsWith(quote)) {
+        return JSON.stringify(projectedSpecifier);
+    }
+    const escaped = projectedSpecifier
+        .replace(/\\/g, "\\\\")
+        .replace(new RegExp(quote, "g"), `\\${quote}`)
+        .replace(/\r/g, "\\r")
+        .replace(/\n/g, "\\n");
+    return `${quote}${escaped}${quote}`;
+}
+function ratio(numerator, denominator) {
+    return denominator === 0 ? 0 : numerator / denominator;
+}

package/dist/alias-advisor/lexical.js

@@ -0,0 +1,240 @@
+"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.collectAliasLexicalEvidence = collectAliasLexicalEvidence;
+exports.rewriteSpecifier = rewriteSpecifier;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const typescript_1 = __importDefault(require("typescript"));
+const path_display_1 = require("../config/path-display");
+const DEFAULT_EXCLUDES = [
+    "node_modules/**",
+    "**/node_modules/**",
+    ".git/**",
+    "**/.git/**",
+    "dist/**",
+    "**/dist/**",
+    "build/**",
+    "**/build/**",
+    "out/**",
+    "**/out/**",
+    ".tmp/**",
+    "**/.tmp/**",
+    "**/*.d.ts"
+];
+const SOURCE_EXTENSIONS = new Set([".ts", ".tsx", ".mts", ".cts"]);
+function collectAliasLexicalEvidence(options) {
+    const startedAt = Date.now();
+    const includeMatchers = options.include.map(globToRegExp);
+    const excludeMatchers = [...DEFAULT_EXCLUDES, ...options.exclude].map(globToRegExp);
+    const files = collectSourceFiles(options.cwd, options.scope, includeMatchers, excludeMatchers);
+    const occurrences = files.flatMap((file) => readImportOccurrences(options.cwd, file, options.aliases));
+    const evidence = buildLexicalEvidence(occurrences, options.minImports, options.minFiles);
+    return {
+        files,
+        occurrences,
+        evidence,
+        elapsedMs: Date.now() - startedAt
+    };
+}
+function collectSourceFiles(cwd, scope, includeMatchers, excludeMatchers) {
+    const result = [];
+    const visit = (directory) => {
+        const entries = fs.readdirSync(directory, { withFileTypes: true })
+            .sort((left, right) => Number(right.isDirectory()) - Number(left.isDirectory()) || left.name.localeCompare(right.name));
+        for (const entry of entries) {
+            const absolute = path.join(directory, entry.name);
+            const relative = toDisplayPath(cwd, absolute).replace(/\\/g, "/");
+            if (matchesAnyPath(excludeMatchers, relative)) {
+                continue;
+            }
+            if (entry.isDirectory()) {
+                visit(absolute);
+                continue;
+            }
+            if (!isSourceFile(absolute)) {
+                continue;
+            }
+            if (includeMatchers.length > 0 && !matchesAnyPath(includeMatchers, relative)) {
+                continue;
+            }
+            result.push(absolute);
+        }
+    };
+    visit(scope);
+    return result;
+}
+function readImportOccurrences(cwd, file, aliases) {
+    const text = fs.readFileSync(file, "utf8");
+    const displayImporter = (0, path_display_1.compactDisplayPath)(cwd, file, aliases).replace(/\\/g, "/");
+    return typescript_1.default.preProcessFile(text, true, true).importedFiles.map((importedFile) => ({
+        importer: path.resolve(file),
+        displayImporter,
+        specifier: importedFile.fileName,
+        literal: text.slice(importedFile.pos, importedFile.end + 2),
+        position: importedFile.pos
+    }));
+}
+function buildLexicalEvidence(occurrences, minImports, minFiles) {
+    const byPrefix = new Map();
+    for (const occurrence of occurrences) {
+        if (!isPrefixCandidateSpecifier(occurrence.specifier)) {
+            continue;
+        }
+        for (const prefix of derivePrefixes(occurrence.specifier)) {
+            byPrefix.set(prefix, [...(byPrefix.get(prefix) ?? []), occurrence]);
+        }
+    }
+    const evidence = [];
+    for (const [prefix, items] of byPrefix) {
+        const importingFiles = unique(items.map((item) => item.displayImporter));
+        if (items.length < minImports || importingFiles.length < minFiles) {
+            continue;
+        }
+        const suggestedAliases = suggestAliases(prefix);
+        if (suggestedAliases.length === 0) {
+            continue;
+        }
+        const currentCharacters = items.reduce((sum, item) => sum + item.specifier.length, 0);
+        const byAlias = suggestedAliases.map((alias) => {
+            const projected = items.reduce((sum, item) => sum + rewriteSpecifier(item.specifier, prefix, alias).length, 0);
+            return { alias, projected, delta: currentCharacters - projected };
+        });
+        evidence.push({
+            prefix,
+            segmentDepth: prefix.split("/").filter(Boolean).length,
+            occurrences: items,
+            importCount: items.length,
+            importingFileCount: importingFiles.length,
+            targetSuffixCount: unique(items.map((item) => item.specifier.slice(prefix.length)).filter(Boolean)).length,
+            suggestedAliases,
+            sourceCharacters: {
+                current: currentCharacters,
+                byAlias
+            },
+            parentPrefixes: [],
+            childPrefixes: []
+        });
+    }
+    applyOverlap(evidence);
+    return evidence.sort((left, right) => bestCharacterDelta(right) - bestCharacterDelta(left) ||
+        right.importCount - left.importCount ||
+        right.importingFileCount - left.importingFileCount ||
+        left.prefix.localeCompare(right.prefix));
+}
+function rewriteSpecifier(specifier, prefix, alias) {
+    return `${alias.replace(/\*$/, "")}${specifier.slice(prefix.length)}`;
+}
+function derivePrefixes(specifier) {
+    const parts = specifier.split("/").filter(Boolean);
+    if (parts.length < 3) {
+        return [];
+    }
+    const result = [];
+    for (let depth = 2; depth <= Math.min(parts.length - 1, 5); depth += 1) {
+        const prefix = `${parts.slice(0, depth).join("/")}/`;
+        if (prefix.length < specifier.length) {
+            result.push(prefix);
+        }
+    }
+    return result;
+}
+function suggestAliases(prefix) {
+    const segment = prefix.split("/").filter(Boolean).at(-1);
+    if (!segment) {
+        return [];
+    }
+    const aliasBase = segment
+        .replace(/[^a-zA-Z0-9_-]+/g, "-")
+        .split(/[-_]+/)
+        .filter(Boolean)
+        .map((part, index) => index === 0 ? part : `${part.slice(0, 1).toUpperCase()}${part.slice(1)}`)
+        .join("");
+    return aliasBase ? [`@${aliasBase}/*`, `#${aliasBase}/*`] : [];
+}
+function applyOverlap(evidence) {
+    for (const candidate of evidence) {
+        candidate.parentPrefixes = evidence
+            .filter((item) => item.prefix !== candidate.prefix && candidate.prefix.startsWith(item.prefix))
+            .map((item) => item.prefix)
+            .sort();
+        candidate.childPrefixes = evidence
+            .filter((item) => item.prefix !== candidate.prefix && item.prefix.startsWith(candidate.prefix))
+            .map((item) => item.prefix)
+            .sort();
+    }
+}
+function bestCharacterDelta(evidence) {
+    return Math.max(0, ...evidence.sourceCharacters.byAlias.map((item) => item.delta));
+}
+function isPrefixCandidateSpecifier(specifier) {
+    return !specifier.startsWith(".") && specifier.includes("/");
+}
+function isSourceFile(file) {
+    return !file.endsWith(".d.ts") && SOURCE_EXTENSIONS.has(path.extname(file));
+}
+function globToRegExp(pattern) {
+    const normalized = pattern.replace(/\\/g, "/").replace(/^\.?\//, "");
+    let source = "";
+    for (let index = 0; index < normalized.length; index += 1) {
+        const char = normalized[index];
+        if (char === "*") {
+            if (normalized[index + 1] === "*") {
+                source += ".*";
+                index += 1;
+            }
+            else {
+                source += "[^/]*";
+            }
+        }
+        else {
+            source += char.replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
+        }
+    }
+    return new RegExp(`^${source}$`);
+}
+function matchesAnyPath(matchers, relative) {
+    return matchers.some((matcher) => matcher.test(relative) || matcher.test(`${relative}/`));
+}
+function toDisplayPath(cwd, file) {
+    const relative = path.relative(cwd, file);
+    return (relative && !relative.startsWith("..") && !path.isAbsolute(relative) ? relative : file).replace(/\\/g, "/");
+}
+function unique(items) {
+    return [...new Set(items)];
+}

package/dist/alias-advisor/model.js

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

package/dist/alias-advisor/path-identity.js

@@ -0,0 +1,49 @@
+"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.canonicalPathIdentity = canonicalPathIdentity;
+exports.sameCanonicalPath = sameCanonicalPath;
+const path = __importStar(require("node:path"));
+const typescript_1 = __importDefault(require("typescript"));
+function canonicalPathIdentity(file, useCaseSensitiveFileNames = typescript_1.default.sys.useCaseSensitiveFileNames) {
+    const resolved = path.resolve(file).replace(/\\/g, "/");
+    return useCaseSensitiveFileNames ? resolved : resolved.toLowerCase();
+}
+function sameCanonicalPath(left, right, useCaseSensitiveFileNames = typescript_1.default.sys.useCaseSensitiveFileNames) {
+    return canonicalPathIdentity(left, useCaseSensitiveFileNames) === canonicalPathIdentity(right, useCaseSensitiveFileNames);
+}

package/dist/alias-advisor/ranking.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROVISIONAL_ALIAS_TEXT_DECISION_THRESHOLDS = void 0;
+exports.rankAliasCandidates = rankAliasCandidates;
+exports.PROVISIONAL_ALIAS_TEXT_DECISION_THRESHOLDS = {
+    minImports: 8,
+    minFiles: 4,
+    materialNetCharacters: 64
+};
+function rankAliasCandidates(input) {
+    const builds = input.map((item) => ({
+        ...item,
+        occurrenceIds: new Set(item.exactTextOccurrenceSavings.keys())
+    }));
+    for (const build of builds) {
+        build.candidate.ranking = initialRanking(build.candidate);
+    }
+    applyOverlapRelations(builds);
+    applyDominance(builds);
+    const sorted = [...builds].sort(compareBuilds);
+    const covered = new Set();
+    for (let index = 0; index < sorted.length; index += 1) {
+        const build = sorted[index];
+        const uncovered = [...build.occurrenceIds].filter((id) => !covered.has(id));
+        const marginalTextReduction = uncovered.reduce((sum, id) => sum + Math.max(0, build.exactTextOccurrenceSavings.get(id) ?? 0), 0);
+        const marginalTokenSaving = uncovered.reduce((sum, id) => sum + Math.max(0, build.occurrenceSavings.get(id) ?? 0), 0);
+        build.candidate.overlap.marginalImports = uncovered.length;
+        build.candidate.overlap.marginalTextReduction = marginalTextReduction;
+        build.candidate.overlap.marginalNetTextReduction = marginalTextReduction - build.candidate.decisionEvidence.exactText.oneTimeConfigCharacters.total;
+        build.candidate.overlap.marginalTokenSaving = marginalTokenSaving - build.candidate.tokenCost.oneTimeConfigTokenCost.total;
+        build.candidate.ranking.ordinal = index + 1;
+        if (build.candidate.ranking.category !== "rejected") {
+            for (const id of build.occurrenceIds) {
+                covered.add(id);
+            }
+        }
+    }
+    return sorted.map((item) => item.candidate);
+}
+function initialRanking(candidate) {
+    const hardRejected = candidate.disposition === "rejected" || candidate.conflicts.length > 0;
+    const breadth = candidate.decisionEvidence.breadth.meetsThreshold;
+    const exactNet = candidate.decisionEvidence.exactText.netReduction.absolute;
+    const recommendable = candidate.decisionEvidence.winsKeepCurrentAliases
+        && candidate.boundaryRisk.level === "low"
+        && candidate.confidence.level === "high";
+    let category;
+    const reasons = [];
+    if (hardRejected) {
+        category = "rejected";
+        reasons.push("M2 hard gate rejected this candidate before scoring");
+    }
+    else if (candidate.intent === "adoptExistingAlias" && recommendable) {
+        category = "recommended";
+        reasons.push("existing alias clears provisional breadth, confidence, risk, and conservative net thresholds");
+    }
+    else if (breadth && exactNet > 0) {
+        category = "review";
+        reasons.push(candidate.intent === "createAlias"
+            ? "create alias is capped at review until config and runtime support are accepted"
+            : "positive candidate does not clear every provisional recommendation threshold");
+    }
+    else {
+        category = "optional";
+        reasons.push(exactNet <= 0 ? "exact one-time config text is not repaid by this repository snapshot" : "candidate is below provisional breadth thresholds");
+    }
+    const score = hardRejected ? 0 : Math.max(0, exactNet)
+        + Math.min(candidate.coverage.imports, 100)
+        + candidate.coverage.files * 2;
+    return {
+        policyVersion: "alias-ranking-v2-text-primary",
+        category,
+        ordinal: 0,
+        score,
+        scoreComponents: {
+            exactNetTextReduction: exactNet,
+            imports: candidate.coverage.imports,
+            files: candidate.coverage.files,
+            confidence: candidate.confidence.level,
+            estimatorConfidence: candidate.tokenCost.profile.confidence
+        },
+        reasons
+    };
+}
+function applyOverlapRelations(builds) {
+    for (const build of builds) {
+        delete build.candidate.overlap.dominatedBy;
+        build.candidate.overlap.marginalImports = 0;
+        build.candidate.overlap.marginalTextReduction = 0;
+        build.candidate.overlap.marginalNetTextReduction = 0;
+        build.candidate.overlap.marginalTokenSaving = 0;
+        const parents = [];
+        const children = [];
+        let exclusiveImports = 0;
+        let exclusiveTextReduction = 0;
+        for (const id of build.occurrenceIds) {
+            if (!builds.some((other) => other !== build && other.occurrenceIds.has(id))) {
+                exclusiveImports += 1;
+                exclusiveTextReduction += Math.max(0, build.exactTextOccurrenceSavings.get(id) ?? 0);
+            }
+        }
+        for (const other of builds) {
+            if (other === build) {
+                continue;
+            }
+            const sharedImports = intersectionSize(build.occurrenceIds, other.occurrenceIds);
+            if (sharedImports === 0) {
+                continue;
+            }
+            if (build.candidate.sourcePrefix.startsWith(other.candidate.sourcePrefix)) {
+                parents.push({ candidateId: other.candidate.id, prefix: other.candidate.sourcePrefix, sharedImports });
+            }
+            else if (other.candidate.sourcePrefix.startsWith(build.candidate.sourcePrefix)) {
+                children.push({ candidateId: other.candidate.id, prefix: other.candidate.sourcePrefix, sharedImports });
+            }
+        }
+        build.candidate.overlap.parents = parents.sort(compareRelations);
+        build.candidate.overlap.children = children.sort(compareRelations);
+        build.candidate.overlap.exclusiveImports = exclusiveImports;
+        build.candidate.overlap.exclusiveTextReduction = exclusiveTextReduction;
+    }
+}
+function applyDominance(builds) {
+    for (const build of builds) {
+        if (build.candidate.ranking.category === "rejected") {
+            continue;
+        }
+        const dominators = builds
+            .filter((other) => other !== build && other.candidate.ranking.category !== "rejected")
+            .filter((other) => isSuperset(other.occurrenceIds, build.occurrenceIds))
+            .filter((other) => other.candidate.decisionEvidence.exactText.oneTimeConfigCharacters.total <= build.candidate.decisionEvidence.exactText.oneTimeConfigCharacters.total)
+            .filter((other) => [...build.occurrenceIds].every((id) => (other.exactTextOccurrenceSavings.get(id) ?? Number.NEGATIVE_INFINITY) >= (build.exactTextOccurrenceSavings.get(id) ?? 0)))
+            .filter((other) => compareBuilds(other, build) < 0)
+            .sort(compareBuilds);
+        const dominator = dominators[0];
+        if (!dominator) {
+            continue;
+        }
+        build.candidate.overlap.dominatedBy = dominator.candidate.id;
+        build.candidate.ranking.category = "optional";
+        build.candidate.ranking.reasons.push(`dominated by ${dominator.candidate.alias} over the same covered imports`);
+    }
+}
+function compareBuilds(left, right) {
+    return categoryOrder(right.candidate.ranking.category) - categoryOrder(left.candidate.ranking.category)
+        || right.candidate.ranking.score - left.candidate.ranking.score
+        || right.candidate.decisionEvidence.exactText.netReduction.absolute - left.candidate.decisionEvidence.exactText.netReduction.absolute
+        || right.candidate.coverage.imports - left.candidate.coverage.imports
+        || right.candidate.coverage.files - left.candidate.coverage.files
+        || left.candidate.alias.localeCompare(right.candidate.alias)
+        || left.candidate.sourcePrefix.localeCompare(right.candidate.sourcePrefix)
+        || left.candidate.id.localeCompare(right.candidate.id);
+}
+function categoryOrder(category) {
+    return category === "recommended" ? 4 : category === "review" ? 3 : category === "optional" ? 2 : 1;
+}
+function compareRelations(left, right) {
+    return right.sharedImports - left.sharedImports || left.prefix.localeCompare(right.prefix) || left.candidateId.localeCompare(right.candidateId);
+}
+function intersectionSize(left, right) {
+    let count = 0;
+    for (const item of left) {
+        if (right.has(item)) {
+            count += 1;
+        }
+    }
+    return count;
+}
+function isSuperset(superset, subset) {
+    return [...subset].every((item) => superset.has(item));
+}

package/dist/alias-advisor/token-estimator.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PathLexicalV1Estimator = exports.PATH_LEXICAL_V1_PROFILE = void 0;
+exports.estimateAliasTokenCost = estimateAliasTokenCost;
+exports.PATH_LEXICAL_V1_PROFILE = {
+    id: "path-lexical-v1",
+    version: 1,
+    status: "estimated",
+    confidence: "low",
+    exactBillingEstimate: false,
+    boundary: "quoted-module-specifier-and-proposed-jsonc-paths-entry"
+};
+class PathLexicalV1Estimator {
+    profile = exports.PATH_LEXICAL_V1_PROFILE;
+    estimate(text, purpose) {
+        return {
+            tokens: lexicalUnits(text).length,
+            purpose
+        };
+    }
+}
+exports.PathLexicalV1Estimator = PathLexicalV1Estimator;
+function estimateAliasTokenCost(input) {
+    const occurrenceSavings = new Map();
+    let sourceTokenCurrent = 0;
+    let sourceTokenProjected = 0;
+    for (let index = 0; index < input.currentSpecifiers.length; index += 1) {
+        const current = input.currentSpecifiers[index] ?? "";
+        const projected = input.projectedSpecifiers[index] ?? current;
+        if (current === projected) {
+            occurrenceSavings.set(input.occurrenceIds[index] ?? String(index), 0);
+            continue;
+        }
+        const currentTokens = input.estimator.estimate(JSON.stringify(current), "quotedModuleSpecifier").tokens;
+        const projectedTokens = input.estimator.estimate(JSON.stringify(projected), "quotedModuleSpecifier").tokens;
+        sourceTokenCurrent += currentTokens;
+        sourceTokenProjected += projectedTokens;
+        occurrenceSavings.set(input.occurrenceIds[index] ?? String(index), currentTokens - projectedTokens);
+    }
+    const byTsconfig = input.intent === "createAlias"
+        ? input.applicableTsconfigs
+            .filter((config) => Boolean(config.mappingTarget))
+            .map((config) => {
+            const snippet = `${JSON.stringify(input.alias)}: [${JSON.stringify(config.mappingTarget)}]`;
+            return {
+                tsconfig: config.tsconfig,
+                snippet,
+                estimatedTokens: input.estimator.estimate(snippet, "jsoncPathsEntry").tokens
+            };
+        })
+        : [];
+    const resolverMirrors = input.resolverMirror ? [{
+            kind: "package-imports",
+            status: "required",
+            snippet: `${JSON.stringify(input.alias)}: ${JSON.stringify(input.resolverMirror.target)}`,
+            estimatedTokens: input.estimator.estimate(`${JSON.stringify(input.alias)}: ${JSON.stringify(input.resolverMirror.target)}`, "resolverMirrorEntry").tokens
+        }] : [];
+    const oneTimeTotal = byTsconfig.reduce((sum, item) => sum + item.estimatedTokens, 0)
+        + resolverMirrors.reduce((sum, item) => sum + item.estimatedTokens, 0);
+    const sourceTokenDelta = sourceTokenCurrent - sourceTokenProjected;
+    const positivePerOccurrence = [...occurrenceSavings.values()].filter((value) => value > 0);
+    const averagePositiveSaving = positivePerOccurrence.length > 0
+        ? positivePerOccurrence.reduce((sum, value) => sum + value, 0) / positivePerOccurrence.length
+        : 0;
+    return {
+        cost: {
+            profile: input.estimator.profile,
+            sourceTokenCurrent,
+            sourceTokenProjected,
+            sourceTokenDelta,
+            oneTimeConfigTokenCost: {
+                total: oneTimeTotal,
+                byTsconfig,
+                resolverMirrors
+            },
+            netTokenSaving: sourceTokenDelta - oneTimeTotal,
+            paybackOccurrences: averagePositiveSaving > 0 ? Math.ceil(oneTimeTotal / averagePositiveSaving) : null,
+            uncachedContextSavingUpperBound: Math.max(0, sourceTokenDelta)
+        },
+        occurrenceSavings
+    };
+}
+function lexicalUnits(text) {
+    return text.match(/[A-Z]+(?=[A-Z][a-z]|\d|\b)|[A-Z]?[a-z]+|\d+|[^A-Za-z0-9\s]/g) ?? [];
+}

package/dist/bin/aib.js

@@ -1,2 +1,6 @@
 #!/usr/bin/env node
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),require("./cli");
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_cli_identity_1 = require("../runtime/node-cli-identity");
+(0, node_cli_identity_1.establishNodeCliIdentity)(__filename);
+require("./cli");