@likec4/language-server 1.36.1 → 1.38.0

package/dist/workspace/ProjectsManager.js

@@ -1,18 +1,33 @@
-import { BiMap, invariant, nonNullable } from "@likec4/core";
+import { BiMap, delay, invariant, memoizeProp, nonNullable } from "@likec4/core";
 import { loggable } from "@likec4/log";
-import { URI, WorkspaceCache } from "langium";
-import picomatch from "picomatch/posix";
-import { hasAtLeast, isNullish, map, pipe, prop, sortBy } from "remeda";
+import { deepEqual } from "fast-equals";
+import {
+  interruptAndCheck,
+  URI,
+  WorkspaceCache
+} from "langium";
+import PQueue from "p-queue";
+import picomatch from "picomatch";
+import { hasAtLeast, isNullish, isTruthy, map, pickBy, pipe, prop, sortBy } from "remeda";
 import {
   hasProtocol,
   joinRelativeURL,
+  normalizeURL,
   parseFilename,
   withoutProtocol,
-  withProtocol
+  withProtocol,
+  withTrailingSlash
 } from "ufo";
 import { parseConfigJson, validateConfig } from "../config/index.js";
 import { logger as mainLogger } from "../logger.js";
 const logger = mainLogger.getChild("ProjectsManager");
