@automaton-labs/aib 0.0.6 → 0.0.8

package/dist/topology/cache.js

@@ -0,0 +1,130 @@
+"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.readTopologyMode = readTopologyMode;
+exports.getProjectTopologySnapshot = getProjectTopologySnapshot;
+exports.topologyCacheStatus = topologyCacheStatus;
+const path = __importStar(require("node:path"));
+const fs = __importStar(require("node:fs"));
+const env_vars_1 = require("../config/env-vars");
+const workspace_state_1 = require("../config/workspace-state");
+const core_1 = require("./core");
+const scope_1 = require("./scope");
+let cache = null;
+function readTopologyMode() {
+    return process.env[env_vars_1.CLI_ENV.topology] === "off" ? "off" : "lazy";
+}
+function getProjectTopologySnapshot(cwd, modeOverride) {
+    const mode = modeOverride ?? readTopologyMode();
+    if (mode === "off") {
+        return null;
+    }
+    const state = (0, workspace_state_1.ensureWorkspaceState)(cwd);
+    const root = path.resolve(state.root);
+    const key = topologyCacheKey(state);
+    if (cache && cache.root === root && cache.key === key) {
+        return cache.snapshot;
+    }
+    const snapshot = (0, core_1.buildProjectTopologySnapshot)(root);
+    cache = {
+        root,
+        key,
+        snapshot
+    };
+    return snapshot;
+}
+function topologyCacheStatus(cwd, modeOverride) {
+    const mode = modeOverride ?? readTopologyMode();
+    if (mode === "off") {
+        return { mode, cached: false };
+    }
+    const state = (0, workspace_state_1.ensureWorkspaceState)(cwd);
+    const root = path.resolve(state.root);
+    const key = topologyCacheKey(state);
+    return {
+        mode,
+        cached: Boolean(cache && cache.root === root && cache.key === key),
+        root,
+        key,
+        ...(cache && cache.root === root && cache.key === key ? { snapshot: { builtAt: cache.snapshot.builtAt, buildMs: cache.snapshot.buildMs } } : {})
+    };
+}
+function topologyCacheKey(state) {
+    const scope = (0, scope_1.createTopologyScope)(state.root);
+    return [
+        state.configPath,
+        state.lastSyncAt,
+        ...state.tsconfigs,
+        ...fingerprintFiles([state.configPath, ...state.tsconfigs]),
+        ...fingerprintPackageJsonFiles(state.root, scope)
+    ].join("\n");
+}
+function fingerprintFiles(files) {
+    return files.map((file) => {
+        try {
+            const stat = fs.statSync(file);
+            return `${path.resolve(file)}:${stat.mtimeMs}:${stat.size}`;
+        }
+        catch {
+            return `${path.resolve(file)}:missing`;
+        }
+    });
+}
+function fingerprintPackageJsonFiles(root, scope) {
+    const files = [];
+    visit(path.resolve(root));
+    return fingerprintFiles(files.sort());
+    function visit(dir) {
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                const nextDir = path.join(dir, entry.name);
+                if (scope.isPathInScope(path.join(nextDir, "package.json"))) {
+                    visit(nextDir);
+                }
+                continue;
+            }
+            if (entry.isFile() && entry.name === "package.json" && scope.isPathInScope(path.join(dir, entry.name))) {
+                files.push(path.join(dir, entry.name));
+            }
+        }
+    }
+}

package/dist/topology/candidates.js

