@automaton-labs/aib 0.0.7 → 0.0.9

package/dist/semantic/semantic-context-provider.js

@@ -0,0 +1,416 @@
+"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.SemanticContextProvider = exports.SemanticContextError = void 0;
+exports.canonicalSemanticFileKey = canonicalSemanticFileKey;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const typescript_1 = __importDefault(require("typescript"));
+const tsconfig_loader_1 = require("../topology/tsconfig-loader");
+class SemanticContextError extends Error {
+    code;
+    details;
+    constructor(code, message, details = {}) {
+        super(message);
+        this.code = code;
+        this.details = details;
+        this.name = "SemanticContextError";
+    }
+}
+exports.SemanticContextError = SemanticContextError;
+/**
+ * Request-local compiler-state owner. Structural ownership remains the
+ * responsibility of WorkspaceProjectIndex; this provider never guesses an
+ * owner from topology or directory proximity. The caller owns and disposes
+ * the structural index separately.
+ *
+ * A fresh WorkspaceProjectIndex per request captures config state from disk.
+ * Mid-request config/package/file changes must invalidate that index; the
+ * provider then fails closed on its captured generation. Detecting unreported
+ * disk drift is intentionally deferred until any long-lived reuse design.
+ */
+class SemanticContextProvider {
+    projectIndex;
+    workspaceRoot;
+    parsedProjects = new Map();
+    activeLeases = new Set();
+    documentRegistry = null;
+    indexGeneration;
+    contextRevision = 0;
+    disposed = false;
+    constructor(workspaceRoot, projectIndex) {
+        this.projectIndex = projectIndex;
+        this.workspaceRoot = path.resolve(workspaceRoot);
+        this.indexGeneration = projectIndex.snapshot.generation;
+    }
+    get state() {
+        return {
+            disposed: this.disposed,
+            activeLeases: this.activeLeases.size,
+            parsedProjectCount: this.parsedProjects.size
+        };
+    }
+    exactOwnersForFile(file) {
+        this.assertActive();
+        this.assertCurrentGeneration();
+        return this.projectIndex.exactOwnersForFile(this.resolveWorkspacePath(file));
+    }
+    acquireProgram(request) {
+        const inputs = this.prepareInputs(request);
+        const host = createOverlayCompilerHost(inputs.parsed.parsed.options, inputs.overlays);
+        let program = typescript_1.default.createProgram({
+            rootNames: [...inputs.descriptor.rootFiles],
+            options: inputs.parsed.parsed.options,
+            host
+        });
+        let checker = program.getTypeChecker();
+        let released = false;
+        const lease = {
+            mode: "program",
+            descriptor: inputs.descriptor,
+            get program() {
+                if (!program) {
+                    throw new Error("Program semantic context lease is released.");
+                }
+                return program;
+            },
+            get checker() {
+                if (!checker) {
+                    throw new Error("Program semantic context lease is released.");
+                }
+                return checker;
+            },
+            diagnostics: (scope = "all") => {
+                if (!program) {
+                    throw new Error("Program semantic context lease is released.");
+                }
+                if (scope === "all") {
+                    return typescript_1.default.getPreEmitDiagnostics(program);
+                }
+                const source = program.getSourceFile(inputs.descriptor.focusFile);
+                return source
+                    ? [...program.getSyntacticDiagnostics(source), ...program.getSemanticDiagnostics(source)]
+                    : [];
+            },
+            release: () => {
+                if (released) {
+                    return;
+                }
+                released = true;
+                program = null;
+                checker = null;
+                inputs.overlays.clear();
+                this.activeLeases.delete(lease);
+            }
+        };
+        this.activeLeases.add(lease);
+        return lease;
+    }
+    acquireLanguageService(request) {
+        const inputs = this.prepareInputs(request);
+        const host = createOverlayLanguageServiceHost(this.workspaceRoot, inputs.parsed.parsed.options, inputs.descriptor.rootFiles, inputs.overlays, ++this.contextRevision);
+        this.documentRegistry ??= typescript_1.default.createDocumentRegistry(typescript_1.default.sys.useCaseSensitiveFileNames, this.workspaceRoot);
+        let languageService = typescript_1.default.createLanguageService(host, this.documentRegistry);
+        let released = false;
+        const lease = {
+            mode: "languageService",
+            descriptor: inputs.descriptor,
+            get languageService() {
+                if (!languageService) {
+                    throw new Error("Language service semantic context lease is released.");
+                }
+                return languageService;
+            },
+            diagnostics: (scope = "all") => {
+                if (!languageService) {
+                    throw new Error("Language service semantic context lease is released.");
+                }
+                const files = scope === "focus" ? [inputs.descriptor.focusFile] : inputs.descriptor.rootFiles;
+                const fileDiagnostics = files.flatMap((file) => [
+                    ...languageService.getSyntacticDiagnostics(file),
+                    ...languageService.getSemanticDiagnostics(file)
+                ]);
+                return scope === "all"
+                    ? [...languageService.getCompilerOptionsDiagnostics(), ...fileDiagnostics]
+                    : fileDiagnostics;
+            },
+            release: () => {
+                if (released) {
+                    return;
+                }
+                released = true;
+                languageService?.dispose();
+                languageService = null;
+                inputs.overlays.clear();
+                this.activeLeases.delete(lease);
+            }
+        };
+        this.activeLeases.add(lease);
+        return lease;
+    }
+    dispose() {
+        if (this.disposed) {
+            return;
+        }
+        for (const lease of [...this.activeLeases]) {
+            lease.release();
+        }
+        this.parsedProjects.clear();
+        this.documentRegistry = null;
+        this.disposed = true;
+    }
+    prepareInputs(request) {
+        this.assertActive();
+        this.assertCurrentGeneration();
+        const focusFile = this.resolveWorkspacePath(request.focusFile);
+        if (!fs.existsSync(focusFile)) {
+            throw new SemanticContextError("SEMANTIC_CONTEXT_FOCUS_NOT_FOUND", "Semantic context focus file was not found.", { focusFile });
+        }
+        const owner = this.resolveOwner(focusFile, request.ownerConfig);
+        const parsed = this.parseProject(owner).parsed;
+        const projectScope = request.projectScope ?? "owner-with-forward-references";
+        const forwardProjects = projectScope === "owner-with-forward-references"
+            ? this.collectForwardProjects(owner)
+            : [];
+        const overlays = this.normalizeOverlays(request.overlays ?? []);
+        const rootFiles = uniqueSorted([
+            ...parsed.parsed.fileNames,
+            ...forwardProjects.flatMap((project) => project.parsed.parsed.fileNames),
+            ...Array.from(overlays.values(), (overlay) => overlay.file)
+        ]);
+        const descriptor = Object.freeze({
+            focusFile,
+            ownerConfig: owner.identity.lexicalPath,
+            projectScope,
+            rootFiles: Object.freeze(rootFiles),
+            forwardProjectConfigs: Object.freeze(forwardProjects.map((project) => project.config.identity.lexicalPath).sort()),
+            overlayFiles: Object.freeze(Array.from(overlays.values(), (overlay) => overlay.file).sort())
+        });
+        return { descriptor, parsed, overlays };
+    }
+    assertCurrentGeneration() {
+        if (this.projectIndex.state.dirty || this.projectIndex.state.generation !== this.indexGeneration) {
+            throw new SemanticContextError("SEMANTIC_CONTEXT_INDEX_CHANGED", "Workspace project structure changed during this request; create a new semantic context provider.", {
+                providerGeneration: this.indexGeneration,
+                indexGeneration: this.projectIndex.state.generation,
+                indexDirty: this.projectIndex.state.dirty
+            });
+        }
+    }
+    resolveOwner(focusFile, requestedOwner) {
+        const owners = this.projectIndex.exactOwnersForFile(focusFile);
+        if (owners.length === 0) {
+            throw new SemanticContextError("SEMANTIC_CONTEXT_OWNER_NOT_FOUND", "No exact parsed TypeScript project owns the focus file.", { focusFile });
+        }
+        if (!requestedOwner) {
+            if (owners.length > 1) {
+                throw new SemanticContextError("SEMANTIC_CONTEXT_OWNER_AMBIGUOUS", "Multiple exact parsed TypeScript projects own the focus file; choose an owner explicitly.", { focusFile, owners: owners.map((owner) => owner.identity.lexicalPath) });
+            }
+            return owners[0];
+        }
+        const requestedKey = this.projectIndex.identityForFile(this.resolveWorkspacePath(requestedOwner)).key;
+        const owner = owners.find((candidate) => candidate.identity.key === requestedKey);
+        if (!owner) {
+            throw new SemanticContextError("SEMANTIC_CONTEXT_OWNER_MISMATCH", "The requested TypeScript project is not an exact owner of the focus file.", {
+                focusFile,
+                ownerConfig: requestedOwner,
+                exactOwners: owners.map((candidate) => candidate.identity.lexicalPath)
+            });
+        }
+        return owner;
+    }
+    collectForwardProjects(owner) {
+        const visited = new Set();
+        const pending = [...owner.projectReferences];
+        const projects = [];
+        while (pending.length > 0) {
+            const identity = pending.shift();
+            if (visited.has(identity.key)) {
+                continue;
+            }
+            visited.add(identity.key);
+            const record = this.projectIndex.configForPath(identity.lexicalPath);
+            if (!record) {
+                throw new SemanticContextError("SEMANTIC_CONTEXT_CONFIG_INVALID", "A referenced TypeScript project is not available in the structural index.", { ownerConfig: owner.identity.lexicalPath, referencedConfig: identity.lexicalPath });
+            }
+            const project = this.parseProject(record);
+            projects.push(project);
+            pending.push(...record.projectReferences);
+        }
+        return projects.sort((left, right) => left.config.identity.lexicalPath.localeCompare(right.config.identity.lexicalPath));
+    }
+    parseProject(config) {
+        const cached = this.parsedProjects.get(config.identity.key);
+        if (cached) {
+            return cached;
+        }
+        const diagnostics = [];
+        const parsed = (0, tsconfig_loader_1.parseTsConfig)(config.identity.lexicalPath, diagnostics);
+        if (!parsed || diagnostics.length > 0) {
+            throw new SemanticContextError("SEMANTIC_CONTEXT_CONFIG_INVALID", "The exact owning TypeScript project could not be parsed without diagnostics.", { config: config.identity.lexicalPath, diagnostics });
+        }
+        const project = { config, parsed };
+        this.parsedProjects.set(config.identity.key, project);
+        return project;
+    }
+    normalizeOverlays(overlays) {
+        const result = new Map();
+        const inputByKey = new Map();
+        for (const overlay of overlays) {
+            let file;
+            try {
+                file = this.resolveWorkspacePath(overlay.file);
+                const identity = this.projectIndex.identityForFile(file);
+                const key = canonicalSemanticFileKey(identity.lexicalPath);
+                const previousInput = inputByKey.get(key);
+                if (previousInput !== undefined) {
+                    throw new SemanticContextError("SEMANTIC_CONTEXT_OVERLAY_DUPLICATE", "Semantic context overlays must contain at most one input for each canonical file.", { first: previousInput, second: overlay.file, canonicalFile: identity.realPath });
+                }
+                inputByKey.set(key, overlay.file);
+                result.set(key, {
+                    file: identity.lexicalPath,
+                    text: overlay.text,
+                    version: overlay.version ?? 1
+                });
+            }
+            catch (error) {
+                if (error instanceof SemanticContextError && error.code === "SEMANTIC_CONTEXT_OVERLAY_DUPLICATE") {
+                    throw error;
+                }
+                throw new SemanticContextError("SEMANTIC_CONTEXT_OVERLAY_OUTSIDE_WORKSPACE", "Semantic context overlays must stay inside the workspace.", { file: overlay.file });
+            }
+        }
+        return result;
+    }
+    resolveWorkspacePath(file) {
+        const absolute = path.resolve(this.workspaceRoot, file);
+        const relative = path.relative(this.workspaceRoot, absolute);
+        if (relative.startsWith("..") || path.isAbsolute(relative)) {
+            throw new SemanticContextError("SEMANTIC_CONTEXT_PATH_OUTSIDE_WORKSPACE", "Semantic context paths must stay inside the workspace.", { file });
+        }
+        return absolute;
+    }
+    assertActive() {
+        if (this.disposed) {
+            throw new Error("SemanticContextProvider is disposed.");
+        }
+    }
+}
+exports.SemanticContextProvider = SemanticContextProvider;
+function createOverlayCompilerHost(options, overlays) {
+    const base = typescript_1.default.createCompilerHost(options, true);
+    const overlayFor = (fileName) => overlays.get(canonicalSemanticFileKey(fileName));
+    return {
+        ...base,
+        // Semantic contexts prove edits; they never materialize compiler output.
+        writeFile: () => undefined,
+        fileExists: (fileName) => Boolean(overlayFor(fileName)) || base.fileExists(fileName),
+        readFile: (fileName) => overlayFor(fileName)?.text ?? base.readFile(fileName),
+        getSourceFile: (fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile) => {
+            const overlay = overlayFor(fileName);
+            if (!overlay) {
+                return base.getSourceFile(fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile);
+            }
+            const languageVersion = typeof languageVersionOrOptions === "object"
+                ? languageVersionOrOptions.languageVersion
+                : languageVersionOrOptions;
+            const source = typescript_1.default.createSourceFile(fileName, overlay.text, languageVersion, true, scriptKindForFile(fileName));
+            source.impliedNodeFormat = typescript_1.default.getImpliedNodeFormatForFile(fileName, undefined, base, options);
+            return source;
+        }
+    };
+}
+function createOverlayLanguageServiceHost(workspaceRoot, options, rootFiles, overlays, contextRevision) {
+    const overlayFor = (fileName) => overlays.get(canonicalSemanticFileKey(fileName));
+    return {
+        getCompilationSettings: () => options,
+        getScriptFileNames: () => [...rootFiles],
+        getScriptVersion: (fileName) => {
+            const overlay = overlayFor(fileName);
+            if (overlay) {
+                return `context:${contextRevision}:overlay:${overlay.version ?? 1}`;
+            }
+            try {
+                const stat = fs.statSync(fileName);
+                return `disk:${stat.mtimeMs}:${stat.size}`;
+            }
+            catch {
+                return "missing";
+            }
+        },
+        getScriptSnapshot: (fileName) => {
+            const text = overlayFor(fileName)?.text ?? typescript_1.default.sys.readFile(fileName);
+            return text === undefined ? undefined : typescript_1.default.ScriptSnapshot.fromString(text);
+        },
+        getCurrentDirectory: () => workspaceRoot,
+        getDefaultLibFileName: (compilerOptions) => typescript_1.default.getDefaultLibFilePath(compilerOptions),
+        fileExists: (fileName) => Boolean(overlayFor(fileName)) || typescript_1.default.sys.fileExists(fileName),
+        readFile: (fileName) => overlayFor(fileName)?.text ?? typescript_1.default.sys.readFile(fileName),
+        readDirectory: typescript_1.default.sys.readDirectory,
+        ...(typescript_1.default.sys.directoryExists ? { directoryExists: typescript_1.default.sys.directoryExists } : {}),
+        ...(typescript_1.default.sys.getDirectories ? { getDirectories: typescript_1.default.sys.getDirectories } : {}),
+        ...(typescript_1.default.sys.realpath ? { realpath: typescript_1.default.sys.realpath } : {}),
+        useCaseSensitiveFileNames: () => Boolean(typescript_1.default.sys.useCaseSensitiveFileNames),
+        getNewLine: () => typescript_1.default.sys.newLine
+    };
+}
+function canonicalSemanticFileKey(file, system = typescript_1.default.sys) {
+    const resolved = path.resolve(file);
+    let canonical = resolved;
+    try {
+        if (fs.existsSync(resolved)) {
+            canonical = path.normalize(system.realpath?.(resolved) ?? fs.realpathSync.native(resolved));
+        }
+    }
+    catch {
+        canonical = resolved;
+    }
+    return system.useCaseSensitiveFileNames ? canonical : canonical.toLowerCase();
+}
+function scriptKindForFile(file) {
+    switch (path.extname(file).toLowerCase()) {
+        case ".js": return typescript_1.default.ScriptKind.JS;
+        case ".jsx": return typescript_1.default.ScriptKind.JSX;
+        case ".tsx": return typescript_1.default.ScriptKind.TSX;
+        case ".json": return typescript_1.default.ScriptKind.JSON;
+        default: return typescript_1.default.ScriptKind.TS;
+    }
+}
+function uniqueSorted(values) {
+    return [...new Set(values.map((value) => path.resolve(value)))].sort((left, right) => left.localeCompare(right));
+}