+export function ProjectFolder(folder) {
+  if (URI.isUri(folder)) {
+    folder = folder.toString();
+  }
+  folder = hasProtocol(folder) ? folder : withProtocol(folder, "file://");
+  return withTrailingSlash(normalizeURL(folder));
+}
 export class ProjectsManager {
   constructor(services) {
     this.services = services;
@@ -38,16 +53,19 @@ export class ProjectsManager {
    * This ensures that the most specific project is used for a document.
    */
   _projects = [];
+  excludedDocuments = /* @__PURE__ */ new WeakMap();
   defaultGlobalProject = {
     id: ProjectsManager.DefaultProjectId,
     config: {
       name: ProjectsManager.DefaultProjectId,
-      exclude: ["**/node_modules/**/*"]
+      exclude: ["**/node_modules/**"]
     },
-    exclude: picomatch("**/node_modules/**/*", {
-      dot: true
-    })
+    exclude: picomatch("**/node_modules/**", { dot: true })
   };
+  reloadProjectsLimiter = new PQueue({
+    concurrency: 1,
+    timeout: 2e4
+  });
   /**
    * Returns:
    *  - the default project ID if there are no projects.
@@ -72,32 +90,32 @@ export class ProjectsManager {
   getProject(arg) {
     const id = typeof arg === "string" ? arg : arg.likec4ProjectId || this.belongsTo(arg);
     if (id === ProjectsManager.DefaultProjectId) {
-      let folder2;
+      let folderUri2;
       try {
-        folder2 = this.services.workspace.WorkspaceManager.workspaceUri;
+        folderUri2 = this.services.workspace.WorkspaceManager.workspaceUri;
       } catch (error) {
         logger.warn("Failed to get workspace URI, using default folder", { error });
-        folder2 = URI.file("");
+        folderUri2 = URI.file("");
       }
       return {
         id: ProjectsManager.DefaultProjectId,
         config: this.defaultGlobalProject.config,
-        folder: folder2
+        folderUri: folderUri2
       };
     }
     const {
       config,
-      folder
+      folderUri
     } = nonNullable(this._projects.find((p) => p.id === id), `Project "${id}" not found`);
     return {
       id,
-      folder: URI.parse(folder),
+      folderUri,
       config
     };
   }
   ensureProjectId(projectId) {
     if (projectId === ProjectsManager.DefaultProjectId) {
-      return projectId;
+      return this.defaultProjectId ?? ProjectsManager.DefaultProjectId;
     }
     if (projectId) {
       invariant(this.projectIdToFolder.has(projectId), `Project ID ${projectId} is not registered`);
@@ -111,14 +129,34 @@ export class ProjectsManager {
   hasMultipleProjects() {
     return this._projects.length > 1;
   }
-  checkIfExcluded(documentUri) {
-    let docUriAsString = documentUri.toString();
-    const project = this.findProjectForDocument(docUriAsString);
-    return project.exclude ? project.exclude(withoutProtocol(docUriAsString)) : false;
+  checkIfExcluded(document) {
+    if (typeof document === "string" || URI.isUri(document)) {
+      let docUriAsString = typeof document === "string" ? document : document.toString();
+      const project = this.findProjectForDocument(docUriAsString);
+      return project.exclude ? project.exclude(withoutProtocol(docUriAsString)) : false;
+    }
+    let isExcluded = this.excludedDocuments.get(document);
+    if (isExcluded === void 0) {
+      isExcluded = this.checkIfExcluded(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.uri.toString(), { strict: false })?.toLowerCase();
-    return !!filename && ProjectsManager.ConfigFileNames.includes(filename);
+    const filename = parseFilename(entry.toString(), { strict: false })?.toLowerCase();
+    const isConfigFile = !!filename && ProjectsManager.ConfigFileNames.includes(filename);
+    if (isConfigFile) {
+      if (this.defaultGlobalProject.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.
@@ -129,7 +167,7 @@ export class ProjectsManager {
     if (entry.isDirectory) {
       return void 0;
     }
-    if (this.isConfigFile(entry)) {
+    if (this.isConfigFile(entry.uri)) {
       try {
         return await this.registerProject(entry.uri);
       } catch (error) {
@@ -151,42 +189,58 @@ ${loggable(error)}`
       const config2 = parseConfigJson(cfg);
       const path = joinRelativeURL(configFile.path, "..");
       const folderUri2 = configFile.with({ path });
-      return this.registerProject({ config: config2, folderUri: folderUri2 });
+      return await this.registerProject({ config: config2, folderUri: folderUri2 });
     }
-    const config = validateConfig(opts.config);
+    const config = pickBy(validateConfig(opts.config), isTruthy);
     const { folderUri } = opts;
-    let id = config.name;
-    let i = 1;
-    while (this.projectIdToFolder.has(id)) {
-      id = `${config.name}-${i++}`;
+    const folder = ProjectFolder(folderUri);
+    let project = this._projects.find((p) => p.folder === folder);
+    if (project && deepEqual(project.config, config)) {
+      return project;
     }
-    let folder;
-    if (URI.isUri(folderUri)) {
-      folder = folderUri.toString();
+    let mustReset = !!project && !deepEqual(project.config, config);
+    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)
+      };
+      mustReset = this._projects.some((p) => p.folder.startsWith(folder) || folder.startsWith(p.folder));
+      this._projects = pipe(
+        [...this._projects, project],
+        sortBy(
+          [({ folder: folder2 }) => withoutProtocol(folder2).split("/").length, "desc"]
+        )
+      );
+      logger.info`register project ${project.id} folder: ${folder}`;
     } else {
-      folder = hasProtocol(folderUri) ? folderUri : withProtocol(folderUri, "file://");
+      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;
     }
-    const project = {
-      id,
-      config,
-      folder
-    };
     if (isNullish(config.exclude)) {
       project.exclude = this.defaultGlobalProject.exclude;
     } else if (hasAtLeast(config.exclude, 1)) {
-      project.exclude = picomatch(config.exclude, {
-        dot: true
-      });
-    }
-    this._projects = pipe(
-      [...this._projects, project],
-      sortBy(
-        [({ folder: folder2 }) => withoutProtocol(folder2).split("/").length, "desc"]
-      )
-    );
-    this.projectIdToFolder.set(id, folder);
-    logger.info`register project ${id} folder: ${folder}`;
-    this.mappingsToProject.clear();
+      project.exclude = picomatch(config.exclude, { dot: true });
+    }
+    this.projectIdToFolder.set(project.id, folder);
+    if (mustReset) {
+      this.resetProjectIds();
+    }
     return project;
   }
   belongsTo(document) {
@@ -200,6 +254,68 @@ ${loggable(error)}`
     }
     return this.findProjectForDocument(documentUri).id;
   }
+  async reloadProjects(token) {
+    const folders = this.services.workspace.WorkspaceManager.workspaceFolders;
+    if (!folders) {
+      logger.warn("No workspace folders found");
+      return;
+    }
+    if (this.reloadProjectsLimiter.size + this.reloadProjectsLimiter.pending > 0) {
+      logger.debug`reload projects is already queued`;
+      return;
+    }
+    this.reloadProjectsLimiter.add(async () => {
+      await delay(100);
+    });
+    this.reloadProjectsLimiter.add(async () => {
+      if (token) {
+        await interruptAndCheck(token);
+      }
+      logger.debug`reload projects`;
+      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 load config file", { error });
+        }
+      }
+      if (configFiles.length === 0 && this._projects.length !== 0) {
+        logger.warning("No config files found, but some projects were registered before");
+      }
+      this._projects = [];
+      this.projectIdToFolder.clear();
+      for (const entry of configFiles) {
+        try {
+          await this.registerProject(entry.uri);
+        } catch (error) {
+          logger.error("Failed to load config file", { error });
+        }
+      }
+      this.resetProjectIds();
+      const docs = this.services.workspace.LangiumDocuments.all.map((d) => d.uri).toArray();
+      logger.info("invalidate and rebuild documents {docs}", { docs: docs.length });
+      await this.services.workspace.DocumentBuilder.update(docs, []);
+    });
+  }
+  uniqueProjectId(name) {
+    let id = name;
+    let i = 1;
+    while (this.projectIdToFolder.has(id)) {
+      id = `${name}-${i++}`;
+    }
+    return id;
+  }
+  resetProjectIds() {
+    this.mappingsToProject.clear();
+    this.excludedDocuments = /* @__PURE__ */ new WeakMap();
+    this.services.workspace.LangiumDocuments.resetProjectIds();
+  }
   findProjectForDocument(documentUri) {
     return this.mappingsToProject.get(documentUri, () => {
       const project = this._projects.find(({ folder }) => documentUri.startsWith(folder));
@@ -208,9 +324,7 @@ ${loggable(error)}`
   }
   // The mapping between document URIs and their corresponding project ID
   // Lazy-created due to initialization order of the LanguageServer
-  _mappingsToProject;
   get mappingsToProject() {
-    this._mappingsToProject ??= new WorkspaceCache(this.services);
-    return this._mappingsToProject;
+    return memoizeProp(this, "_mappingsToProject", () => new WorkspaceCache(this.services));
   }
 }

package/dist/workspace/WorkspaceManager.d.ts

@@ -1,12 +1,19 @@
-import type { FileSelector, FileSystemNode, LangiumDocument } from 'langium';
+import type { BuildOptions, FileSelector, FileSystemNode, LangiumDocument, LangiumDocumentFactory } from 'langium';
 import { DefaultWorkspaceManager } from 'langium';
 import type { WorkspaceFolder } from 'vscode-languageserver';
 import { URI } from 'vscode-uri';
+import type { FileSystemProvider } from '../filesystem';
 import type { LikeC4SharedServices } from '../module';
 export declare class LikeC4WorkspaceManager extends DefaultWorkspaceManager {
     private services;
-    private documentFactory;
+    protected readonly documentFactory: LangiumDocumentFactory;
+    protected readonly fileSystemProvider: FileSystemProvider;
+    initialBuildOptions: BuildOptions;
     constructor(services: LikeC4SharedServices);
+    /**
+     * First load all project config files, then load all documents in the workspace.
+     */
+    protected performStartup(folders: WorkspaceFolder[]): Promise<LangiumDocument[]>;
     /**
      * 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

package/dist/workspace/WorkspaceManager.js

@@ -8,63 +8,54 @@ export class LikeC4WorkspaceManager extends DefaultWorkspaceManager {
     super(services);
     this.services = services;
     this.documentFactory = services.workspace.LangiumDocumentFactory;
+    this.fileSystemProvider = services.workspace.FileSystemProvider;
   }
   documentFactory;
+  fileSystemProvider;
+  initialBuildOptions = {
+    eagerLinking: true,
+    validation: true
+  };
   /**
-   * 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.
+   * First load all project config files, then load all documents in the workspace.
    */
-  async loadAdditionalDocuments(folders, collector) {
-    const projects = this.services.workspace.ProjectsManager;
+  async performStartup(folders) {
+    this.folders ??= folders;
+    const configFiles = [];
     for (const folder of folders) {
       try {
-        const content = await this.fileSystemProvider.readDirectory(URI.parse(folder.uri));
-        for (const entry of content) {
-          try {
-            await projects.loadConfigFile(entry);
-          } catch (error) {
-            logError(error);
-          }
-        }
+        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) {
+        logError(error);
+      }
+    }
+    const projects = this.services.workspace.ProjectsManager;
+    for (const entry of configFiles) {
+      try {
+        await projects.loadConfigFile(entry);
       } catch (error) {
         logError(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);
   }
-  // /**
-  //  * We override the default implementation to process project config files during the traversal.
-  //  * This is necessary to ensure that the project config files are loaded and processed correctly.
-  //  */
-  // protected override async traverseFolder(
-  //   workspaceFolder: WorkspaceFolder,
-  //   folderPath: URI,
-  //   fileExtensions: string[],
-  //   collector: (document: LangiumDocument) => void,
-  // ): Promise<void> {
-  //   // Then load other files
-  //   for (const entry of nonConfigFiles) {
-  //     try {
-  //       if (this.includeEntry(workspaceFolder, entry, fileExtensions)) {
-  //         if (entry.isDirectory) {
-  //           await this.traverseFolder(workspaceFolder, entry.uri, fileExtensions, collector)
-  //         } else if (entry.isFile) {
-  //           const document = await this.langiumDocuments.getOrCreateDocument(entry.uri)
-  //           collector(document)
-  //         }
-  //       }
-  //     } catch (error) {
-  //       logError(error)
-  //     }
-  //   }
-  // }
   /**
    * Determine whether the given folder entry shall be included while indexing the workspace.
    */
   includeEntry(_workspaceFolder, entry, selector) {
-    if (this.services.workspace.ProjectsManager.isConfigFile(entry)) {
+    if (this.services.workspace.ProjectsManager.isConfigFile(entry.uri)) {
       return false;
     }
     if (entry.isFile) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@likec4/language-server",
   "description": "LikeC4 Language Server",
-  "version": "1.36.1",
+  "version": "1.38.0",
   "license": "MIT",
   "bugs": "https://github.com/likec4/likec4/issues",
   "homepage": "https://likec4.dev",
@@ -89,21 +89,24 @@
     "access": "public"
   },
   "dependencies": {
-    "@hpcc-js/wasm-graphviz": "1.10.0"
+    "@hpcc-js/wasm-graphviz": "1.11.0"
   },
   "devDependencies": {
     "@types/chroma-js": "^3.1.1",
     "@types/natural-compare-lite": "^1.4.2",
-    "@modelcontextprotocol/sdk": "^1.13.2",
+    "@types/vscode": "^1.84.0",
+    "@modelcontextprotocol/sdk": "^1.17.2",
     "@msgpack/msgpack": "^3.1.2",
     "@smithy/util-base64": "^4.0.0",
-    "@types/express": "^5.0.3",
+    "@hono/node-server": "^1.14.4",
     "@types/node": "~20.19.2",
     "@types/picomatch": "^4.0.2",
     "@types/which": "^3.0.4",
+    "chokidar": "^4.0.3",
     "chroma-js": "^3.1.2",
+    "defu": "^6.1.4",
     "esm-env": "^1.2.2",
-    "express": "^5.1.0",
+    "hono": "^4.9.0",
     "fast-equals": "^5.2.2",
     "fdir": "6.4.6",
     "indent-string": "^5.0.0",
@@ -116,6 +119,7 @@
     "p-timeout": "6.1.4",
     "picomatch": "^4.0.3",
     "pretty-ms": "^9.2.0",
+    "fetch-to-node": "^2.1.0",
     "remeda": "^2.23.1",
     "strip-indent": "^4.0.0",
     "tsx": "4.20.3",
@@ -133,11 +137,11 @@
     "vscode-uri": "3.1.0",
     "which": "^5.0.0",
     "zod": "3.25.67",
-    "@likec4/layouts": "1.36.1",
-    "@likec4/core": "1.36.1",
-    "@likec4/icons": "1.36.1",
-    "@likec4/log": "1.36.1",
-    "@likec4/tsconfig": "1.36.1"
+    "@likec4/log": "1.38.0",
+    "@likec4/icons": "1.38.0",
+    "@likec4/core": "1.38.0",
+    "@likec4/tsconfig": "1.38.0",
+    "@likec4/layouts": "1.38.0"
   },
   "scripts": {
     "typecheck": "tsc -b --verbose",

package/dist/LikeC4FileSystem.d.ts

@@ -1,14 +0,0 @@
-import { type FileSystemNode, URI } from 'langium';
-import { NodeFileSystemProvider } from 'langium/node';
-export declare const LikeC4FileSystem: {
-    fileSystemProvider: () => SymLinkTraversingFileSystemProvider;
-};
-/**
- * A file system provider that follows symbolic links.
- * @see https://github.com/likec4/likec4/pull/1213
- */
-declare class SymLinkTraversingFileSystemProvider extends NodeFileSystemProvider {
-    readFile(uri: URI): Promise<string>;
-    readDirectory(folderPath: URI): Promise<FileSystemNode[]>;
-}
-export {};

package/dist/LikeC4FileSystem.js

@@ -1,39 +0,0 @@
-import { fdir } from "fdir";
-import { URI } from "langium";
-import { NodeFileSystemProvider } from "langium/node";
-import { LikeC4LanguageMetaData } from "./generated/module.js";
-import { Content, isLikeC4Builtin } from "./likec4lib.js";
-import { logError } from "./logger.js";
-import { ProjectsManager } from "./workspace/ProjectsManager.js";
-export const LikeC4FileSystem = {
-  fileSystemProvider: () => new SymLinkTraversingFileSystemProvider()
-};
-const SearchExtension = [
-  ...LikeC4LanguageMetaData.fileExtensions,
-  ...ProjectsManager.ConfigFileNames
-];
-const hasExtension = (path) => SearchExtension.some((ext) => path.endsWith(ext));
-class SymLinkTraversingFileSystemProvider extends NodeFileSystemProvider {
-  async readFile(uri) {
-    if (isLikeC4Builtin(uri)) {
-      return Promise.resolve(Content);
-    }
-    return await super.readFile(uri);
-  }
-  async readDirectory(folderPath) {
-    const entries = [];
-    try {
-      const crawled = await new fdir().withSymlinks({ resolvePaths: false }).withFullPaths().filter(hasExtension).crawl(folderPath.fsPath).withPromise();
-      for (const path of crawled) {
-        entries.push({
-          isFile: true,
-          isDirectory: false,
-          uri: URI.file(path)
-        });
-      }
-    } catch (error) {
-      logError(error);
-    }
-    return entries;
-  }
-}

package/dist/mcp/sseserver/MCPServer.js

@@ -1,80 +0,0 @@
-import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
-import express from "express";
-import { logger } from "../utils.js";
-export class SSELikeC4MCPServer {
-  constructor(services) {
-    this.services = services;
-  }
-  // Store transports by session ID to send notifications
-  transports = {};
-  server = void 0;
-  _port = 33335;
-  get isStarted() {
-    return this.server?.listening === true;
-  }
-  get port() {
-    return this._port;
-  }
-  async dispose() {
-    await this.stop();
-  }
-  async start(port = 33335) {
-    if (this.server) {
-      if (this.port === port) {
-        return;
-      }
-      await this.stop();
-    }
-    logger.info("Starting MCP server on port {port}", { port });
-    this._port = port;
-    const mcp = this.services.mcp.ServerFactory.create();
-    const app = express();
-    app.get("/sse", async (_, res) => {
-      const transport = new SSEServerTransport("/messages", res);
-      this.transports[transport.sessionId] = transport;
-      logger.debug`SSE connection established, sessionId: ${transport.sessionId}`;
-      res.on("close", () => {
-        delete this.transports[transport.sessionId];
-      });
-      await mcp.connect(transport);
-    });
-    app.post("/messages", async (req, res) => {
-      const sessionId = req.query["sessionId"];
-      const transport = this.transports[sessionId];
-      if (transport) {
-        logger.debug`SSE message received, sessionId: ${sessionId}`;
-        await transport.handlePostMessage(req, res);
-      } else {
-        res.status(400).send("No transport found for sessionId");
-      }
-    });
-    return new Promise((resolve, reject) => {
-      this.server = app.listen(this._port, (err) => {
-        if (err) {
-          reject(err);
-          return;
-        }
-        logger.info("MCP server listening on port {port}", { port: this._port });
-        resolve();
-      });
-    });
-  }
-  async stop() {
-    this.transports = {};
-    const server = this.server;
-    if (!server) {
-      return;
-    }
-    logger.info("Stopping MCP server");
-    this.server = void 0;
-    return new Promise((resolve) => {
-      server.close((err) => {
-        if (err) {
-          logger.error("Failed to stop MCP server", { err });
-        }
-        logger.info("MCP server stopped");
-        resolve();
-      });
-    });
-  }
-}