@likec4/language-server 1.37.0 → 1.38.1

package/dist/module.js

@@ -1,7 +1,6 @@
 import { GraphvizWasmAdapter, QueueGraphvizLayoter } from "@likec4/layouts";
 import {
   DocumentState,
-  EmptyFileSystem,
   inject,
   WorkspaceCache
 } from "langium";
@@ -10,6 +9,9 @@ import {
   createDefaultSharedModule
 } from "langium/lsp";
 import { LikeC4DocumentationProvider } from "./documentation/index.js";
+import {
+  NoopFileSystem
+} from "./filesystem/index.js";
 import { LikeC4Formatter } from "./formatting/LikeC4Formatter.js";
 import {
   LikeC4GeneratedModule,
@@ -25,7 +27,10 @@ import {
   LikeC4HoverProvider,
   LikeC4SemanticTokenProvider
 } from "./lsp/index.js";
-import { NoopLikeC4MCPServer, NoopLikeC4MCPServerFactory } from "./mcp/NoopLikeC4MCPServer.js";
+import {
+  NoMCPServer
+} from "./mcp/interfaces.js";
+import { LikeC4MCPServerFactory } from "./mcp/MCPServerFactory.js";
 import {
   DefaultLikeC4ModelBuilder,
   DeploymentsIndex,
@@ -54,7 +59,7 @@ import {
   LikeC4WorkspaceManager,
   ProjectsManager
 } from "./workspace/index.js";
-const LikeC4SharedModule = {
+const createLikeC4SharedModule = (context) => ({
   lsp: {
     NodeKindProvider: (services) => new NodeKindProvider(services),
     WorkspaceSymbolProvider: (services) => new WorkspaceSymbolProvider(services)
@@ -63,13 +68,15 @@ const LikeC4SharedModule = {
     IndexManager: (services) => new IndexManager(services),
     LangiumDocuments: (services) => new LangiumDocuments(services),
     ProjectsManager: (services) => new ProjectsManager(services),
-    WorkspaceManager: (services) => new LikeC4WorkspaceManager(services)
+    WorkspaceManager: (services) => new LikeC4WorkspaceManager(services),
+    FileSystemProvider: (services) => context.fileSystemProvider(services),
+    FileSystemWatcher: (services) => context.fileSystemWatcher(services)
   }
-};
+});
 function bind(Type) {
   return (services) => new Type(services);
 }
-export const LikeC4Module = {
+export const createLikeC4Module = (context) => ({
   documentation: {
     DocumentationProvider: bind(LikeC4DocumentationProvider)
   },
@@ -79,8 +86,8 @@ export const LikeC4Module = {
   ValidatedWorkspaceCache: (services) => new WorkspaceCache(services.shared, DocumentState.Validated),
   Rpc: bind(Rpc),
   mcp: {
-    Server: bind(NoopLikeC4MCPServer),
-    ServerFactory: bind(NoopLikeC4MCPServerFactory)
+    Server: (services) => context.mcpServer(services),
+    ServerFactory: bind(LikeC4MCPServerFactory)
   },
   likec4: {
     LanguageServices: bind(DefaultLikeC4LanguageServices),
@@ -119,13 +126,16 @@ export const LikeC4Module = {
   parser: {
     ValueConverter: bind(LikeC4ValueConverter)
   }
-};
-export function createCustomLanguageServices(context, module, module2, module3) {
+});
+export function createLanguageServices(context, module, module2, module3) {
   const shared = createSharedServices(context);
   const modules = [
     createDefaultModule({ shared }),
     LikeC4GeneratedModule,
-    LikeC4Module,
+    createLikeC4Module({
+      ...NoMCPServer,
+      ...context
+    }),
     module,
     module2,
     module3
@@ -142,30 +152,15 @@ export function createCustomLanguageServices(context, module, module2, module3)
 }
 export function createSharedServices(context = {}) {
   const moduleContext = {
-    ...EmptyFileSystem,
+    ...NoMCPServer,
+    ...NoopFileSystem,
     ...context
   };
   return inject(
     createDefaultSharedModule(moduleContext),
     LikeC4GeneratedSharedModule,
-    LikeC4SharedModule
-  );
-}
-export function createLanguageServices(context = {}) {
-  const shared = createSharedServices(context);
-  const likec4 = inject(
-    createDefaultModule({ shared }),
-    LikeC4GeneratedModule,
-    LikeC4Module
+    createLikeC4SharedModule(moduleContext)
   );
-  shared.ServiceRegistry.register(likec4);
-  registerValidationChecks(likec4);
-  if (!context.connection) {
-    shared.workspace.ConfigurationProvider.initialized({});
-  } else {
-    likec4.Rpc.init();
-  }
-  return { shared, likec4 };
 }
 function _merge(target, source) {
   if (source) {

package/dist/protocol.d.ts

@@ -1,5 +1,5 @@
 import type { ComputedLikeC4ModelData, ComputedView, DeploymentFqn, DiagramView, Fqn, LayoutedLikeC4ModelData, NonEmptyArray, ProjectId, RelationId, ViewChange, ViewId } from '@likec4/core';
-import { NotificationType, RequestType, RequestType0 } from 'vscode-languageserver-protocol';
+import { NotificationType, RequestType, RequestType0 } from 'vscode-jsonrpc';
 import type { DiagnosticSeverity, DocumentUri, Location, Position, Range, URI } from 'vscode-languageserver-types';
 import type { ProjectConfig } from './config';
 export declare namespace DidChangeModelNotification {

package/dist/protocol.js

@@ -1,4 +1,4 @@
-import { NotificationType, RequestType, RequestType0 } from "vscode-languageserver-protocol";
+import { NotificationType, RequestType, RequestType0 } from "vscode-jsonrpc";
 export var DidChangeModelNotification;
 ((DidChangeModelNotification2) => {
   DidChangeModelNotification2.type = new NotificationType("likec4/onDidChangeModel");

package/dist/test/testServices.js

@@ -1,12 +1,13 @@
-import { DocumentState, EmptyFileSystem, TextDocument, UriUtils } from "langium";
+import { DocumentState, TextDocument, UriUtils } from "langium";
 import * as assert from "node:assert";
 import { entries } from "remeda";
 import stripIndent from "strip-indent";
 import { DiagnosticSeverity } from "vscode-languageserver-types";
 import { URI, Utils } from "vscode-uri";
+import { NoopFileSystem } from "../filesystem/index.js";
 import { createLanguageServices } from "../module.js";
 export function createTestServices(workspace = "file:///test/workspace") {
-  const services = createLanguageServices(EmptyFileSystem).likec4;
+  const services = createLanguageServices(NoopFileSystem).likec4;
   const metaData = services.LanguageMetaData;
   const langiumDocuments = services.shared.workspace.LangiumDocuments;
   const documentBuilder = services.shared.workspace.DocumentBuilder;

package/dist/workspace/LangiumDocuments.d.ts

@@ -1,10 +1,13 @@
 import type { NonEmptyArray, ProjectId } from '@likec4/core';
-import { type Stream, DefaultLangiumDocuments } from 'langium';
+import type { LangiumDocument, Stream } from 'langium';
+import { DefaultLangiumDocuments } from 'langium';
 import { type LikeC4LangiumDocument } from '../ast';
 import type { LikeC4SharedServices } from '../module';
 export declare class LangiumDocuments extends DefaultLangiumDocuments {
     protected services: LikeC4SharedServices;
+    protected compare: any;
     constructor(services: LikeC4SharedServices);
+    addDocument(document: LangiumDocument): void;
     /**
      * Returns all user documents, excluding built-in documents.
      */

package/dist/workspace/LangiumDocuments.js

@@ -1,12 +1,27 @@
+import { compareNaturalHierarchically } from "@likec4/core/utils";
 import { DefaultLangiumDocuments } from "langium";
 import { groupBy, prop } from "remeda";
 import { isLikeC4LangiumDocument } from "../ast.js";
 import { isLikeC4Builtin } from "../likec4lib.js";
+const compare = compareNaturalHierarchically("/", true);
+const ensureOrder = (a, b) => compare(a.uri.path, b.uri.path);
 export class LangiumDocuments extends DefaultLangiumDocuments {
   constructor(services) {
     super(services);
     this.services = services;
   }
+  compare = compareNaturalHierarchically("/", true);
+  addDocument(document) {
+    const uriString = document.uri.toString();
+    if (this.documentMap.has(uriString)) {
+      throw new Error(`A document with the URI '${uriString}' is already present.`);
+    }
+    const docs = [...this.documentMap.values(), document].sort(ensureOrder);
+    this.documentMap.clear();
+    for (const doc of docs) {
+      this.documentMap.set(doc.uri.toString(), doc);
+    }
+  }
   /**
    * Returns all user documents, excluding built-in documents.
    */

package/dist/workspace/ProjectsManager.d.ts

@@ -5,7 +5,7 @@ import type { Tagged } from 'type-fest';
 import { ProjectConfig } from '../config';
 import type { LikeC4SharedServices } from '../module';
 /**
- * A tagged string that represents a project folder.
+ * A tagged string that represents a project folder URI
  * Always has trailing slash.
  */
 export type ProjectFolder = Tagged<string, 'ProjectFolder'>;

package/dist/workspace/ProjectsManager.js

@@ -10,23 +10,26 @@ 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,
   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();
+function normalizeUri(uri) {
+  if (URI.isUri(uri)) {
+    return uri.toString();
+  } else if (typeof uri === "string") {
+    return uri.startsWith("file://") ? uri : URI.file(uri).toString();
+  } else {
+    return uri.uri.toString();
   }
-  folder = hasProtocol(folder) ? folder : withProtocol(folder, "file://");
-  return withTrailingSlash(normalizeURL(folder));
+}
+export function ProjectFolder(folder) {
+  folder = normalizeUri(folder);
+  return withTrailingSlash(folder);
 }
 export class ProjectsManager {
   constructor(services) {
@@ -115,7 +118,7 @@ export class ProjectsManager {
   }
   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`);
@@ -131,7 +134,7 @@ export class ProjectsManager {
   }
   checkIfExcluded(document) {
     if (typeof document === "string" || URI.isUri(document)) {
-      let docUriAsString = typeof document === "string" ? document : document.toString();
+      let docUriAsString = normalizeUri(document);
       const project = this.findProjectForDocument(docUriAsString);
       return project.exclude ? project.exclude(withoutProtocol(docUriAsString)) : false;
     }
@@ -201,6 +204,9 @@ ${loggable(error)}`
     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,
@@ -241,14 +247,7 @@ ${loggable(error)}`
     return project;
   }
   belongsTo(document) {
-    let documentUri;
-    if (typeof document === "string") {
-      documentUri = hasProtocol(document) ? document : withProtocol(document, "file://");
-    } else if (URI.isUri(document)) {
-      documentUri = document.toString();
-    } else {
-      documentUri = document.uri.toString();
-    }
+    const documentUri = normalizeUri(document);
     return this.findProjectForDocument(documentUri).id;
   }
   async reloadProjects(token) {
@@ -272,7 +271,7 @@ ${loggable(error)}`
       const configFiles = [];
       for (const folder of folders) {
         try {
-          const files = await this.services.workspace.FileSystemProvider.readDirectory(URI.parse(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);

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,58 +8,49 @@ 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.
    */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@likec4/language-server",
   "description": "LikeC4 Language Server",
-  "version": "1.37.0",
+  "version": "1.38.1",
   "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,10 +119,11 @@
     "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",
-    "turbo": "2.5.5",
+    "turbo": "2.5.6",
     "type-fest": "^4.41.0",
     "typescript": "5.9.2",
     "ufo": "1.6.1",
@@ -133,17 +137,17 @@
     "vscode-uri": "3.1.0",
     "which": "^5.0.0",
     "zod": "3.25.67",
-    "@likec4/core": "1.37.0",
-    "@likec4/icons": "1.37.0",
-    "@likec4/layouts": "1.37.0",
-    "@likec4/log": "1.37.0",
-    "@likec4/tsconfig": "1.37.0"
+    "@likec4/core": "1.38.1",
+    "@likec4/layouts": "1.38.1",
+    "@likec4/tsconfig": "1.38.1",
+    "@likec4/icons": "1.38.1",
+    "@likec4/log": "1.38.1"
   },
   "scripts": {
     "typecheck": "tsc -b --verbose",
     "build": "unbuild",
     "pack": "pnpm pack",
-    "pregenerate": "rm -f src/generated/*",
+    "pregenerate": "rm -f src/generated/* || true",
     "watch:langium": "langium generate --watch",
     "watch:ts": "tsc --watch",
     "generate": "langium generate && tsx scripts/generate-icons.ts",

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();
-      });
-    });
-  }
-}

package/dist/mcp/sseserver/MCPServerFactory.js

@@ -1,50 +0,0 @@
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import packageJson from "../../../package.json" with { type: "json" };
-import { listProjects } from "../tools/list-projects.js";
-import { openView } from "../tools/open-view.js";
-import { readElement } from "../tools/read-element.js";
-import { readProjectElements } from "../tools/read-project-elements.js";
-import { readProjectSummary } from "../tools/read-project-summary.js";
-import { readView } from "../tools/read-view.js";
-import { searchElement } from "../tools/search-element.js";
-export class LikeC4MCPServerFactory {
-  constructor(services) {
-    this.services = services;
-  }
-  create(options) {
-    const isInEditor = this.services.shared.lsp.Connection !== void 0;
-    const mcp = new McpServer({
-      name: "LikeC4",
-      version: packageJson.version
-    }, {
-      instructions: `Provides access to LikeC4 model.
-Available tools:
-- list-projects: List all available LikeC4 projects in the workspace
-- read-project-summary: to understand project specifications (what element kinds, tags, metadata keys are available) and available project views
-- read-project-elements: list all elements in the project
-- search-element: Search for LikeC4 element by partial match of id, title, kind, shape or tags
-- read-element: all information about the element (includes source location)
-- read-view: all information about the view (includes source location)
-${isInEditor ? "- open-view: opens the panel in the editor with the LikeC4 view" : ""}
-
-Documentation for LikeC4 is available at https://likec4.dev/llms-full.txt
-`,
-      ...options,
-      capabilities: {
-        tools: {},
-        resources: {},
-        ...options?.capabilities
-      }
-    });
-    mcp.registerTool(...listProjects(this.services.likec4.LanguageServices));
-    mcp.registerTool(...readProjectSummary(this.services.likec4.LanguageServices));
-    mcp.registerTool(...readProjectElements(this.services.likec4.LanguageServices));
-    mcp.registerTool(...readElement(this.services.likec4.LanguageServices));
-    mcp.registerTool(...readView(this.services.likec4.LanguageServices));
-    mcp.registerTool(...searchElement(this.services.likec4.LanguageServices));
-    if (isInEditor) {
-      mcp.registerTool(...openView(this.services.likec4.LanguageServices));
-    }
-    return mcp;
-  }
-}