@likec4/language-server 1.28.1 → 1.29.1

package/dist/index.d.ts

@@ -4,6 +4,7 @@ export { getLspConnectionSink, logger as lspLogger } from './logger';
 export type { DocumentParser, LikeC4ModelBuilder, LikeC4ModelLocator, LikeC4ModelParser } from './model';
 export type { LikeC4LanguageServices } from './LikeC4LanguageServices';
 export { isLikeC4Builtin } from './likec4lib';
+export { LikeC4MCPTools } from './mcp/LikeC4MCPTools';
 export { createCustomLanguageServices, createLanguageServices, LikeC4Module } from './module';
 export type { LikeC4Services, LikeC4SharedServices } from './module';
 export type { LikeC4Views } from './views';

package/dist/index.js

@@ -3,10 +3,12 @@ import { startLanguageServer as startLanguim } from "langium/lsp";
 import { createConnection, ProposedFeatures } from "vscode-languageserver/node";
 import { LikeC4FileSystem } from "./LikeC4FileSystem.js";
 import { getTelemetrySink, logger } from "./logger.js";
+import { WithMCPServer } from "./mcp/sseserver/with-mcp-server.js";
 import { createCustomLanguageServices } from "./module.js";
 import { ConfigurableLayouter } from "./views/configurable-layouter.js";
 export { getLspConnectionSink, logger as lspLogger } from "./logger.js";
 export { isLikeC4Builtin } from "./likec4lib.js";
+export { LikeC4MCPTools } from "./mcp/LikeC4MCPTools.js";
 export { createCustomLanguageServices, createLanguageServices, LikeC4Module } from "./module.js";
 export { LikeC4FileSystem };
 export function startLanguageServer() {
@@ -26,7 +28,11 @@ export function startLanguageServer() {
     ]
   });
   logger.info("Starting LikeC4 language server");
-  const services = createCustomLanguageServices({ connection, ...LikeC4FileSystem }, ConfigurableLayouter);
+  const services = createCustomLanguageServices(
+    { connection, ...LikeC4FileSystem },
+    ConfigurableLayouter,
+    WithMCPServer
+  );
   startLanguim(services.shared);
   return services;
 }

package/dist/lsp/SemanticTokenProvider.js

@@ -27,7 +27,7 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
       });
       return "prune";
     }
