@likec4/language-server 1.45.0 → 1.46.0

package/dist/workspace/ProjectsManager.js

@@ -1,4 +1,4 @@
-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';
@@ -32,6 +32,7 @@ const DefaultProject = {
         exclude: ['**/node_modules/**'],
     },
     exclude: picomatch('**/node_modules/**', { dot: true }),
+    includeConfig: { paths: [], maxDepth: 3, fileThreshold: 30 },
 };
 export class ProjectsManager {
     services;
@@ -106,6 +107,7 @@ export class ProjectsManager {
                     folder: ProjectFolder(folderUri),
                     folderUri,
                     exclude: DefaultProject.exclude,
+                    includeConfig: DefaultProject.includeConfig,
                 };
             }
             this.#defaultProject = project;
@@ -148,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) }),
         };
     }
     /**
@@ -251,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
@@ -278,6 +283,8 @@ 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;
@@ -287,6 +294,48 @@ export class ProjectsManager {
         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);
         // Reset assigned project IDs if no projects reload is active
         if (mustReset && !this.#activeReload) {
@@ -402,36 +451,43 @@ export class ProjectsManager {
                 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;
             }
-            if (doc.uri.toString().startsWith(folder)) {
+            const docUriStr = doc.uri.toString();
+            if (docUriStr.startsWith(folder)) {
                 return true;
             }
-            const docdir = withTrailingSlash(joinRelativeURL(doc.uri.toString(), '..'));
+            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();
-            const projectId = project.id;
-            logger.info('rebuild documents of project {projectId}: {docs}', {
-                projectId,
+            log.info('rebuild documents: {docs}', {
                 docs: docs.length,
             });
             await this.services.workspace.DocumentBuilder
                 .update(docs, [], cancelToken)
                 .catch(error => {
-                logger.warn('Failed to rebuild project {projectId}', {
-                    projectId,
+                log.warn('Failed to rebuild project', {
                     error,
                 });
             });
@@ -440,8 +496,19 @@ export class ProjectsManager {
     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 ?? this.default;
+            return this.default;
         });
     }
     // The mapping between document URIs and their corresponding project ID
@@ -456,6 +523,25 @@ export class ProjectsManager {
     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;

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);
     }
     /**

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@likec4/language-server",
   "description": "LikeC4 Language Server",
-  "version": "1.45.0",
+  "version": "1.46.0",
   "license": "MIT",
   "bugs": "https://github.com/likec4/likec4/issues",
   "homepage": "https://likec4.dev",
@@ -76,19 +76,19 @@
     "access": "public"
   },
   "dependencies": {
-    "@hpcc-js/wasm-graphviz": "1.15.0",
+    "@hpcc-js/wasm-graphviz": "1.16.0",
     "bundle-require": "^5.1.0",
     "esbuild": "0.27.0"
   },
   "devDependencies": {
     "@hono/node-server": "^1.19.6",
-    "@modelcontextprotocol/sdk": "^1.20.1",
+    "@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",
@@ -96,7 +96,7 @@
     "fast-equals": "^5.3.3",
     "fdir": "6.4.0",
     "fetch-to-node": "^2.1.0",
-    "hono": "^4.10.6",
+    "hono": "^4.10.7",
     "immer": "^10.2.0",
     "indent-string": "^5.0.0",
     "json5": "^2.2.3",
@@ -104,21 +104,21 @@
     "langium-cli": "3.5.2",
     "nano-spawn": "^1.0.3",
     "natural-compare-lite": "^1.4.0",
-    "oxlint": "1.29.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.1",
+    "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.13",
+    "vitest": "4.0.15",
     "vscode-jsonrpc": "8.2.1",
     "vscode-languageserver": "9.0.1",
     "vscode-languageserver-protocol": "3.17.5",
@@ -126,13 +126,13 @@
     "vscode-uri": "3.1.0",
     "which": "^5.0.0",
     "zod": "^3.25.76",
-    "@likec4/config": "1.45.0",
-    "@likec4/core": "1.45.0",
+    "@likec4/config": "1.46.0",
+    "@likec4/core": "1.46.0",
     "@likec4/devops": "1.42.0",
-    "@likec4/icons": "1.45.0",
-    "@likec4/layouts": "1.45.0",
-    "@likec4/log": "1.45.0",
-    "@likec4/tsconfig": "1.45.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",