@likec4/language-server 1.42.1 → 1.44.0

package/dist/workspace/ProjectsManager.js

@@ -0,0 +1,373 @@
+import { isLikeC4Config, validateProjectConfig, } from '@likec4/config';
+import { BiMap, delay, invariant, memoizeProp, nonNullable } from '@likec4/core/utils';
+import { deepEqual } from 'fast-equals';
+import { interruptAndCheck, URI, WorkspaceCache, } from 'langium';
+import picomatch from 'picomatch';
+import { hasAtLeast, isNullish, map, pipe, prop, sortBy } from 'remeda';
+import { joinRelativeURL, parseFilename, withoutProtocol, withTrailingSlash, } from 'ufo';
+import { logger as mainLogger } from '../logger';
+const logger = mainLogger.getChild('ProjectsManager');
+function normalizeUri(uri) {
+    if (URI.isUri(uri)) {
+        return uri.toString();
+    }
+    else if (typeof uri === 'string') {
+        // TODO: handle non-file URIs, i.e. vscode-remote://
+        return uri.startsWith('file://') ? uri : URI.file(uri).toString();
+    }
+    else {
+        return uri.uri.toString();
+    }
+}
+export function ProjectFolder(folder) {
+    folder = normalizeUri(folder);
+    return withTrailingSlash(folder);
+}
+const DefaultProject = {
+    id: 'default',
+    config: {
+        name: 'default',
+        exclude: ['**/node_modules/**'],
+    },
+    exclude: picomatch('**/node_modules/**', { dot: true }),
+};
+export class ProjectsManager {
+    services;
+    /**
+     * The global project ID used for all documents
+     * that are not part of a specific project.
+     */
+    static DefaultProjectId = DefaultProject.id;
+    /**
+     * Configured default project ID.
+     * (it is used in CLI and Vite plugin)
+     */
+    #defaultProjectId = undefined;
+    /**
+     * The mapping between project config files and project IDs.
+     */
+    #projectIdToFolder = new BiMap();
+    /**
+     * Registered projects.
+     * Sorted descending by the number of segments in the folder path.
+     * This ensures that the most specific project is used for a document.
+     */
+    #projects = [];
+    #excludedDocuments = new WeakMap();
+    constructor(services) {
+        this.services = services;
+        logger.debug `created`;
+    }
+    /**
+     * Returns:
+     *  - configured default project ID if set
+     *  - the default project ID if there are no projects.
+     *  - the ID of the only project
+     *  - undefined if there are multiple projects.
+     */
+    get defaultProjectId() {
+        if (this.#defaultProjectId) {
+            return this.#defaultProjectId;
+        }
+        if (this.#projects.length > 1) {
+            return undefined;
+        }
+        return this.#projects[0]?.id ?? ProjectsManager.DefaultProjectId;
+    }
+    set defaultProjectId(id) {
+        if (id === this.#defaultProjectId) {
+            return;
+        }
+        if (!id || id === ProjectsManager.DefaultProjectId) {
+            logger.debug `reset default project ID`;
+            this.#defaultProjectId = undefined;
+            return;
+        }
+        invariant(this.#projects.find(p => p.id === id), `Project "${id}" not found`);
+        logger.debug `set default project ID to ${id}`;
+        this.#defaultProjectId = id;
+    }
+    get all() {
+        if (hasAtLeast(this.#projects, 1)) {
+            const ids = [
+                ...map(this.#projects, prop('id')),
+                DefaultProject.id,
+            ];
+            // if default project is set, ensure it is first
+            if (this.#defaultProjectId) {
+                const idx = ids.findIndex(p => p === this.#defaultProjectId);
+                if (idx > 0) {
+                    const [defaultProject] = ids.splice(idx, 1);
+                    return [defaultProject, ...ids];
+                }
+            }
+            return ids;
+        }
+        return [DefaultProject.id];
+    }
+    getProject(arg) {
+        const id = typeof arg === 'string' ? arg : (arg.likec4ProjectId || this.belongsTo(arg));
+        if (id === DefaultProject.id) {
+            let folderUri;
+            try {
+                folderUri = this.services.workspace.WorkspaceManager.workspaceUri;
+            }
+            catch (error) {
+                logger.warn('Failed to get workspace URI, using default folder', { error });
+                folderUri = URI.file('');
+                // ignore - workspace not initialized
+            }
+            return {
+                id: ProjectsManager.DefaultProjectId,
+                config: DefaultProject.config,
+                folderUri,
+            };
+        }
+        const { config, folderUri, } = nonNullable(this.#projects.find(p => p.id === id), `Project "${id}" not found`);
+        return {
+            id,
+            folderUri,
+            config,
+        };
+    }
+    /**
+     * Validates and ensures the project ID.
+     * If no project ID is specified, returns default project ID
+     * If there are multiple projects and default project is not set, throws an error
+     */
+    ensureProjectId(projectId) {
+        if (projectId === ProjectsManager.DefaultProjectId) {
+            return this.defaultProjectId ?? ProjectsManager.DefaultProjectId;
+        }
+        if (projectId) {
+            invariant(this.#projectIdToFolder.has(projectId), `Project ID ${projectId} is not registered`);
+            return projectId;
+        }
+        return nonNullable(this.defaultProjectId, () => `Specify exact project, known: [${[...this.#projectIdToFolder.keys()].join(', ')}]`);
+    }
+    /**
+     * Validates and ensures the project.
+     */
+    ensureProject(projectId) {
+        projectId = this.ensureProjectId(projectId);
+        return this.getProject(projectId);
+    }
+    hasMultipleProjects() {
+        return this.#projects.length > 1;
+    }
+    /**
+     * Checks if the specified document should be excluded from processing.
+     */
+    isExcluded(document) {
+        if (typeof document === 'string' || URI.isUri(document)) {
+            let docUriAsString = normalizeUri(document);
+            const project = this.findProjectForDocument(docUriAsString);
+            return project.exclude ? project.exclude(withoutProtocol(docUriAsString)) : false;
+        }
+        let isExcluded = this.#excludedDocuments.get(document);
+        if (isExcluded === undefined) {
+            isExcluded = this.isExcluded(document.uri);
+            this.#excludedDocuments.set(document, isExcluded);
+        }
+        return isExcluded;
+    }
+    /**
+     * Checks if it is a config file and it is not excluded by default exclude pattern
+     *
+     * @param entry The file system entry to check
+     */
+    isConfigFile(entry) {
+        const filename = parseFilename(entry.toString(), { strict: false })?.toLowerCase();
+        const isConfigFile = !!filename && isLikeC4Config(filename);
+        if (isConfigFile) {
+            if (DefaultProject.exclude(entry.path)) {
+                logger.debug `exclude config file ${entry.path}`;
+                return false;
+            }
+        }
+        return isConfigFile;
+    }
+    /**
+     * Checks if the provided file system entry is a valid project config file.
+     *
+     * @param entry The file system entry to check
+     */
+    async registerConfigFile(configFile) {
+        if (this.isConfigFile(configFile)) {
+            try {
+                return await this.registerProject(configFile);
+            }
+            catch (error) {
+                this.services.lsp.Connection?.window.showErrorMessage(`LikeC4: Failed to register project at ${configFile.fsPath}`);
+                logger.warn('Failed to register project at {uri}', { uri: configFile.fsPath, error });
+                return undefined;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Registers (or reloads) likec4 project by config file or config object.
+     * If there is some project registered at same folder, it will be reloaded.
+     */
+    async registerProject(opts) {
+        if (URI.isUri(opts)) {
+            const configFile = opts;
+            const config = await this.services.workspace.FileSystemProvider.loadProjectConfig(configFile);
+            const path = joinRelativeURL(configFile.path, '..');
+            const folderUri = configFile.with({ path });
+            return this._registerProject({ config, folderUri });
+        }
+        return this._registerProject(opts);
+    }
+    /**
+     * Registers (or reloads) likec4 project by config file or config object.
+     * If there is some project registered at same folder, it will be reloaded.
+     */
+    _registerProject(opts) {
+        const config = validateProjectConfig(opts.config);
+        const folder = ProjectFolder(opts.folderUri);
+        let project = this.#projects.find(p => p.folder === folder);
+        if (project && deepEqual(project.config, config)) {
+            return project;
+        }
+        let mustReset = false;
+        let id;
+        if (!project) {
+            if (this.#projectIdToFolder.has(config.name)) {
+                logger.warn `Project "${config.name}" already exists, generating unique ID`;
+            }
+            id = this.uniqueProjectId(config.name);
+            project = {
+                id,
+                config,
+                folder,
+                folderUri: URI.parse(folder),
+            };
+            // if there is any project within subfolder or parent folder
+            // we need to reset assigned to documents project IDs
+            mustReset = this.#projects.some(p => p.folder.startsWith(folder) || folder.startsWith(p.folder));
+            this.#projects = pipe([...this.#projects, project], sortBy([({ folder }) => withoutProtocol(folder).split('/').length, 'desc']));
+            logger.info `register project ${project.id} folder: ${folder}`;
+        }
+        else {
+            // Project exists but configs are different (deepEqual check above)
+            mustReset = true;
+            if (project.config.name !== config.name) {
+                this.#projectIdToFolder.delete(project.id);
+                logger.info `unregister project ${project.id} folder: ${folder}`;
+                id = this.uniqueProjectId(config.name);
+                project.id = id;
+                logger.info `re-register project ${project.id} folder: ${folder}`;
+            }
+            else {
+                id = project.id;
+                logger.info `update project ${project.id} on config change`;
+            }
+            project.config = config;
+        }
+        if (isNullish(config.exclude)) {
+            project.exclude = DefaultProject.exclude;
+        }
+        else if (hasAtLeast(config.exclude, 1)) {
+            project.exclude = picomatch(config.exclude, { dot: true });
+        }
+        this.#projectIdToFolder.set(project.id, folder);
+        if (mustReset) {
+            this.resetProjectIds();
+        }
+        return project;
+    }
+    belongsTo(document) {
+        const documentUri = normalizeUri(document);
+        return this.findProjectForDocument(documentUri).id;
+    }
+    #activeReload = null;
+    async reloadProjects() {
+        try {
+            if (!this.#activeReload) {
+                logger.debug `schedule reload projects`;
+                this.#activeReload = this._reloadProjects();
+            }
+            else {
+                logger.debug `reload projects is already in progress, waiting`;
+            }
+            await this.#activeReload;
+        }
+        finally {
+            this.#activeReload = null;
+        }
+    }
+    async _reloadProjects() {
+        // debounce reload projects
+        await delay(200);
+        const folders = this.services.workspace.WorkspaceManager.workspaceFolders;
+        if (!folders) {
+            logger.warn('No workspace folders found');
+            return;
+        }
+        await this.services.workspace.WorkspaceLock.write(async (cancelToken) => {
+            const configFiles = [];
+            for (const folder of folders) {
+                try {
+                    const files = await this.services.workspace.FileSystemProvider.scanProjectFiles(URI.parse(folder.uri));
+                    for (const file of files) {
+                        if (file.isFile && this.isConfigFile(file.uri)) {
+                            configFiles.push(file);
+                        }
+                    }
+                }
+                catch (error) {
+                    logger.error('Failed to scanProjectFiles, {folder}', { folder: folder.uri, error });
+                }
+            }
+            if (configFiles.length === 0 && this.#projects.length !== 0) {
+                logger.warning('No config files found, but some projects were registered before');
+            }
+            await interruptAndCheck(cancelToken);
+            logger.debug `start reload projects`;
+            this.#projects = [];
+            this.#projectIdToFolder.clear();
+            for (const entry of configFiles) {
+                try {
+                    await this.registerConfigFile(entry.uri);
+                }
+                catch (error) {
+                    logger.error('Failed to load config file {uri}', { uri: entry.uri.toString(), error });
+                }
+            }
+            this.resetProjectIds();
+            await this.rebuidDocuments(cancelToken);
+        });
+    }
+    uniqueProjectId(name) {
+        let id = name;
+        let i = 1;
+        while (this.#projectIdToFolder.has(id)) {
+            id = `${name}-${i++}`;
+        }
+        return id;
+    }
+    resetProjectIds() {
+        if (this.#defaultProjectId && !this.#projectIdToFolder.has(this.#defaultProjectId)) {
+            this.#defaultProjectId = undefined;
+        }
+        this.mappingsToProject.clear();
+        this.#excludedDocuments = new WeakMap();
+        this.services.workspace.LangiumDocuments.resetProjectIds();
+    }
+    async rebuidDocuments(cancelToken) {
+        await this.services.workspace.WorkspaceManager.rebuildAll(cancelToken);
+    }
+    findProjectForDocument(documentUri) {
+        return this.mappingsToProject.get(documentUri, () => {
+            const project = this.#projects.find(({ folder }) => documentUri.startsWith(folder));
+            // If the document is not part of any project, assign it to the global project ID
+            return project ?? DefaultProject;
+        });
+    }
+    // The mapping between document URIs and their corresponding project ID
+    // Lazy-created due to initialization order of the LanguageServer
+    get mappingsToProject() {
+        return memoizeProp(this, '_mappingsToProject', () => new WorkspaceCache(this.services));
+    }
+}

package/dist/workspace/WorkspaceManager.d.ts

@@ -1,4 +1,4 @@
-import type { BuildOptions, FileSelector, FileSystemNode, LangiumDocument, LangiumDocumentFactory } from 'langium';
+import type { BuildOptions, Cancellation, FileSelector, FileSystemNode, LangiumDocument, LangiumDocumentFactory } from 'langium';
 import { DefaultWorkspaceManager } from 'langium';
 import type { WorkspaceFolder } from 'vscode-languageserver';
 import { URI } from 'vscode-uri';
@@ -24,7 +24,8 @@ export declare class LikeC4WorkspaceManager extends DefaultWorkspaceManager {
      * Determine whether the given folder entry shall be included while indexing the workspace.
      */
     protected includeEntry(_workspaceFolder: WorkspaceFolder, entry: FileSystemNode, selector: FileSelector): boolean;
-    workspace(): any;
+    workspace(): WorkspaceFolder | null;
+    rebuildAll(cancelToken?: Cancellation.CancellationToken): Promise<void>;
     get workspaceUri(): URI;
     get workspaceURL(): URL;
 }

package/dist/workspace/WorkspaceManager.js

@@ -0,0 +1,93 @@
+import { invariant } from '@likec4/core';
+import { DefaultWorkspaceManager } from 'langium';
+import { hasAtLeast } from 'remeda';
+import { URI } from 'vscode-uri';
+import * as BuiltIn from '../likec4lib';
+import { logger, logWarnError } from '../logger';
+export class LikeC4WorkspaceManager extends DefaultWorkspaceManager {
+    services;
+    documentFactory;
+    fileSystemProvider;
+    initialBuildOptions = {
+        eagerLinking: true,
+        validation: true,
+    };
+    constructor(services) {
+        super(services);
+        this.services = services;
+        this.documentFactory = services.workspace.LangiumDocumentFactory;
+        this.fileSystemProvider = services.workspace.FileSystemProvider;
+    }
+    /**
+     * First load all project config files, then load all documents in the workspace.
+     */
+    async performStartup(folders) {
+        this.folders ??= folders;
+        const configFiles = [];
+        for (const folder of folders) {
+            try {
+                const uri = URI.parse(folder.uri);
+                const found = await this.fileSystemProvider.scanProjectFiles(uri);
+                configFiles.push(...found);
+                this.services.workspace.FileSystemWatcher.watch(uri.fsPath);
+            }
+            catch (error) {
+                logWarnError(error);
+            }
+        }
+        // Project config files
+        const projects = this.services.workspace.ProjectsManager;
+        for (const entry of configFiles) {
+            try {
+                await projects.registerConfigFile(entry.uri);
+            }
+            catch (error) {
+                logWarnError(error);
+            }
+        }
+        return await super.performStartup(folders);
+    }
+    /**
+     * Load all additional documents that shall be visible in the context of the given workspace
+     * folders and add them to the collector. This can be used to include built-in libraries of
+     * your language, which can be either loaded from provided files or constructed in memory.
+     */
+    async loadAdditionalDocuments(folders, collector) {
+        collector(this.documentFactory.fromString(BuiltIn.Content, URI.parse(BuiltIn.Uri)));
+        await super.loadAdditionalDocuments(folders, collector);
+    }
+    /**
+     * Determine whether the given folder entry shall be included while indexing the workspace.
+     */
+    includeEntry(_workspaceFolder, entry, selector) {
+        if (this.services.workspace.ProjectsManager.isConfigFile(entry.uri)) {
+            return false;
+        }
+        if (entry.isFile) {
+            return !this.services.workspace.ProjectsManager.isExcluded(entry.uri);
+        }
+        return super.includeEntry(_workspaceFolder, entry, selector);
+    }
+    workspace() {
+        if (this.folders && hasAtLeast(this.folders, 1)) {
+            return this.folders[0];
+        }
+        return null;
+    }
+    async rebuildAll(cancelToken) {
+        const docs = this.services.workspace.LangiumDocuments.all.map(d => d.uri).toArray();
+        logger.info('invalidate and rebuild all {docs} documents', { docs: docs.length });
+        this.services.workspace.Cache.clear();
+        await this.documentBuilder.update(docs, [], cancelToken);
+    }
+    get workspaceUri() {
+        const workspace = this.workspace();
+        invariant(workspace, 'Workspace not initialized');
+        return URI.parse(workspace.uri);
+    }
+    get workspaceURL() {
+        const workspace = this.workspace();
+        invariant(workspace, 'Workspace not initialized');
+        return new URL(workspace.uri);
+    }
+}

package/dist/workspace/index.js

@@ -0,0 +1,5 @@
+export * from './AstNodeDescriptionProvider';
+export * from './IndexManager';
+export * from './LangiumDocuments';
+export * from './ProjectsManager';
+export * from './WorkspaceManager';

package/likec4lib/package.json

@@ -1,4 +1,4 @@
 {
   "types": "../dist/likec4lib.d.ts",
-  "module": "../dist/likec4lib.mjs"
+  "module": "../dist/likec4lib.js"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@likec4/language-server",
   "description": "LikeC4 Language Server",
-  "version": "1.42.1",
+  "version": "1.44.0",
   "license": "MIT",
   "bugs": "https://github.com/likec4/likec4/issues",
   "homepage": "https://likec4.dev",
@@ -34,39 +34,39 @@
       "sources": "./src/index.ts",
       "default": {
         "types": "./dist/index.d.ts",
-        "default": "./dist/index.mjs"
+        "default": "./dist/index.js"
       }
     },
     "./likec4lib": {
       "sources": "./src/likec4lib.ts",
       "default": {
         "types": "./dist/likec4lib.d.ts",
-        "import": "./dist/likec4lib.mjs",
-        "default": "./dist/likec4lib.mjs"
+        "import": "./dist/likec4lib.js",
+        "default": "./dist/likec4lib.js"
       }
     },
     "./browser-worker": {
       "sources": "./src/browser-worker.ts",
       "default": {
         "types": "./dist/browser-worker.d.ts",
-        "import": "./dist/browser-worker.mjs",
-        "default": "./dist/browser-worker.mjs"
+        "import": "./dist/browser-worker.js",
+        "default": "./dist/browser-worker.js"
       }
     },
     "./browser": {
       "sources": "./src/browser.ts",
       "default": {
         "types": "./dist/browser.d.ts",
-        "import": "./dist/browser.mjs",
-        "default": "./dist/browser.mjs"
+        "import": "./dist/browser.js",
+        "default": "./dist/browser.js"
       }
     },
     "./protocol": {
       "sources": "./src/protocol.ts",
       "default": {
         "types": "./dist/protocol.d.ts",
-        "import": "./dist/protocol.mjs",
-        "default": "./dist/protocol.mjs"
+        "import": "./dist/protocol.js",
+        "default": "./dist/protocol.js"
       }
     },
     "./bundled": "./dist/bundled.mjs"
@@ -76,47 +76,48 @@
     "access": "public"
   },
   "dependencies": {
-    "@hpcc-js/wasm-graphviz": "1.12.0",
+    "@hpcc-js/wasm-graphviz": "1.15.0",
     "bundle-require": "^5.1.0",
-    "esbuild": "0.25.9"
+    "esbuild": "0.25.11"
   },
   "devDependencies": {
-    "@hono/node-server": "^1.19.3",
-    "@modelcontextprotocol/sdk": "^1.17.5",
+    "@hono/node-server": "^1.19.5",
+    "@modelcontextprotocol/sdk": "^1.20.1",
     "@msgpack/msgpack": "^3.1.2",
-    "@smithy/util-base64": "^4.0.0",
+    "@smithy/util-base64": "^4.3.0",
     "@types/natural-compare-lite": "^1.4.2",
-    "@types/node": "~20.19.11",
+    "@types/node": "~20.19.22",
     "@types/picomatch": "^4.0.2",
     "@types/vscode": "^1.84.0",
     "@types/which": "^3.0.4",
     "chokidar": "^4.0.3",
     "defu": "^6.1.4",
     "esm-env": "^1.2.2",
-    "fast-equals": "^5.2.2",
+    "fast-equals": "^5.3.2",
     "fdir": "6.4.0",
     "fetch-to-node": "^2.1.0",
-    "hono": "^4.9.8",
+    "hono": "^4.10.2",
     "indent-string": "^5.0.0",
     "json5": "^2.2.3",
     "langium": "3.5.0",
     "langium-cli": "3.5.2",
+    "nano-spawn": "^1.0.3",
     "natural-compare-lite": "^1.4.0",
-    "oxlint": "1.18.0",
+    "oxlint": "1.28.0",
     "p-debounce": "4.0.0",
     "p-queue": "8.1.1",
     "p-timeout": "6.1.4",
     "picomatch": "^4.0.3",
     "pretty-ms": "^9.2.0",
-    "remeda": "^2.31.1",
-    "strip-indent": "^4.0.0",
+    "remeda": "^2.32.0",
+    "strip-indent": "^4.1.1",
     "tsx": "4.20.6",
-    "turbo": "2.5.8",
+    "turbo": "2.6.0",
     "type-fest": "^4.41.0",
-    "typescript": "5.9.2",
+    "typescript": "5.9.3",
     "ufo": "1.6.1",
     "unbuild": "3.5.0",
-    "vitest": "3.2.4",
+    "vitest": "4.0.8",
     "vscode-jsonrpc": "8.2.1",
     "vscode-languageserver": "9.0.1",
     "vscode-languageserver-protocol": "3.17.5",
@@ -124,12 +125,12 @@
     "vscode-uri": "3.1.0",
     "which": "^5.0.0",
     "zod": "^3.25.76",
-    "@likec4/core": "1.42.1",
-    "@likec4/config": "1.42.1",
-    "@likec4/icons": "1.42.1",
-    "@likec4/log": "1.42.1",
-    "@likec4/layouts": "1.42.1",
-    "@likec4/tsconfig": "1.42.1",
+    "@likec4/core": "1.44.0",
+    "@likec4/config": "1.44.0",
+    "@likec4/layouts": "1.44.0",
+    "@likec4/log": "1.44.0",
+    "@likec4/icons": "1.44.0",
+    "@likec4/tsconfig": "1.44.0",
     "@likec4/devops": "1.42.0"
   },
   "scripts": {
@@ -151,5 +152,5 @@
     "test:watch": "vitest"
   },
   "types": "dist/index.d.ts",
-  "module": "dist/index.mjs"
+  "module": "dist/index.js"
 }

package/protocol/package.json

@@ -1,4 +1,4 @@
 {
   "types": "../dist/protocol.d.ts",
-  "module": "../dist/protocol.mjs"
+  "module": "../dist/protocol.js"
 }