-    if (ast.isRelation(node) || ast.isOutgoingRelationExpr(node) && "kind" in node) {
+    if ((ast.isRelation(node) || ast.isOutgoingRelationExpr(node) || ast.isDeploymentRelation(node)) && "kind" in node) {
       acceptor({
         node,
         property: "kind",
@@ -43,7 +43,7 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
       acceptor({
         node,
         property: "value",
-        type: SemanticTokenTypes.variable,
+        type: SemanticTokenTypes.interface,
         modifier: [
           SemanticTokenModifiers.definition,
           SemanticTokenModifiers.readonly
@@ -60,17 +60,6 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
           SemanticTokenModifiers.readonly
         ]
       });
-      if (ast.isFqnRefExpr(node) && node.selector) {
-        acceptor({
-          node,
-          property: "selector",
-          type: SemanticTokenTypes.variable,
-          modifier: [
-            SemanticTokenModifiers.definition,
-            SemanticTokenModifiers.readonly
-          ]
-        });
-      }
       return "prune";
     }
     if (ast.isWhereRelationKind(node) && isTruthy(node.value)) {
@@ -107,7 +96,7 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
         type: SemanticTokenTypes.type,
         modifier: [SemanticTokenModifiers.definition]
       });
-      return "prune";
+      return;
     }
     if (ast.isGlobalStyleGroup(node) || ast.isGlobalStyle(node)) {
       acceptor({
@@ -164,7 +153,7 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
         type: SemanticTokenTypes.type,
         modifier: [SemanticTokenModifiers.definition]
       });
-      return "prune";
+      return;
     }
     if (ast.isFqnRef(node) || ast.isStrictFqnRef(node)) {
       acceptor({
@@ -190,18 +179,6 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
       });
       return !node.parent ? "prune" : void 0;
     }
-    if (ast.isImported(node)) {
-      acceptor({
-        node,
-        property: "imported",
-        type: SemanticTokenTypes.variable,
-        modifier: [
-          SemanticTokenModifiers.definition,
-          SemanticTokenModifiers.readonly
-        ]
-      });
-      return "prune";
-    }
     if (ast.isSpecificationColor(node)) {
       acceptor({
         node,
@@ -310,7 +287,7 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
     acceptor({
       node,
       property: "name",
-      type: SemanticTokenTypes.function,
+      type: SemanticTokenTypes.variable,
       modifier: [
         SemanticTokenModifiers.declaration,
         SemanticTokenModifiers.readonly

package/dist/mcp/LikeC4MCPServerFactory.d.ts

@@ -0,0 +1,16 @@
+import type { ServerOptions } from '@modelcontextprotocol/sdk/server/index.js';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { LikeC4Services } from '../module';
+export interface LikeC4MCPServer {
+    start(port: number): Promise<void>;
+    stop(): Promise<void>;
+}
+export declare class NoopLikeC4MCPServer implements LikeC4MCPServer {
+    start(port: number): Promise<never>;
+    stop(): Promise<never>;
+}
+export declare class LikeC4MCPServerFactory {
+    private services;
+    constructor(services: LikeC4Services);
+    create(options?: ServerOptions): McpServer;
+}

package/dist/mcp/LikeC4MCPServerFactory.js

@@ -0,0 +1,86 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import packageJson from "../../package.json" with { type: "json" };
+import { LikeC4MCPTools } from "./LikeC4MCPTools.js";
+export class NoopLikeC4MCPServer {
+  start(port) {
+    return Promise.reject(new Error("Not implemented"));
+  }
+  stop() {
+    return Promise.reject(new Error("Not implemented"));
+  }
+}
+function toolResponse(text) {
+  return {
+    content: [{
+      type: "text",
+      text
+    }]
+  };
+}
+export class LikeC4MCPServerFactory {
+  constructor(services) {
+    this.services = services;
+  }
+  create(options) {
+    const {
+      instructions,
+      listProjects,
+      readProjectSummary,
+      searchElement,
+      readElement,
+      readView
+    } = LikeC4MCPTools;
+    const mcp = new McpServer({
+      name: "LikeC4",
+      version: packageJson.version
+    }, {
+      instructions,
+      ...options,
+      capabilities: {
+        tools: {},
+        ...options?.capabilities
+      }
+    });
+    const tools = this.services.mcp.Tools;
+    mcp.tool(
+      listProjects.name,
+      listProjects.description,
+      async () => {
+        return toolResponse(await tools.listProjects());
+      }
+    );
+    mcp.tool(
+      readProjectSummary.name,
+      readProjectSummary.description,
+      readProjectSummary.paramsSchema,
+      async (params) => {
+        return toolResponse(await tools.readProjectSummary(params.project));
+      }
+    );
+    mcp.tool(
+      searchElement.name,
+      searchElement.description,
+      searchElement.paramsSchema,
+      async (params) => {
+        return toolResponse(await tools.searchElement(params));
+      }
+    );
+    mcp.tool(
+      readElement.name,
+      readElement.description,
+      readElement.paramsSchema,
+      async (params) => {
+        return toolResponse(await tools.readElement(params));
+      }
+    );
+    mcp.tool(
+      readView.name,
+      readView.description,
+      readView.paramsSchema,
+      async (params) => {
+        return toolResponse(await tools.readView(params));
+      }
+    );
+    return mcp;
+  }
+}

package/dist/mcp/LikeC4MCPTools.d.ts

@@ -0,0 +1,96 @@
+import { type ProjectId } from '@likec4/core';
+import { z } from 'zod';
+import type { LikeC4Services } from '../module';
+export declare namespace LikeC4MCPTools {
+    const instructions = "This server provides access to LikeC4 model.\n\nKey capabilities:\n- List all available LikeC4 projects in the workspace\n- Search for LikeC4 project and return its summary, that includes specifications, all elements and views\n- Search for LikeC4 element by title\n- Read details about LikeC4 element by id\n- Read details about LikeC4 view by id\n\n";
+    const listProjects: {
+        name: string;
+        description: string;
+    };
+    const readProjectSummary: {
+        name: string;
+        description: string;
+        paramsSchema: {
+            project: z.ZodOptional<z.ZodString>;
+        };
+    };
+    const searchElement: {
+        name: string;
+        description: string;
+        paramsSchema: {
+            search: z.ZodString;
+        };
+    };
+    const readElement: {
+        name: string;
+        description: string;
+        paramsSchema: {
+            id: z.ZodString;
+            project: z.ZodOptional<z.ZodString>;
+        };
+    };
+    const readView: {
+        name: string;
+        description: string;
+        paramsSchema: {
+            id: z.ZodString;
+            project: z.ZodOptional<z.ZodString>;
+        };
+    };
+}
+export interface LikeC4MCPTools {
+    listProjects(): Promise<string>;
+    /**
+     * Searches for LikeC4 project and returns its summary, specifications, elements and views
+     *
+     * @param project Project name (optional, will use default project if not specified)
+     */
+    readProjectSummary(project?: string): Promise<string>;
+    /**
+     * Searches for LikeC4 elements that have the search string in their names
+     * Can be used to resolve projects for further requests (like read-element or read-project-summary)
+     *
+     * @param params.search non-empty string
+     */
+    searchElement(params: {
+        search: string;
+    }): Promise<string>;
+    /**
+     * Read details about LikeC4 element.
+     *
+     * @param params.id Element id (FQN)
+     * @param params.project Project name (optional, will use default project if not specified)
+     */
+    readElement(params: {
+        id: string;
+        project?: string | undefined;
+    }): Promise<string>;
+    /**
+     * Read details about LikeC4 view.
+     *
+     * @param params.id View id (FQN)
+     * @param params.project Project name (optional, will use default project if not specified)
+     */
+    readView(params: {
+        id: string;
+        project?: string | undefined;
+    }): Promise<string>;
+}
+export declare class DefaultLikeC4MCPTools implements LikeC4MCPTools {
+    private services;
+    private readonly languageServices;
+    constructor(services: LikeC4Services);
+    listProjects(): Promise<string>;
+    readProjectSummary(_project?: ProjectId): Promise<string>;
+    searchElement(params: {
+        search: string;
+    }): Promise<string>;
+    readElement(params: {
+        id: string;
+        project?: string;
+    }): Promise<string>;
+    readView(params: {
+        id: string;
+        project?: string;
+    }): Promise<string>;
+}

package/dist/mcp/LikeC4MCPTools.js

@@ -0,0 +1,288 @@
+import { loggable } from "@likec4/log";
+import { flatMap } from "remeda";
+import stripIndent from "strip-indent";
+import { z } from "zod";
+import { logger as mainLogger } from "../logger.js";
+import { toSingleLine } from "../model/parser/Base.js";
+import { ProjectsManager } from "../workspace/ProjectsManager.js";
+import { elementResource, modelViewResource } from "./utils.js";
+const logger = mainLogger.getChild("LikeC4MCPServices");
+function singleLine(str) {
+  const res = toSingleLine(str)?.replaceAll('"', "'");
+  return res ? `"${res}"` : "null";
+}
+function outputEach(iterator, ifEmpty, output) {
+  const items = [...iterator];
+  if (items.length === 0) {
+    return [ifEmpty];
+  }
+  return flatMap(items, output);
+}
+export var LikeC4MCPTools;
+((LikeC4MCPTools2) => {
+  LikeC4MCPTools2.instructions = `This server provides access to LikeC4 model.
+
+Key capabilities:
+- List all available LikeC4 projects in the workspace
+- Search for LikeC4 project and return its summary, that includes specifications, all elements and views
+- Search for LikeC4 element by title
+- Read details about LikeC4 element by id
+- Read details about LikeC4 view by id
+
+`;
+  LikeC4MCPTools2.listProjects = {
+    name: "list-projects",
+    description: "Lists all available LikeC4 projects in the workspace"
+  };
+  LikeC4MCPTools2.readProjectSummary = {
+    name: "read-project-summary",
+    description: stripIndent(`
+      Searches for LikeC4 project and returns its summary, specifications, elements and views
+
+      Args:
+        project: Project name
+    `),
+    paramsSchema: {
+      project: z.string().optional()
+    }
+  };
+  LikeC4MCPTools2.searchElement = {
+    name: "search-element",
+    description: stripIndent(`
+      Search for LikeC4 elements that have the search string in their names
+      Can be used to resolve projects for further requests (like read-element or read-project-summary)
+
+      Args:
+        search: non-empty string
+    `),
+    paramsSchema: {
+      search: z.string()
+    }
+  };
+  LikeC4MCPTools2.readElement = {
+    name: "read-element",
+    description: stripIndent(`
+      Read details about a LikeC4 element
+
+      Args:
+        id: Element id (FQN)
+        project: Project name (optional, will use default project if not specified)
+    `),
+    paramsSchema: {
+      id: z.string().min(1),
+      project: z.string().optional()
+    }
+  };
+  LikeC4MCPTools2.readView = {
+    name: "read-view",
+    description: stripIndent(`
+      Read details about a LikeC4 view
+
+      Args:
+        id: View id
+        project: Project name (optional, will use default project if not specified)
+    `),
+    paramsSchema: {
+      id: z.string().min(1),
+      project: z.string().optional()
+    }
+  };
+})(LikeC4MCPTools || (LikeC4MCPTools = {}));
+export class DefaultLikeC4MCPTools {
+  constructor(services) {
+    this.services = services;
+    this.languageServices = services.likec4.LanguageServices;
+  }
+  languageServices;
+  async listProjects() {
+    const projects = await this.languageServices.projects();
+    const response = [];
+    for (const project of projects) {
+      if (!project.documents) {
+        continue;
+      }
+      response.push(
+        `<likec4project>`,
+        `id: "${project.id}"`,
+        `folder: ${project.folder.toString()}`,
+        "sources:",
+        ...project.documents.map((d) => `- ${d.toString()}`),
+        ""
+      );
+      try {
+        const model = await this.languageServices.computedModel(project.id);
+        const elements = [...model.elements()];
+        if (elements.length > 0) {
+          response.push(
+            "elements:",
+            ...elements.flatMap((el) => [
+              `- id: ${el.id}`,
+              `  kind: ${el.kind}`,
+              `  title: ${singleLine(el.title)}`,
+              ""
+            ]),
+            ""
+          );
+        }
+        const views = [...model.views()];
+        if (views.length > 0) {
+          response.push(
+            "views:",
+            ...views.flatMap((v) => [
+              `- id: ${v.id}`,
+              `  title: ${singleLine(v.title)}`,
+              ""
+            ]),
+            ""
+          );
+        }
+      } catch (error) {
+        logger.error(loggable(error));
+      }
+      response.push(`</likec4project>`);
+    }
+    if (response.length === 0) {
+      response.push(
+        `<likec4project>`,
+        `id: "default"`,
+        `folder: ${this.languageServices.workspaceUri.toString()}`,
+        `</likec4project>`
+      );
+    }
+    return response.join("\n");
+  }
+  async readProjectSummary(_project) {
+    const projectId = _project ?? ProjectsManager.DefaultProjectId;
+    const project = this.languageServices.projects().find((p) => p.id === projectId);
+    if (!project) {
+      return "Project not found";
+    }
+    const model = await this.languageServices.computedModel(project.id);
+    const response = [
+      `project: "${project.id}"`,
+      `folder: ${project.folder.toString()}`
+    ];
+    if (project.documents) {
+      response.push(
+        "sources:",
+        ...project.documents.map((d) => `- ${d.toString()}`),
+        ""
+      );
+    }
+    response.push("<specifications>");
+    const elementKinds = Object.keys(model.$model.specification.elements);
+    if (elementKinds.length > 0) {
+      response.push(
+        "element kinds:",
+        ...elementKinds.map((kind) => `- ${kind}`),
+        ""
+      );
+    }
+    const relationshipKinds = Object.keys(model.$model.specification.relationships);
+    if (relationshipKinds.length > 0) {
+      response.push(
+        "relationship kinds:",
+        ...relationshipKinds.map((kind) => `- ${kind}`),
+        ""
+      );
+    }
+    const deploymentKinds = Object.keys(model.$model.specification.deployments);
+    if (deploymentKinds.length > 0) {
+      response.push(
+        "deployment node kinds:",
+        ...deploymentKinds.map((kind) => `- ${kind}`),
+        ""
+      );
+    }
+    if (model.allTags().length > 0) {
+      response.push(
+        "tags:",
+        ...model.allTags().map((t) => `- ${t}`),
+        ""
+      );
+    }
+    response.push(
+      "</specifications>",
+      ""
+    );
+    response.push(
+      "<elements>",
+      ...outputEach(model.elements(), "No elements", (el) => [
+        `- id: ${el.id}`,
+        ...el.parent ? [
+          `  parentId: ${el.parent.id}`
+        ] : [],
+        `  kind: ${el.kind}`,
+        `  shape: ${el.shape}`,
+        `  title: ${singleLine(el.title)}`,
+        `  description: ${singleLine(el.description)}`,
+        `  technology: ${singleLine(el.technology)}`,
+        `  tags: ${JSON.stringify(el.tags)}`,
+        ""
+      ]),
+      "</elements>",
+      "<views>",
+      ...outputEach(model.views(), "No views", (v) => [
+        `- id: ${v.id}`,
+        `  viewType: ${v.__}`,
+        `  title: ${singleLine(v.title)}`,
+        ""
+      ]),
+      "</views>"
+    );
+    return response.join("\n");
+  }
+  async searchElement(params) {
+    const search = params.search.toLowerCase();
+    const found = [];
+    for (const project of this.languageServices.projects()) {
+      try {
+        const model = await this.languageServices.computedModel(project.id);
+        const elements = [...model.elements()].filter((el) => el.title.toLowerCase().includes(search));
+        if (elements.length > 0) {
+          found.push(
+            "<project>",
+            `project: "${project.id}"`,
+            "found:",
+            ...elements.flatMap((el) => [
+              `- id: ${el.id}`,
+              `  kind: ${el.kind}`,
+              `  title: ${singleLine(el.title)}`,
+              ""
+            ]),
+            "</project>"
+          );
+        }
+      } catch (error) {
+        logger.error(loggable(error));
+      }
+    }
+    return found.length > 0 ? found.join("\n") : "No elements with this name found";
+  }
+  async readElement(params) {
+    const projectId = params.project ?? ProjectsManager.DefaultProjectId;
+    const project = this.languageServices.projects().find((p) => p.id === projectId);
+    if (!project) {
+      return `Project "${projectId}" not found`;
+    }
+    const model = await this.languageServices.computedModel(project.id);
+    const element = model.findElement(params.id);
+    if (!element) {
+      return `Element "${params.id}" not found in project "${projectId}"`;
+    }
+    return JSON.stringify(elementResource(this.languageServices, element, project.id));
+  }
+  async readView(params) {
+    const projectId = params.project ?? ProjectsManager.DefaultProjectId;
+    const project = this.languageServices.projects().find((p) => p.id === projectId);
+    if (!project) {
+      return `Project "${projectId}" not found`;
+    }
+    const model = await this.languageServices.computedModel(project.id);
+    const view = model.findView(params.id);
+    if (!view) {
+      return `View "${params.id}" not found in project "${projectId}"`;
+    }
+    return JSON.stringify(modelViewResource(this.languageServices, view, project.id));
+  }
+}

package/dist/mcp/sseserver/SSELikeC4MCPServer.d.ts

@@ -0,0 +1,13 @@
+import type { AsyncDisposable } from 'langium';
+import type { LikeC4Services } from '../../module';
+import type { LikeC4MCPServer } from '../LikeC4MCPServerFactory';
+export declare class SSELikeC4MCPServer implements LikeC4MCPServer, AsyncDisposable {
+    private services;
+    private readonly transports;
+    private server;
+    private port;
+    constructor(services: LikeC4Services);
+    dispose(): Promise<void>;
+    start(port?: number): Promise<void>;
+    stop(): Promise<void>;
+}

package/dist/mcp/sseserver/SSELikeC4MCPServer.js

@@ -0,0 +1,74 @@
+import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
+import express from "express";
+import { logger as mainLogger } from "../../logger.js";
+const logger = mainLogger.getChild("LikeC4MCPServer");
+export class SSELikeC4MCPServer {
+  constructor(services) {
+    this.services = services;
+  }
+  // Store transports by session ID to send notifications
+  transports = {};
+  server = void 0;
+  port = 33335;
+  async dispose() {
+    await this.stop();
+  }
+  async start(port = 33335) {
+    if (this.server) {
+      if (this.port === port) {
+        return;
+      }
+      await this.stop();
+    }
+    logger.info("Starting 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(port, (err) => {
+        if (err) {
+          logger.error("Failed to start server", { err });
+          reject(err);
+          return;
+        }
+        logger.info("server listening on port {port}", { port });
+        resolve();
+      });
+    });
+  }
+  async stop() {
+    const server = this.server;
+    if (!server) {
+      return;
+    }
+    logger.info("Stopping server");
+    this.server = void 0;
+    return new Promise((resolve) => {
+      server.close((err) => {
+        if (err) {
+          logger.error("Failed to stop SSE server", { err });
+        }
+        resolve();
+      });
+    });
+  }
+}

package/dist/mcp/sseserver/with-mcp-server.d.ts

@@ -0,0 +1,7 @@
+import type { LikeC4Services } from '../../module';
+import type { LikeC4MCPServer } from '../LikeC4MCPServerFactory';
+export declare const WithMCPServer: {
+    mcp: {
+        Server(services: LikeC4Services): LikeC4MCPServer;
+    };
+};