@likec4/language-server 1.44.0 → 1.46.0

package/dist/workspace/ProjectsManager.js

@@ -1,10 +1,12 @@
-import { isLikeC4Config, validateProjectConfig, } from '@likec4/config';
+import { isLikeC4Config, normalizeIncludeConfig, validateProjectConfig, } from '@likec4/config';
 import { BiMap, delay, invariant, memoizeProp, nonNullable } from '@likec4/core/utils';
+import { wrapError } from '@likec4/log';
 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 { isLikeC4Builtin } from '../likec4lib';
 import { logger as mainLogger } from '../logger';
 const logger = mainLogger.getChild('ProjectsManager');
 function normalizeUri(uri) {
@@ -30,6 +32,7 @@ const DefaultProject = {
         exclude: ['**/node_modules/**'],
     },
     exclude: picomatch('**/node_modules/**', { dot: true }),
+    includeConfig: { paths: [], maxDepth: 3, fileThreshold: 30 },
 };
 export class ProjectsManager {
     services;
@@ -43,6 +46,10 @@ export class ProjectsManager {
      * (it is used in CLI and Vite plugin)
      */
     #defaultProjectId = undefined;
+    /**
+     * Cached default project.
+     */
+    #defaultProject = undefined;
     /**
      * The mapping between project config files and project IDs.
      */
@@ -78,6 +85,7 @@ export class ProjectsManager {
         if (id === this.#defaultProjectId) {
             return;
         }
+        this.#defaultProject = undefined;
         if (!id || id === ProjectsManager.DefaultProjectId) {
             logger.debug `reset default project ID`;
             this.#defaultProjectId = undefined;
@@ -87,6 +95,25 @@ export class ProjectsManager {
         logger.debug `set default project ID to ${id}`;
         this.#defaultProjectId = id;
     }
+    get default() {
+        if (!this.#defaultProject) {
+            const id = this.defaultProjectId ?? ProjectsManager.DefaultProjectId;
+            let project = this.#projects.find(p => p.id === id);
+            if (!project) {
+                const folderUri = this.getWorkspaceFolder();
+                project = {
+                    id,
+                    config: DefaultProject.config,
+                    folder: ProjectFolder(folderUri),
+                    folderUri,
+                    exclude: DefaultProject.exclude,
+                    includeConfig: DefaultProject.includeConfig,
+                };
+            }
+            this.#defaultProject = project;
+        }
+        return this.#defaultProject;
+    }
     get all() {
         if (hasAtLeast(this.#projects, 1)) {
             const ids = [
@@ -114,7 +141,7 @@ export class ProjectsManager {
             }
             catch (error) {
                 logger.warn('Failed to get workspace URI, using default folder', { error });
-                folderUri = URI.file('');
+                folderUri = URI.file('/');
                 // ignore - workspace not initialized
             }
             return {
@@ -123,11 +150,12 @@ export class ProjectsManager {
                 folderUri,
             };
         }
-        const { config, folderUri, } = nonNullable(this.#projects.find(p => p.id === id), `Project "${id}" not found`);
+        const project = nonNullable(this.#projects.find(p => p.id === id), `Project "${id}" not found`);
         return {
             id,
-            folderUri,
-            config,
+            folderUri: project.folderUri,
+            config: project.config,
+            ...(project.includePaths && { includePaths: project.includePaths.map(p => p.uri) }),
         };
     }
     /**
@@ -188,42 +216,31 @@ export class ProjectsManager {
         return isConfigFile;
     }
     /**
-     * Checks if the provided file system entry is a valid project config file.
-     *
-     * @param entry The file system entry to check
+     * Registers likec4 project by config file.
      */
     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;
-            }
+        if (DefaultProject.exclude(configFile.path)) {
+            throw new Error(`Path to ${configFile.fsPath} is excluded by: ${DefaultProject.config.exclude.join(', ')}`);
         }
-        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;
+        if (!this.isConfigFile(configFile)) {
+            throw new Error(`${configFile.fsPath} is not a valid LikeC4 config filename.`);
+        }
+        try {
             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 await this.registerProject({ config, folderUri });
+        }
+        catch (error) {
+            this.services.lsp.Connection?.window.showErrorMessage(`LikeC4: Failed to register project at ${configFile.fsPath}`);
+            throw wrapError(error, `Failed to register project config ${configFile.fsPath}:\n`);
         }
-        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) {
+    async registerProject(opts) {
         const config = validateProjectConfig(opts.config);
         const folder = ProjectFolder(opts.folderUri);
         let project = this.#projects.find(p => p.folder === folder);
@@ -237,11 +254,13 @@ export class ProjectsManager {
                 logger.warn `Project "${config.name}" already exists, generating unique ID`;
             }
             id = this.uniqueProjectId(config.name);
+            const includeConfig = normalizeIncludeConfig(config.include);
             project = {
                 id,
                 config,
                 folder,
                 folderUri: URI.parse(folder),
+                includeConfig,
             };
             // if there is any project within subfolder or parent folder
             // we need to reset assigned to documents project IDs
@@ -264,22 +283,83 @@ export class ProjectsManager {
                 logger.info `update project ${project.id} on config change`;
             }
             project.config = config;
+            const includeConfig = normalizeIncludeConfig(config.include);
+            project.includeConfig = includeConfig;
         }
+        // Reset cached default project
+        this.#defaultProject = undefined;
         if (isNullish(config.exclude)) {
             project.exclude = DefaultProject.exclude;
         }
         else if (hasAtLeast(config.exclude, 1)) {
             project.exclude = picomatch(config.exclude, { dot: true });
         }
+        // Resolve include paths relative to project folder
+        if (project.includeConfig.paths && hasAtLeast(project.includeConfig.paths, 1)) {
+            project.includePaths = project.includeConfig.paths.map(includePath => {
+                const resolvedPath = joinRelativeURL(project.folderUri.path, includePath);
+                const uri = project.folderUri.with({ path: resolvedPath });
+                return {
+                    uri,
+                    folder: ProjectFolder(uri),
+                };
+            });
+            logger.debug `project ${project.id} include paths: ${project.includePaths.map(p => p.uri.fsPath).join(', ')}`;
+            // Check for overlapping include paths with other projects
+            for (const includePath of project.includePaths) {
+                // Check if this include path overlaps with another project's folder
+                for (const otherProject of this.#projects) {
+                    if (otherProject.id === project.id)
+                        continue;
+                    if (includePath.folder.startsWith(otherProject.folder) || otherProject.folder.startsWith(includePath.folder)) {
+                        logger.warn('Project "{projectId}" include path "{includePath}" overlaps with project "{otherProjectId}" folder. ' +
+                            'Files in overlapping areas will only belong to one project.', { projectId: project.id, includePath: includePath.folder, otherProjectId: otherProject.id });
+                    }
+                    // Check if this include path overlaps with another project's include paths
+                    if (otherProject.includePaths) {
+                        for (const otherIncludePath of otherProject.includePaths) {
+                            if (includePath.folder.startsWith(otherIncludePath.folder)
+                                || otherIncludePath.folder.startsWith(includePath.folder)) {
+                                logger.warn('Project "{projectId}" include path "{includePath}" overlaps with project "{otherProjectId}" ' +
+                                    'include path "{otherIncludePath}". Files in overlapping areas will only belong to one project.', {
+                                    projectId: project.id,
+                                    includePath: includePath.folder,
+                                    otherProjectId: otherProject.id,
+                                    otherIncludePath: otherIncludePath.folder,
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        else {
+            delete project.includePaths;
+        }
         this.#projectIdToFolder.set(project.id, folder);
-        if (mustReset) {
-            this.resetProjectIds();
+        // Reset assigned project IDs if no projects reload is active
+        if (mustReset && !this.#activeReload) {
+            await this.rebuidProject(project.id).catch(error => {
+                logger.warn('Failed to rebuild project {projectId} after config change', {
+                    projectId: project.id,
+                    error,
+                });
+            });
         }
         return project;
     }
+    /**
+     * Determines which project the given document belongs to.
+     * If the document does not belong to any project, returns the default project ID.
+     */
     belongsTo(document) {
-        const documentUri = normalizeUri(document);
-        return this.findProjectForDocument(documentUri).id;
+        if (URI.isUri(document) || typeof document === 'string') {
+            const documentUri = normalizeUri(document);
+            return this.findProjectForDocument(documentUri).id;
+        }
+        return this.documentBelongsTo.get(document, () => {
+            return this.findProjectForDocument(normalizeUri(document.uri));
+        }).id;
     }
     #activeReload = null;
     async reloadProjects() {
@@ -306,13 +386,16 @@ export class ProjectsManager {
             return;
         }
         await this.services.workspace.WorkspaceLock.write(async (cancelToken) => {
+            logger.debug `start reload projects`;
             const configFiles = [];
             for (const folder of folders) {
                 try {
+                    logger.debug `scan projects in folder ${folder.uri}`;
                     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);
+                            logger.debug `found config ${file.uri.fsPath}`;
+                            configFiles.push(file.uri);
                         }
                     }
                 }
@@ -324,19 +407,18 @@ export class ProjectsManager {
                 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) {
+            for (const uri of configFiles) {
                 try {
-                    await this.registerConfigFile(entry.uri);
+                    await this.registerConfigFile(uri);
                 }
                 catch (error) {
-                    logger.error('Failed to load config file {uri}', { uri: entry.uri.toString(), error });
+                    logger.error('Failed to load config file {uri}', { uri: uri.fsPath, error });
                 }
             }
-            this.resetProjectIds();
-            await this.rebuidDocuments(cancelToken);
+            this.reset();
+            await this.services.workspace.WorkspaceManager.rebuildAll(cancelToken);
         });
     }
     uniqueProjectId(name) {
@@ -347,22 +429,86 @@ export class ProjectsManager {
         }
         return id;
     }
-    resetProjectIds() {
+    reset() {
+        this.#defaultProject = undefined;
         if (this.#defaultProjectId && !this.#projectIdToFolder.has(this.#defaultProjectId)) {
             this.#defaultProjectId = undefined;
         }
+        this.services.workspace.LangiumDocuments.all.forEach(doc => {
+            if (isLikeC4Builtin(doc.uri)) {
+                return;
+            }
+            // Remove assigned project ID to force re-calculation
+            delete doc.likec4ProjectId;
+        });
+        this.documentBelongsTo.clear();
         this.mappingsToProject.clear();
         this.#excludedDocuments = new WeakMap();
-        this.services.workspace.LangiumDocuments.resetProjectIds();
     }
-    async rebuidDocuments(cancelToken) {
-        await this.services.workspace.WorkspaceManager.rebuildAll(cancelToken);
+    async rebuidProject(projectId, cancelToken) {
+        if (!cancelToken) {
+            return await this.services.workspace.WorkspaceLock.write(async (ct) => {
+                await this.rebuidProject(projectId, ct);
+            });
+        }
+        logger.info `rebuild project ${projectId}`;
+        // reset default project cache
+        this.#defaultProject = undefined;
+        const project = this.#projects.find(p => p.id === projectId) ?? this.default;
+        if (project.id !== projectId) {
+            logger.warn `Project ${projectId} not found, rebuilding default project ${project.id}`;
+        }
+        const log = logger.getChild(project.id);
+        const folder = project.folder;
+        const includePathStrings = project.includePaths?.map(p => p.folder) ?? [];
+        const docs = this.services.workspace.LangiumDocuments
+            .all
+            .filter(doc => {
+            if (project.exclude?.(doc.uri.path)) {
+                return false;
+            }
+            const docUriStr = doc.uri.toString();
+            if (docUriStr.startsWith(folder)) {
+                return true;
+            }
+            if (includePathStrings.some(includePath => docUriStr.startsWith(includePath))) {
+                return true;
+            }
+            const docdir = withTrailingSlash(joinRelativeURL(docUriStr, '..'));
+            return docdir.startsWith(folder) || folder.startsWith(docdir);
+        })
+            .map(d => d.uri)
+            .toArray();
+        if (docs.length > 0) {
+            this.reset();
+            log.info('rebuild documents: {docs}', {
+                docs: docs.length,
+            });
+            await this.services.workspace.DocumentBuilder
+                .update(docs, [], cancelToken)
+                .catch(error => {
+                log.warn('Failed to rebuild project', {
+                    error,
+                });
+            });
+        }
     }
     findProjectForDocument(documentUri) {
         return this.mappingsToProject.get(documentUri, () => {
             const project = this.#projects.find(({ folder }) => documentUri.startsWith(folder));
+            if (project) {
+                return project;
+            }
+            const projectWithInclude = this.#projects.find(({ includePaths }) => {
+                if (!includePaths)
+                    return false;
+                return includePaths.some(includePath => documentUri.startsWith(includePath.folder));
+            });
+            if (projectWithInclude) {
+                return projectWithInclude;
+            }
             // If the document is not part of any project, assign it to the global project ID
-            return project ?? DefaultProject;
+            return this.default;
         });
     }
     // The mapping between document URIs and their corresponding project ID
@@ -370,4 +516,40 @@ export class ProjectsManager {
     get mappingsToProject() {
         return memoizeProp(this, '_mappingsToProject', () => new WorkspaceCache(this.services));
     }
+    /**
+     * The mapping between documents and projects they belong to.
+     * Lazy-created due to initialization order of the LanguageServer
+     */
+    get documentBelongsTo() {
+        return memoizeProp(this, '_documentBelongsTo', () => new WorkspaceCache(this.services));
+    }
+    /**
+     * Returns all include paths from all projects.
+     * Used by WorkspaceManager to scan additional directories for C4 files.
+     */
+    getAllIncludePaths() {
+        const result = [];
+        for (const project of this.#projects) {
+            if (project.includePaths) {
+                for (const includePath of project.includePaths) {
+                    result.push({
+                        projectId: project.id,
+                        includePath: includePath.uri,
+                        includeConfig: project.includeConfig,
+                    });
+                }
+            }
+        }
+        return result;
+    }
+    getWorkspaceFolder() {
+        try {
+            return this.services.workspace.WorkspaceManager.workspaceUri;
+        }
+        catch (error) {
+            logger.warn('Failed to get workspace URI, using default folder', { error });
+            return URI.file('/');
+            // ignore - workspace not initialized
+        }
+    }
 }

package/dist/workspace/WorkspaceManager.js

@@ -54,6 +54,44 @@ export class LikeC4WorkspaceManager extends DefaultWorkspaceManager {
      */
     async loadAdditionalDocuments(folders, collector) {
         collector(this.documentFactory.fromString(BuiltIn.Content, URI.parse(BuiltIn.Uri)));
+        // Load documents from project include paths
+        const includePaths = this.services.workspace.ProjectsManager.getAllIncludePaths();
+        let totalFilesLoaded = 0;
+        for (const { projectId, includePath, includeConfig } of includePaths) {
+            try {
+                logger.debug `scanning include path ${includePath.fsPath} for project ${projectId}`;
+                const files = await this.fileSystemProvider.readDirectory(includePath, {
+                    recursive: true,
+                    maxDepth: includeConfig.maxDepth,
+                });
+                let filesLoadedFromPath = 0;
+                for (const file of files) {
+                    if (file.isFile && !this.services.workspace.ProjectsManager.isExcluded(file.uri)) {
+                        const doc = await this.documentFactory.fromUri(file.uri);
+                        collector(doc);
+                        filesLoadedFromPath++;
+                        totalFilesLoaded++;
+                    }
+                }
+                logger.debug `loaded ${filesLoadedFromPath} files from include path ${includePath.fsPath}`;
+            }
+            catch (error) {
+                logWarnError(error);
+            }
+        }
+        // Warn if total files loaded exceeds threshold across all include paths
+        if (includePaths.length > 0 && totalFilesLoaded > 0) {
+            // Get the minimum threshold from all projects
+            const minThreshold = Math.min(...includePaths.map(p => p.includeConfig.fileThreshold));
+            if (totalFilesLoaded > minThreshold) {
+                logger.warn(`Loaded ${totalFilesLoaded} files from include paths (threshold: ${minThreshold}). ` +
+                    'Large include directories may slow workspace initialization. ' +
+                    'Consider adjusting "include.fileThreshold" or "include.maxDepth" in your project configuration.');
+            }
+            else {
+                logger.info `loaded ${totalFilesLoaded} total files from ${includePaths.length} include paths`;
+            }
+        }
         await super.loadAdditionalDocuments(folders, collector);
     }
     /**
@@ -75,6 +113,11 @@ export class LikeC4WorkspaceManager extends DefaultWorkspaceManager {
         return null;
     }
     async rebuildAll(cancelToken) {
+        if (!cancelToken) {
+            return await this.services.workspace.WorkspaceLock.write(async (ct) => {
+                await this.rebuildAll(ct);
+            });
+        }
         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();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@likec4/language-server",
   "description": "LikeC4 Language Server",
-  "version": "1.44.0",
+  "version": "1.46.0",
   "license": "MIT",
   "bugs": "https://github.com/likec4/likec4/issues",
   "homepage": "https://likec4.dev",
@@ -76,48 +76,49 @@
     "access": "public"
   },
   "dependencies": {
-    "@hpcc-js/wasm-graphviz": "1.15.0",
+    "@hpcc-js/wasm-graphviz": "1.16.0",
     "bundle-require": "^5.1.0",
-    "esbuild": "0.25.11"
+    "esbuild": "0.27.0"
   },
   "devDependencies": {
-    "@hono/node-server": "^1.19.5",
-    "@modelcontextprotocol/sdk": "^1.20.1",
+    "@hono/node-server": "^1.19.6",
+    "@modelcontextprotocol/sdk": "^1.22.0",
     "@msgpack/msgpack": "^3.1.2",
     "@smithy/util-base64": "^4.3.0",
     "@types/natural-compare-lite": "^1.4.2",
-    "@types/node": "~20.19.22",
+    "@types/node": "~22.19.1",
     "@types/picomatch": "^4.0.2",
-    "@types/vscode": "^1.84.0",
+    "@types/vscode": "^1.106.1",
     "@types/which": "^3.0.4",
     "chokidar": "^4.0.3",
     "defu": "^6.1.4",
     "esm-env": "^1.2.2",
-    "fast-equals": "^5.3.2",
+    "fast-equals": "^5.3.3",
     "fdir": "6.4.0",
     "fetch-to-node": "^2.1.0",
-    "hono": "^4.10.2",
+    "hono": "^4.10.7",
+    "immer": "^10.2.0",
     "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.28.0",
+    "oxlint": "1.31.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",
+    "pretty-ms": "^9.3.0",
     "remeda": "^2.32.0",
     "strip-indent": "^4.1.1",
-    "tsx": "4.20.6",
-    "turbo": "2.6.0",
+    "tsx": "4.21.0",
+    "turbo": "2.6.3",
     "type-fest": "^4.41.0",
     "typescript": "5.9.3",
     "ufo": "1.6.1",
     "unbuild": "3.5.0",
-    "vitest": "4.0.8",
+    "vitest": "4.0.15",
     "vscode-jsonrpc": "8.2.1",
     "vscode-languageserver": "9.0.1",
     "vscode-languageserver-protocol": "3.17.5",
@@ -125,13 +126,13 @@
     "vscode-uri": "3.1.0",
     "which": "^5.0.0",
     "zod": "^3.25.76",
-    "@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"
+    "@likec4/config": "1.46.0",
+    "@likec4/core": "1.46.0",
+    "@likec4/devops": "1.42.0",
+    "@likec4/icons": "1.46.0",
+    "@likec4/layouts": "1.46.0",
+    "@likec4/log": "1.46.0",
+    "@likec4/tsconfig": "1.46.0"
   },
   "scripts": {
     "typecheck": "tsc -b --verbose",