@likec4/language-server 1.45.0 → 1.46.2

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/lib/package.json

@@ -0,0 +1,159 @@
+{
+    "name": "@likec4/language-server",
+    "description": "LikeC4 Language Server",
+    "version": "1.45.0",
+    "license": "MIT",
+    "bugs": "https://github.com/likec4/likec4/issues",
+    "homepage": "https://likec4.dev",
+    "author": "Denis Davydkov <denis@davydkov.com>",
+    "files": [
+        "bin",
+        "dist",
+        "**/package.json",
+        "!**/__mocks__/",
+        "!**/__tests__/",
+        "!**/*.spec.*",
+        "!**/*.map"
+    ],
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/likec4/likec4.git",
+        "directory": "packages/language-server"
+    },
+    "engines": {
+        "node": "^20.19.0 || >=22.18.0"
+    },
+    "engineStrict": true,
+    "type": "module",
+    "sideEffects": false,
+    "bin": {
+        "likec4-language-server": "./bin/likec4-language-server.mjs"
+    },
+    "exports": {
+        ".": {
+            "sources": "./src/index.ts",
+            "default": {
+                "types": "./dist/index.d.ts",
+                "default": "./dist/index.js"
+            }
+        },
+        "./likec4lib": {
+            "sources": "./src/likec4lib.ts",
+            "default": {
+                "types": "./dist/likec4lib.d.ts",
+                "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.js",
+                "default": "./dist/browser-worker.js"
+            }
+        },
+        "./browser": {
+            "sources": "./src/browser.ts",
+            "default": {
+                "types": "./dist/browser.d.ts",
+                "import": "./dist/browser.js",
+                "default": "./dist/browser.js"
+            }
+        },
+        "./protocol": {
+            "sources": "./src/protocol.ts",
+            "default": {
+                "types": "./dist/protocol.d.ts",
+                "import": "./dist/protocol.js",
+                "default": "./dist/protocol.js"
+            }
+        },
+        "./bundled": "./dist/bundled.mjs"
+    },
+    "publishConfig": {
+        "registry": "https://registry.npmjs.org",
+        "access": "public",
+        "types": "dist/index.d.ts",
+        "module": "dist/index.js"
+    },
+    "scripts": {
+        "typecheck": "tsc -b --verbose",
+        "build": "unbuild",
+        "prepack": "likec4ops prepack",
+        "pack": "pnpm pack",
+        "postpack": "cp likec4-language-server-$npm_package_version.tgz package.tgz || true",
+        "pregenerate": "rm -f src/generated/* || true",
+        "watch:langium": "langium generate --watch",
+        "watch:ts": "tsc --watch",
+        "generate": "langium generate && tsx scripts/generate-icons.ts",
+        "dev": "run-p \"watch:*\"",
+        "lint": "oxlint --type-aware",
+        "lint:fix": "oxlint --type-aware --fix",
+        "lint:package": "pnpx publint ./package.tgz",
+        "clean": "likec4ops clean contrib src/generated src/generated-lib",
+        "test": "vitest run --no-isolate",
+        "test-dbg": "vitest run --no-isolate -t formating",
+        "vitest:ui": "vitest --no-isolate --ui",
+        "test:watch": "vitest"
+    },
+    "dependencies": {
+        "@hpcc-js/wasm-graphviz": "catalog:utils",
+        "bundle-require": "catalog:utils",
+        "esbuild": "catalog:esbuild"
+    },
+    "devDependencies": {
+        "@hono/node-server": "catalog:hono",
+        "@likec4/config": "workspace:*",
+        "@likec4/core": "workspace:*",
+        "@likec4/devops": "workspace:*",
+        "@likec4/icons": "workspace:*",
+        "@likec4/layouts": "workspace:*",
+        "@likec4/log": "workspace:*",
+        "@likec4/tsconfig": "workspace:*",
+        "@modelcontextprotocol/sdk": "catalog:mcp",
+        "@msgpack/msgpack": "^3.1.2",
+        "@smithy/util-base64": "^4.3.0",
+        "@types/natural-compare-lite": "catalog:utils",
+        "@types/node": "catalog:",
+        "@types/picomatch": "catalog:utils",
+        "@types/vscode": "catalog:vscode",
+        "@types/which": "^3.0.4",
+        "chokidar": "catalog:utils",
+        "defu": "catalog:utils",
+        "esm-env": "catalog:utils",
+        "fast-equals": "catalog:utils",
+        "fdir": "catalog:utils",
+        "fetch-to-node": "^2.1.0",
+        "hono": "catalog:hono",
+        "immer": "catalog:utils",
+        "indent-string": "^5.0.0",
+        "json5": "catalog:utils",
+        "langium": "catalog:langium",
+        "langium-cli": "catalog:langium",
+        "nano-spawn": "catalog:utils",
+        "natural-compare-lite": "catalog:utils",
+        "oxlint": "catalog:",
+        "p-debounce": "catalog:utils",
+        "p-queue": "catalog:utils",
+        "p-timeout": "catalog:utils",
+        "picomatch": "catalog:utils",
+        "pretty-ms": "^9.2.0",
+        "remeda": "catalog:utils",
+        "strip-indent": "catalog:utils",
+        "tsx": "catalog:",
+        "turbo": "catalog:",
+        "type-fest": "catalog:utils",
+        "typescript": "catalog:",
+        "ufo": "catalog:utils",
+        "unbuild": "catalog:",
+        "vitest": "catalog:vitest",
+        "vscode-jsonrpc": "catalog:vscode",
+        "vscode-languageserver": "catalog:vscode",
+        "vscode-languageserver-protocol": "catalog:vscode",
+        "vscode-languageserver-types": "catalog:vscode",
+        "vscode-uri": "catalog:vscode",
+        "which": "^5.0.0",
+        "zod": "catalog:utils"
+    }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@likec4/language-server",
   "description": "LikeC4 Language Server",
-  "version": "1.45.0",
+  "version": "1.46.2",
   "license": "MIT",
   "bugs": "https://github.com/likec4/likec4/issues",
   "homepage": "https://likec4.dev",
@@ -21,7 +21,7 @@
     "directory": "packages/language-server"
   },
   "engines": {
-    "node": "^20.19.0 || >=22.18.0"
+    "node": ">=22.21.1"
   },
   "engineStrict": true,
   "type": "module",
@@ -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"
+    "esbuild": "0.27.1"
   },
   "devDependencies": {
-    "@hono/node-server": "^1.19.6",
-    "@modelcontextprotocol/sdk": "^1.20.1",
+    "@hono/node-server": "^1.19.7",
+    "@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,29 +96,29 @@
     "fast-equals": "^5.3.3",
     "fdir": "6.4.0",
     "fetch-to-node": "^2.1.0",
-    "hono": "^4.10.6",
-    "immer": "^10.2.0",
+    "hono": "^4.11.1",
+    "immer": "^11.0.1",
     "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.29.0",
+    "oxlint": "1.33.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.16",
     "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/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/config": "1.46.2",
+    "@likec4/layouts": "1.46.2",
+    "@likec4/log": "1.46.1",
+    "@likec4/icons": "1.46.1",
+    "@likec4/core": "1.46.2",
+    "@likec4/tsconfig": "1.46.1",
+    "@likec4/devops": "1.42.0"
   },
   "scripts": {
     "typecheck": "tsc -b --verbose",