@automaton-labs/aib 0.0.7 → 0.0.9

package/dist/topology/workspace-project-index.js

@@ -0,0 +1,542 @@
+"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.WorkspaceProjectIndex = void 0;
+const crypto = __importStar(require("node:crypto"));
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_perf_hooks_1 = require("node:perf_hooks");
+const typescript_1 = __importDefault(require("typescript"));
+const errors_1 = require("../shared/errors");
+const core_1 = require("./core");
+const tsconfig_loader_1 = require("./tsconfig-loader");
+class WorkspaceProjectIndex {
+    rootIdentity;
+    generation = 1;
+    dirty = false;
+    disposed = false;
+    invalidationKinds = new Set();
+    current;
+    constructor(workspaceRoot) {
+        this.rootIdentity = createWorkspacePathIdentity(path.resolve(workspaceRoot));
+        this.current = this.build();
+    }
+    get state() {
+        return {
+            generation: this.generation,
+            dirty: this.dirty,
+            disposed: this.disposed,
+            invalidationKinds: Array.from(this.invalidationKinds).sort()
+        };
+    }
+    identityForFile(file) {
+        this.assertActive();
+        return this.resolveFileIdentity(file);
+    }
+    get snapshot() {
+        this.assertActive();
+        this.ensureFresh();
+        return cloneSnapshot(this.current.snapshot);
+    }
+    /** Exact TypeScript parsed owner set; topology primary ownership is never a fallback. */
+    exactOwnersForFile(file) {
+        this.assertActive();
+        this.ensureFresh();
+        const identity = this.identityForFile(file);
+        return (this.current.ownersByFileKey.get(identity.key) ?? []).map(cloneConfigRecord);
+    }
+    /** Read-only topology facts captured by the same structural build as exact ownership. */
+    get topologySnapshot() {
+        this.assertActive();
+        this.ensureFresh();
+        return cloneTopologySnapshot(this.current.topology);
+    }
+    /** Exact union of TypeScript-parsed project file sets; no Program or filesystem ownership guess. */
+    ownedFiles() {
+        this.assertActive();
+        this.ensureFresh();
+        return Array.from(this.current.ownedFilesByKey.values())
+            .map((identity) => ({ ...identity }))
+            .sort((left, right) => left.lexicalPath.localeCompare(right.lexicalPath));
+    }
+    configForPath(configFile) {
+        this.assertActive();
+        this.ensureFresh();
+        const record = this.current.configByKey.get(this.identityForFile(configFile).key);
+        return record ? cloneConfigRecord(record) : null;
+    }
+    packageForFile(file) {
+        this.assertActive();
+        this.ensureFresh();
+        const identity = this.identityForFile(file);
+        const record = this.current.packagesByDepth.find((pkg) => isPathInsideOrEqual(identity.realPath, pkg.identity.realPath));
+        return record ? clonePackageRecord(record) : null;
+    }
+    invalidate(change) {
+        this.assertActive();
+        const relevant = change.paths.some((file) => this.isInsideWorkspace(file));
+        if (!relevant) {
+            return;
+        }
+        this.generation += 1;
+        this.dirty = true;
+        this.invalidationKinds.add(change.kind);
+    }
+    refresh() {
+        this.assertActive();
+        this.current = this.build();
+        this.dirty = false;
+        this.invalidationKinds.clear();
+        this.current.snapshot.dirty = false;
+        this.current.snapshot.invalidationKinds = [];
+        return cloneSnapshot(this.current.snapshot);
+    }
+    dispose() {
+        if (this.disposed) {
+            return;
+        }
+        this.disposed = true;
+        this.current.configByKey.clear();
+        this.current.ownersByFileKey.clear();
+        this.current.ownedFilesByKey.clear();
+        this.current.packagesByDepth.length = 0;
+        this.current.pathResolver.clear();
+        this.current.snapshot.configs.length = 0;
+        this.current.snapshot.packages.length = 0;
+        this.current.snapshot.diagnostics.length = 0;
+        this.current.topology.tsconfigs.length = 0;
+        this.current.topology.packages.length = 0;
+        this.current.topology.diagnostics.length = 0;
+        this.invalidationKinds.clear();
+    }
+    ensureFresh() {
+        if (this.dirty) {
+            this.refresh();
+        }
+    }
+    build() {
+        const startedAt = node_perf_hooks_1.performance.now();
+        const topology = (0, core_1.buildProjectTopologySnapshot)(this.rootIdentity.lexicalPath);
+        const pathResolver = new CanonicalPathResolver();
+        const diagnostics = topology.diagnostics.map((item) => ({
+            code: item.code,
+            message: item.message,
+            ...(item.file ? { file: item.file } : {})
+        }));
+        const configByKey = new Map();
+        const ownersByFileKey = new Map();
+        const ownedFilesByKey = new Map();
+        const exactOwnershipStartedAt = node_perf_hooks_1.performance.now();
+        const roles = classifyConfigRoles(this.rootIdentity.lexicalPath, topology.tsconfigs, pathResolver);
+        for (const config of topology.tsconfigs) {
+            const parsedDiagnostics = [];
+            const configPath = resolveSnapshotPath(this.rootIdentity.lexicalPath, config.file);
+            const parsed = (0, tsconfig_loader_1.parseTsConfig)(configPath, parsedDiagnostics);
+            diagnostics.push(...parsedDiagnostics.map((item) => ({
+                code: item.code,
+                message: item.message,
+                ...(item.file ? { file: item.file } : {})
+            })));
+            if (!parsed) {
+                continue;
+            }
+            const role = roles.get(pathResolver.identity(configPath).key);
+            const record = buildConfigRecord(this.rootIdentity.lexicalPath, config, parsed, pathResolver, role);
+            configByKey.set(record.identity.key, record);
+            for (const file of record.configRole === "project" ? parsed.parsed.fileNames : []) {
+                const fileIdentity = pathResolver.identity(file);
+                const fileKey = fileIdentity.key;
+                ownedFilesByKey.set(fileKey, fileIdentity);
+                const owners = ownersByFileKey.get(fileKey) ?? [];
+                owners.push(record);
+                ownersByFileKey.set(fileKey, owners);
+            }
+        }
+        for (const owners of ownersByFileKey.values()) {
+            owners.sort((left, right) => left.identity.lexicalPath.localeCompare(right.identity.lexicalPath));
+        }
+        const exactOwnershipMs = node_perf_hooks_1.performance.now() - exactOwnershipStartedAt;
+        const packageIndexStartedAt = node_perf_hooks_1.performance.now();
+        const packages = topology.packages
+            .map((pkg) => buildPackageRecord(pkg, pathResolver))
+            .sort((left, right) => left.identity.lexicalPath.localeCompare(right.identity.lexicalPath));
+        const packagesByDepth = [...packages].sort((left, right) => right.identity.realPath.length - left.identity.realPath.length ||
+            left.identity.realPath.localeCompare(right.identity.realPath));
+        const packageIndexMs = node_perf_hooks_1.performance.now() - packageIndexStartedAt;
+        const configs = Array.from(configByKey.values()).sort((left, right) => left.identity.lexicalPath.localeCompare(right.identity.lexicalPath));
+        const invalidationKinds = Array.from(this.invalidationKinds).sort();
+        const totalMs = node_perf_hooks_1.performance.now() - startedAt;
+        const snapshot = {
+            root: this.rootIdentity,
+            generation: this.generation,
+            dirty: this.dirty,
+            builtAt: new Date().toISOString(),
+            buildMs: totalMs,
+            topologyBuildMs: topology.buildMs,
+            timings: {
+                topologyScopeMs: topology.timings.scopeMs ?? 0,
+                topologyTsconfigDiscoveryMs: topology.timings.tsconfigDiscoveryMs ?? 0,
+                topologyTsconfigMs: topology.timings.tsconfigMs,
+                topologyPackageMs: topology.timings.packageMs,
+                topologyDependencyMs: topology.timings.dependencyMs ?? 0,
+                topologyTotalMs: topology.timings.totalMs,
+                exactOwnershipMs,
+                packageIndexMs,
+                totalMs
+            },
+            ownershipAuthority: "typescript-parsed-owning-project-file-names",
+            topologyRole: "config-package-discovery-hint",
+            configs,
+            packages,
+            ownedFileCount: ownersByFileKey.size,
+            overlappingFileCount: Array.from(ownersByFileKey.values()).filter((owners) => owners.length > 1).length,
+            diagnostics: diagnostics.sort(compareDiagnostics),
+            invalidationKinds
+        };
+        return { topology, snapshot, configByKey, ownersByFileKey, ownedFilesByKey, packagesByDepth, pathResolver };
+    }
+    resolveFileIdentity(file) {
+        const absolute = path.resolve(this.rootIdentity.lexicalPath, file);
+        if (!isPathInsideOrEqual(absolute, this.rootIdentity.lexicalPath)) {
+            throw new errors_1.CliError("WORKSPACE_PROJECT_INDEX_PATH_OUTSIDE_ROOT", "Workspace project index paths must stay inside the workspace.", {
+                root: this.rootIdentity.lexicalPath,
+                path: file
+            });
+        }
+        return this.current.pathResolver.identity(absolute);
+    }
+    isInsideWorkspace(file) {
+        const absolute = path.resolve(this.rootIdentity.lexicalPath, file);
+        return isPathInsideOrEqual(absolute, this.rootIdentity.lexicalPath);
+    }
+    assertActive() {
+        if (this.disposed) {
+            throw new Error("WorkspaceProjectIndex is disposed.");
+        }
+    }
+}
+exports.WorkspaceProjectIndex = WorkspaceProjectIndex;
+function buildConfigRecord(root, config, parsed, pathResolver, role) {
+    const sourceFileKeys = role.configRole === "project"
+        ? parsed.parsed.fileNames.map((file) => pathResolver.identity(file).key).sort()
+        : [];
+    return {
+        identity: pathResolver.identity(parsed.file),
+        configRole: role.configRole,
+        roleEvidence: { ...role.roleEvidence },
+        ...(config.extends ? { extends: pathResolver.identity(resolveSnapshotPath(root, config.extends)) } : {}),
+        projectReferences: (config.references ?? [])
+            .map((reference) => pathResolver.identity(resolveProjectReferencePath(root, reference)))
+            .sort((left, right) => left.key.localeCompare(right.key)),
+        compilerOptionsFingerprint: hashStableJson(pickResolutionCompilerOptions(parsed.parsed.options)),
+        fileSetFingerprint: hashStableJson(sourceFileKeys),
+        sourceFileCount: sourceFileKeys.length
+    };
+}
+function classifyConfigRoles(root, configs, pathResolver) {
+    const extendsTargets = new Set(configs.flatMap((config) => config.extends
+        ? [pathResolver.identity(resolveSnapshotPath(root, config.extends)).key]
+        : []));
+    const referenceTargets = new Set(configs.flatMap((config) => (config.references ?? [])
+        .map((reference) => pathResolver.identity(resolveProjectReferencePath(root, reference)).key)));
+    return new Map(configs.map((config) => {
+        const configPath = resolveSnapshotPath(root, config.file);
+        const identity = pathResolver.identity(configPath);
+        const ownFiles = (config.files?.length ?? 0) > 0;
+        const ownInclude = (config.include?.length ?? 0) > 0;
+        const canonicalProjectName = path.basename(configPath).toLowerCase() === "tsconfig.json";
+        const extendsTarget = extendsTargets.has(identity.key);
+        const projectReferenceTarget = referenceTargets.has(identity.key);
+        const solution = (config.references?.length ?? 0) > 0 && config.files !== undefined && config.files.length === 0 && !ownInclude;
+        const configRole = solution
+            ? "solution"
+            : projectReferenceTarget || ownFiles || ownInclude || canonicalProjectName || !extendsTarget
+                ? "project"
+                : "base";
+        return [identity.key, {
+                configRole,
+                roleEvidence: { extendsTarget, projectReferenceTarget, ownFiles, ownInclude, canonicalProjectName }
+            }];
+    }));
+}
+function buildPackageRecord(pkg, pathResolver) {
+    const exact = readExactPackageBoundary(pkg.packageJson);
+    const identity = pathResolver.identity(pkg.root);
+    const packageJson = pathResolver.identity(pkg.packageJson);
+    const evidence = {
+        root: identity.key,
+        packageJson: packageJson.key,
+        name: pkg.name ?? null,
+        type: exact.type ?? null,
+        main: exact.main ?? null,
+        module: exact.module ?? null,
+        types: exact.types ?? null,
+        typings: exact.typings ?? null,
+        private: exact.private ?? null,
+        dependencies: exact.dependencies,
+        exports: exact.exports ?? null,
+        imports: exact.imports ?? null
+    };
+    return {
+        identity,
+        packageJson,
+        ...(pkg.name ? { name: pkg.name } : {}),
+        ...(exact.type ? { type: exact.type } : {}),
+        ...(exact.main ? { main: exact.main } : {}),
+        ...(exact.module ? { module: exact.module } : {}),
+        ...(exact.types ? { types: exact.types } : {}),
+        ...(exact.typings ? { typings: exact.typings } : {}),
+        ...(exact.private !== undefined ? { private: exact.private } : {}),
+        dependencies: exact.dependencies,
+        ...(exact.exports !== undefined ? { exports: exact.exports } : {}),
+        ...(exact.imports !== undefined ? { imports: exact.imports } : {}),
+        fingerprint: hashStableJson(evidence)
+    };
+}
+function readExactPackageBoundary(packageJson) {
+    try {
+        const parsed = typescript_1.default.parseConfigFileTextToJson(packageJson, fs.readFileSync(packageJson, "utf8"));
+        const config = parsed.config ?? {};
+        const type = config.type;
+        const dependencies = new Set();
+        for (const field of ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"]) {
+            const value = config[field];
+            if (!value || typeof value !== "object" || Array.isArray(value))
+                continue;
+            Object.keys(value).forEach((name) => dependencies.add(name));
+        }
+        const exportsValue = cloneUnknownJsonValue(config.exports);
+        const importsValue = cloneUnknownJsonValue(config.imports);
+        return {
+            ...(typeof type === "string" && type.trim() !== "" ? { type } : {}),
+            ...(typeof config.main === "string" && config.main.trim() !== "" ? { main: config.main } : {}),
+            ...(typeof config.module === "string" && config.module.trim() !== "" ? { module: config.module } : {}),
+            ...(typeof config.types === "string" && config.types.trim() !== "" ? { types: config.types } : {}),
+            ...(typeof config.typings === "string" && config.typings.trim() !== "" ? { typings: config.typings } : {}),
+            ...(typeof config.private === "boolean" ? { private: config.private } : {}),
+            dependencies: [...dependencies].sort(),
+            ...(exportsValue !== undefined ? { exports: exportsValue } : {}),
+            ...(importsValue !== undefined ? { imports: importsValue } : {})
+        };
+    }
+    catch {
+        return { dependencies: [] };
+    }
+}
+function pickResolutionCompilerOptions(options) {
+    return compactObject({
+        allowJs: options.allowJs,
+        baseUrl: options.baseUrl ? normalizeIdentityText(options.baseUrl) : undefined,
+        customConditions: options.customConditions ? [...options.customConditions].sort() : undefined,
+        jsx: options.jsx,
+        module: options.module,
+        moduleResolution: options.moduleResolution,
+        moduleSuffixes: options.moduleSuffixes ? [...options.moduleSuffixes] : undefined,
+        paths: options.paths ? sortRecordArrays(options.paths) : undefined,
+        preserveSymlinks: options.preserveSymlinks,
+        resolveJsonModule: options.resolveJsonModule,
+        rootDir: options.rootDir ? normalizeIdentityText(options.rootDir) : undefined,
+        rootDirs: options.rootDirs ? options.rootDirs.map(normalizeIdentityText).sort() : undefined,
+        typeRoots: options.typeRoots ? options.typeRoots.map(normalizeIdentityText).sort() : undefined,
+        types: options.types ? [...options.types].sort() : undefined
+    });
+}
+function createWorkspacePathIdentity(file) {
+    return new CanonicalPathResolver().identity(file);
+}
+function resolveSnapshotPath(root, value) {
+    return path.normalize(path.isAbsolute(value) ? value : path.resolve(root, value));
+}
+function resolveProjectReferencePath(root, value) {
+    const resolved = resolveSnapshotPath(root, value);
+    if (fs.existsSync(resolved) && fs.statSync(resolved).isDirectory()) {
+        return path.join(resolved, "tsconfig.json");
+    }
+    if (!path.extname(resolved)) {
+        const nested = path.join(resolved, "tsconfig.json");
+        if (fs.existsSync(nested)) {
+            return nested;
+        }
+    }
+    return resolved;
+}
+function normalizeIdentityText(value) {
+    const normalized = path.normalize(value);
+    return typescript_1.default.sys.useCaseSensitiveFileNames ? normalized : normalized.toLowerCase();
+}
+function isPathInsideOrEqual(candidate, parent) {
+    const relative = path.relative(path.resolve(parent), path.resolve(candidate));
+    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+function hashStableJson(value) {
+    return crypto.createHash("sha256").update(stableStringify(value)).digest("hex");
+}
+function stableStringify(value) {
+    if (Array.isArray(value)) {
+        return `[${value.map(stableStringify).join(",")}]`;
+    }
+    if (value && typeof value === "object") {
+        const object = value;
+        return `{${Object.keys(object).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(object[key])}`).join(",")}}`;
+    }
+    return JSON.stringify(value);
+}
+function compactObject(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined));
+}
+function sortRecordArrays(value) {
+    return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, items]) => [key, [...items].sort()]));
+}
+function compareDiagnostics(left, right) {
+    return left.code.localeCompare(right.code) ||
+        (left.file ?? "").localeCompare(right.file ?? "") ||
+        left.message.localeCompare(right.message);
+}
+function cloneSnapshot(snapshot) {
+    return {
+        ...snapshot,
+        root: { ...snapshot.root },
+        timings: { ...snapshot.timings },
+        configs: snapshot.configs.map(cloneConfigRecord),
+        packages: snapshot.packages.map(clonePackageRecord),
+        diagnostics: snapshot.diagnostics.map((diagnostic) => ({ ...diagnostic })),
+        invalidationKinds: [...snapshot.invalidationKinds]
+    };
+}
+function cloneTopologySnapshot(snapshot) {
+    return JSON.parse(JSON.stringify(snapshot));
+}
+function cloneConfigRecord(config) {
+    return {
+        ...config,
+        identity: { ...config.identity },
+        roleEvidence: { ...config.roleEvidence },
+        ...(config.extends ? { extends: { ...config.extends } } : {}),
+        projectReferences: config.projectReferences.map((reference) => ({ ...reference }))
+    };
+}
+function clonePackageRecord(pkg) {
+    return {
+        ...pkg,
+        dependencies: [...pkg.dependencies],
+        identity: { ...pkg.identity },
+        packageJson: { ...pkg.packageJson },
+        ...(pkg.exports !== undefined ? { exports: cloneJsonValue(pkg.exports) } : {}),
+        ...(pkg.imports !== undefined ? { imports: cloneJsonValue(pkg.imports) } : {})
+    };
+}
+function cloneJsonValue(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+function cloneUnknownJsonValue(value) {
+    if (value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number") {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.map(cloneUnknownJsonValue).filter((item) => item !== undefined);
+    }
+    if (value && typeof value === "object") {
+        const entries = Object.entries(value)
+            .map(([key, item]) => [key, cloneUnknownJsonValue(item)])
+            .filter((entry) => entry[1] !== undefined);
+        return Object.fromEntries(entries);
+    }
+    return undefined;
+}
+class CanonicalPathResolver {
+    realDirectories = new Map();
+    symlinkEntries = new Map();
+    identity(file) {
+        const lexicalPath = path.normalize(path.resolve(file));
+        let realPath = lexicalPath;
+        if (fs.existsSync(lexicalPath)) {
+            try {
+                const parent = path.dirname(lexicalPath);
+                const symlink = this.isSymlinkEntry(parent, path.basename(lexicalPath));
+                realPath = symlink === false
+                    ? path.join(this.realDirectory(parent), path.basename(lexicalPath))
+                    : path.normalize(fs.realpathSync.native(lexicalPath));
+            }
+            catch {
+                realPath = lexicalPath;
+            }
+        }
+        return { lexicalPath, realPath, key: normalizeIdentityText(realPath) };
+    }
+    clear() {
+        this.realDirectories.clear();
+        this.symlinkEntries.clear();
+    }
+    isSymlinkEntry(directory, name) {
+        const lexical = path.normalize(path.resolve(directory));
+        const key = normalizeIdentityText(lexical);
+        let entries = this.symlinkEntries.get(key);
+        if (entries === undefined) {
+            try {
+                entries = new Set(fs.readdirSync(lexical, { withFileTypes: true })
+                    .filter((entry) => entry.isSymbolicLink())
+                    .map((entry) => normalizeFileName(entry.name)));
+            }
+            catch {
+                entries = null;
+            }
+            this.symlinkEntries.set(key, entries);
+        }
+        return entries ? entries.has(normalizeFileName(name)) : null;
+    }
+    realDirectory(directory) {
+        const lexical = path.normalize(path.resolve(directory));
+        const key = normalizeIdentityText(lexical);
+        const existing = this.realDirectories.get(key);
+        if (existing) {
+            return existing;
+        }
+        let real = lexical;
+        try {
+            real = path.normalize(fs.realpathSync.native(lexical));
+        }
+        catch {
+            // Non-existing directories retain lexical identity until refresh.
+        }
+        this.realDirectories.set(key, real);
+        return real;
+    }
+}
+function normalizeFileName(value) {
+    return typescript_1.default.sys.useCaseSensitiveFileNames ? value : value.toLowerCase();
+}