package/dist/semantic/semantic-resident-admission.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SemanticResidentAdmissionCoordinator = void 0;
+/** Session-wide admission authority: many normal residents or one oversized resident, never both. */
+class SemanticResidentAdmissionCoordinator {
+    normalByOwner = new Map();
+    oversizedOwner = null;
+    get state() {
+        return {
+            normalResidents: [...this.normalByOwner.values()].reduce((sum, count) => sum + count, 0),
+            oversizedResident: this.oversizedOwner !== null
+        };
+    }
+    tryAcquireNormal(owner) {
+        if (this.oversizedOwner !== null)
+            return false;
+        this.normalByOwner.set(owner, (this.normalByOwner.get(owner) ?? 0) + 1);
+        return true;
+    }
+    releaseNormal(owner) {
+        const count = this.normalByOwner.get(owner) ?? 0;
+        if (count <= 1)
+            this.normalByOwner.delete(owner);
+        else
+            this.normalByOwner.set(owner, count - 1);
+    }
+    tryAcquireOversized(owner) {
+        if (this.oversizedOwner !== null || this.state.normalResidents > 0)
+            return false;
+        this.oversizedOwner = owner;
+        return true;
+    }
+    releaseOversized(owner) {
+        if (this.oversizedOwner === owner)
+            this.oversizedOwner = null;
+    }
+}
+exports.SemanticResidentAdmissionCoordinator = SemanticResidentAdmissionCoordinator;

package/dist/semantic/semantic-worker-child.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const semantic_worker_runtime_1 = require("./semantic-worker-runtime");
+const runtime = new semantic_worker_runtime_1.SemanticWorkerRuntime();
+process.on("message", (message) => {
+    if (message.type === "job") {
+        runJob(message);
+        return;
+    }
+    if (message.type === "invalidate") {
+        runtime.invalidate(message.workspaceRoot, message.change);
+        send({ type: "invalidated", id: message.id });
+        return;
+    }
+    runtime.dispose();
+    send({ type: "shutdown", id: message.id });
+    process.disconnect?.();
+});
+send({ type: "ready", pid: process.pid, memory: process.memoryUsage() });
+function runJob(message) {
+    try {
+        const output = runtime.run(message);
+        send({
+            type: "result",
+            id: message.id,
+            ...output
+        });
+    }
+    catch (error) {
+        send({ type: "error", id: message.id, error: serializeError(error) });
+    }
+}
+function send(message) {
+    process.send?.(message);
+}
+function serializeError(error) {
+    if (!(error instanceof Error))
+        return { name: "Error", message: String(error) };
+    return { name: error.name, message: error.message, ...(error.stack ? { stack: error.stack } : {}) };
+}