@@ -0,0 +1,372 @@
+"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.generateTopologyCandidates = generateTopologyCandidates;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const SOURCE_EXTENSIONS = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
+const SKIP_DIRS = new Set(["node_modules", ".git", ".tmp", ".next", "dist", "build", "out", "coverage"]);
+function generateTopologyCandidates(snapshot) {
+    const startedAt = Date.now();
+    const boundaryStartedAt = Date.now();
+    const boundaries = collectBoundaries(snapshot);
+    const boundaryMs = Date.now() - boundaryStartedAt;
+    const candidateStartedAt = Date.now();
+    const skipped = new Map();
+    const candidates = [];
+    const seen = new Set();
+    const boundaryByPath = new Map(boundaries.map((boundary) => [boundary.path, boundary]));
+    for (const consumer of boundaries) {
+        const consumerRoot = path.resolve(snapshot.root, consumer.path);
+        const importer = firstSourceFile(consumerRoot);
+        if (!importer) {
+            increment(skipped, "consumer has no representative source file");
+            continue;
+        }
+        const consumerTsconfig = findBoundaryTsconfig(snapshot, consumer.path, importer);
+        if (!consumerTsconfig) {
+            increment(skipped, "consumer has no owning tsconfig");
+            continue;
+        }
+        const consumerPackage = packageForBoundary(snapshot, consumer.path);
+        if (consumerPackage) {
+            for (const providerPackage of snapshot.packages) {
+                if (!providerPackage.name || providerPackage.root === consumerPackage.root || !consumerPackage.dependencies.includes(providerPackage.name)) {
+                    continue;
+                }
+                const providerPath = toDisplayPath(snapshot.root, providerPackage.root);
+                const provider = boundaryByPath.get(providerPath);
+                if (!provider) {
+                    increment(skipped, "package dependency target is outside visible boundaries");
+                    continue;
+                }
+                if (!hasBarePackageEntry(providerPackage)) {
+                    increment(skipped, "package dependency has no root entry");
+                    continue;
+                }
+                const targetFile = packageEntryTargetFile(providerPackage) ?? firstSourceFile(providerPackage.root);
+                if (!targetFile) {
+                    increment(skipped, hasDeclaredImportableEntry(providerPackage)
+                        ? "package dependency has no importable target file"
+                        : "package dependency has no code entry");
+                    continue;
+                }
+                const specifier = providerPackage.name;
+                const id = `${consumer.path}->${provider.path}:${specifier}:${toDisplayPath(snapshot.root, targetFile)}`;
+                if (!seen.has(id)) {
+                    seen.add(id);
+                    candidates.push({
+                        id,
+                        consumerBoundary: consumer.path,
+                        providerBoundary: provider.path,
+                        consumerTsconfig: consumerTsconfig.file,
+                        representativeImporterFile: toDisplayPath(snapshot.root, importer),
+                        targetFile: toDisplayPath(snapshot.root, targetFile),
+                        targetRoot: toDisplayPath(snapshot.root, providerPackage.root),
+                        aliasPattern: specifier,
+                        targetPattern: `${specifier} package`,
+                        specifier,
+                        source: "package-dependency",
+                        reason: `${consumerPackage.name ?? consumer.path} declares dependency ${specifier}`
+                    });
+                }
+            }
+        }
+        for (const mapping of consumerTsconfig.paths) {
+            for (const rawTarget of mapping.targets) {
+                const targetFile = targetFileFromMapping(snapshot.root, mapping, rawTarget);
+                if (!targetFile) {
+                    increment(skipped, "alias target cannot resolve to source file");
+                    continue;
+                }
+                const provider = boundaryForFile(snapshot.root, boundaries, targetFile);
+                if (!provider) {
+                    increment(skipped, "alias target is outside known boundaries");
+                    continue;
+                }
+                if (!boundaryByPath.has(provider.path)) {
+                    increment(skipped, "provider boundary not visible");
+                    continue;
+                }
+                if (provider.path === consumer.path) {
+                    increment(skipped, "alias maps to same boundary");
+                    continue;
+                }
+                const specifier = specifierFromMapping(snapshot.root, targetFile, mapping, rawTarget);
+                if (!specifier) {
+                    increment(skipped, "could not build alias specifier");
+                    continue;
+                }
+                const id = `${consumer.path}->${provider.path}:${specifier}:${toDisplayPath(snapshot.root, targetFile)}`;
+                if (seen.has(id)) {
+                    continue;
+                }
+                seen.add(id);
+                candidates.push({
+                    id,
+                    consumerBoundary: consumer.path,
+                    providerBoundary: provider.path,
+                    consumerTsconfig: consumerTsconfig.file,
+                    representativeImporterFile: toDisplayPath(snapshot.root, importer),
+                    targetFile: toDisplayPath(snapshot.root, targetFile),
+                    aliasPattern: mapping.pattern,
+                    targetPattern: rawTarget,
+                    specifier,
+                    source: "tsconfig-path",
+                    reason: `matched ${mapping.pattern} in ${consumerTsconfig.file}`
+                });
+            }
+        }
+    }
+    return {
+        boundaries,
+        candidates: candidates.sort((left, right) => left.providerBoundary.localeCompare(right.providerBoundary) ||
+            left.consumerBoundary.localeCompare(right.consumerBoundary) ||
+            left.specifier.localeCompare(right.specifier)),
+        skipped: [...skipped.entries()].map(([reason, count]) => ({ reason, count })).sort((left, right) => left.reason.localeCompare(right.reason)),
+        timings: {
+            boundaryMs,
+            candidateMs: Date.now() - candidateStartedAt,
+            totalMs: Date.now() - startedAt
+        }
+    };
+}
+function collectBoundaries(snapshot) {
+    const boundaries = [];
+    for (const pkg of snapshot.packages) {
+        const display = toDisplayPath(snapshot.root, pkg.root);
+        if (display === ".") {
+            continue;
+        }
+        boundaries.push({
+            path: display,
+            ...(pkg.name ? { packageName: pkg.name } : {})
+        });
+    }
+    const src = path.join(snapshot.root, "src");
+    if (fs.existsSync(src) && fs.statSync(src).isDirectory()) {
+        boundaries.push({ path: "src" });
+    }
+    return uniqueBoundaries(boundaries).sort((left, right) => left.path.localeCompare(right.path));
+}
+function packageForBoundary(snapshot, boundary) {
+    return snapshot.packages.find((pkg) => toDisplayPath(snapshot.root, pkg.root) === boundary);
+}
+function uniqueBoundaries(boundaries) {
+    const seen = new Map();
+    for (const boundary of boundaries) {
+        if (!seen.has(boundary.path)) {
+            seen.set(boundary.path, boundary);
+        }
+    }
+    return [...seen.values()];
+}
+function findBoundaryTsconfig(snapshot, boundary, importer) {
+    const preferred = `${boundary}/tsconfig.json`;
+    const direct = snapshot.tsconfigs.find((config) => config.file === preferred);
+    if (direct) {
+        return direct;
+    }
+    const absoluteImporter = path.resolve(importer);
+    return snapshot.tsconfigs
+        .filter((config) => {
+        const configDir = path.dirname(path.resolve(snapshot.root, config.file));
+        const relative = path.relative(configDir, absoluteImporter);
+        return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+    })
+        .sort((left, right) => path.dirname(path.resolve(snapshot.root, right.file)).length - path.dirname(path.resolve(snapshot.root, left.file)).length)[0];
+}
+function targetFileFromMapping(root, mapping, rawTarget) {
+    const star = rawTarget.indexOf("*");
+    if (star >= 0) {
+        return firstSourceFile(path.resolve(root, mapping.baseUrl, rawTarget.slice(0, star)));
+    }
+    return resolveSourceFile(path.resolve(root, mapping.baseUrl, rawTarget));
+}
+function specifierFromMapping(root, targetFile, mapping, rawTarget) {
+    const star = rawTarget.indexOf("*");
+    if (star < 0) {
+        return mapping.pattern.includes("*") ? null : mapping.pattern;
+    }
+    if (!mapping.pattern.includes("*")) {
+        return null;
+    }
+    const targetPrefix = path.resolve(root, mapping.baseUrl, rawTarget.slice(0, star));
+    const relative = withoutSourceExtension(path.relative(targetPrefix, targetFile).replace(/\\/g, "/"));
+    if (relative.startsWith("..")) {
+        return null;
+    }
+    return mapping.pattern.replace("*", relative);
+}
+function resolveSourceFile(target) {
+    const direct = firstSourceFile(target);
+    if (direct) {
+        return direct;
+    }
+    const withoutExt = withoutSourceExtension(target);
+    for (const extension of SOURCE_EXTENSIONS) {
+        const candidate = `${withoutExt}${extension}`;
+        if (fs.existsSync(candidate) && fs.statSync(candidate).isFile() && !candidate.endsWith(".d.ts")) {
+            return candidate;
+        }
+    }
+    return null;
+}
+function boundaryForFile(root, boundaries, file) {
+    const absolute = path.resolve(file);
+    return boundaries
+        .filter((boundary) => {
+        const boundaryRoot = path.resolve(root, boundary.path);
+        const relative = path.relative(boundaryRoot, absolute);
+        return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+    })
+        .sort((left, right) => right.path.length - left.path.length)[0];
+}
+function firstSourceFile(root) {
+    if (!fs.existsSync(root)) {
+        return null;
+    }
+    const stat = fs.statSync(root);
+    if (stat.isFile()) {
+        return SOURCE_EXTENSIONS.includes(path.extname(root)) && !root.endsWith(".d.ts") ? root : null;
+    }
+    const preferred = preferredSourceFile(root);
+    if (preferred) {
+        return preferred;
+    }
+    const entries = fs.readdirSync(root, { withFileTypes: true }).sort((left, right) => left.name.localeCompare(right.name));
+    for (const entry of entries) {
+        if (SKIP_DIRS.has(entry.name)) {
+            continue;
+        }
+        const full = path.join(root, entry.name);
+        if (entry.isDirectory()) {
+            const nested = firstSourceFile(full);
+            if (nested) {
+                return nested;
+            }
+            continue;
+        }
+        if (entry.isFile() && SOURCE_EXTENSIONS.includes(path.extname(entry.name)) && !entry.name.endsWith(".d.ts")) {
+            return full;
+        }
+    }
+    return null;
+}
+function hasBarePackageEntry(pkg) {
+    if (pkg.main || pkg.module || pkg.types || pkg.typings) {
+        return true;
+    }
+    if (!pkg.exports) {
+        return true;
+    }
+    return Object.prototype.hasOwnProperty.call(pkg.exports, ".");
+}
+function hasDeclaredImportableEntry(pkg) {
+    return Boolean(pkg.main || pkg.module || pkg.types || pkg.typings || pkg.exports);
+}
+function packageEntryTargetFile(pkg) {
+    const candidates = [
+        ...packageExportTargets(pkg.exports?.["."]),
+        pkg.types,
+        pkg.typings,
+        pkg.module,
+        pkg.main,
+        "./index.ts",
+        "./index.tsx",
+        "./src/index.ts",
+        "./src/index.tsx"
+    ].filter((value) => typeof value === "string" && value.trim() !== "");
+    for (const candidate of candidates) {
+        if (path.isAbsolute(candidate) || candidate.startsWith("#")) {
+            continue;
+        }
+        const resolved = path.resolve(pkg.root, candidate);
+        if (fs.existsSync(resolved) && fs.statSync(resolved).isFile()) {
+            return resolved;
+        }
+    }
+    return null;
+}
+function packageExportTargets(value) {
+    if (typeof value === "string") {
+        return [value];
+    }
+    if (Array.isArray(value)) {
+        return value.flatMap(packageExportTargets);
+    }
+    if (value && typeof value === "object") {
+        const record = value;
+        const preferred = ["types", "browser", "import", "require", "default"];
+        return [
+            ...preferred.flatMap((key) => packageExportTargets(record[key])),
+            ...Object.keys(record)
+                .filter((key) => !preferred.includes(key))
+                .flatMap((key) => packageExportTargets(record[key]))
+        ];
+    }
+    return [];
+}
+function preferredSourceFile(root) {
+    const preferredNames = [
+        "public-api.ts",
+        "public-api.tsx",
+        "index.ts",
+        "index.tsx",
+        "main.ts",
+        "main.tsx"
+    ];
+    for (const name of preferredNames) {
+        const candidate = path.join(root, name);
+        if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) {
+            return candidate;
+        }
+    }
+    const srcDir = path.join(root, "src");
+    if (srcDir !== root && fs.existsSync(srcDir) && fs.statSync(srcDir).isDirectory()) {
+        return preferredSourceFile(srcDir);
+    }
+    return null;
+}
+function increment(map, reason) {
+    map.set(reason, (map.get(reason) ?? 0) + 1);
+}
+function withoutSourceExtension(file) {
+    return file.replace(/\.(d\.)?[cm]?[tj]sx?$/i, "");
+}
+function toDisplayPath(root, file) {
+    const relative = path.relative(root, path.resolve(file)).replace(/\\/g, "/");
+    return relative === "" ? "." : relative.startsWith("..") ? path.resolve(file).replace(/\\/g, "/") : relative;
+}