@likec4/language-server 1.32.2 → 1.34.0

package/dist/index.d.ts

@@ -4,7 +4,6 @@ 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,12 +3,11 @@ 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 { WithMCPServer } from "./mcp/sseserver/WithMCPServer.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() {

package/dist/lsp/SemanticTokenProvider.js

@@ -272,7 +272,7 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
         });
         return "prune";
       }
-      if ("value" in node && node.value) {
+      if ("value" in node && node.value && !ast.isStringProperty(node)) {
         acceptor({
           node,
           property: "value",

package/dist/mcp/{LikeC4MCPServerFactory.d.ts → NoopLikeC4MCPServer.d.ts}

@@ -1,15 +1,7 @@
 import type { ServerOptions } from '@modelcontextprotocol/sdk/server/index.js';
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { LikeC4Services } from '../module';
-export interface LikeC4MCPServer {
-    readonly isStarted: boolean;
-    readonly port: number;
-    start(port: number): Promise<void>;
-    stop(): Promise<void>;
-}
-export interface LikeC4MCPServerFactory {
-    create(options?: ServerOptions): McpServer;
-}
+import type { LikeC4MCPServer, LikeC4MCPServerFactory } from './interfaces';
 export declare class NoopLikeC4MCPServer implements LikeC4MCPServer {
     get isStarted(): boolean;
     get port(): number;

package/dist/mcp/interfaces.d.ts

@@ -0,0 +1,11 @@
+import type { ServerOptions } from '@modelcontextprotocol/sdk/server/index.js';
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export interface LikeC4MCPServer {
+    readonly isStarted: boolean;
+    readonly port: number;
+    start(port: number): Promise<void>;
+    stop(): Promise<void>;
+}
+export interface LikeC4MCPServerFactory {
+    create(options?: ServerOptions): McpServer;
+}

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

@@ -1,6 +1,6 @@
 import type { AsyncDisposable } from 'langium';
 import type { LikeC4Services } from '../../module';
-import type { LikeC4MCPServer } from '../LikeC4MCPServerFactory';
+import type { LikeC4MCPServer } from '../interfaces';
 export declare class SSELikeC4MCPServer implements LikeC4MCPServer, AsyncDisposable {
     private services;
     private transports;

package/dist/mcp/sseserver/MCPServer.js

@@ -1,7 +1,6 @@
 import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
 import express from "express";
-import { logger as mainLogger } from "../../logger.js";
-const logger = mainLogger.getChild("LikeC4MCPServer");
+import { logger } from "../utils.js";
 export class SSELikeC4MCPServer {
   constructor(services) {
     this.services = services;
@@ -61,18 +60,19 @@ export class SSELikeC4MCPServer {
     });
   }
   async stop() {
+    this.transports = {};
     const server = this.server;
     if (!server) {
       return;
     }
-    logger.info("Stopping server");
+    logger.info("Stopping MCP server");
     this.server = void 0;
-    this.transports = {};
     return new Promise((resolve) => {
       server.close((err) => {
         if (err) {
-          logger.error("Failed to stop SSE server", { err });
+          logger.error("Failed to stop MCP server", { err });
         }
+        logger.info("MCP server stopped");
         resolve();
       });
     });

package/dist/mcp/sseserver/MCPServerFactory.js

@@ -1,78 +1,50 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import packageJson from "../../../package.json" with { type: "json" };
-import { LikeC4MCPTools } from "../LikeC4MCPTools.js";
-function toolResponse(text) {
-  return {
-    content: [{
-      type: "text",
-      text
-    }]
-  };
-}
+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 {
-      instructions,
-      listProjects,
-      readProjectSummary,
-      searchElement,
-      readElement,
-      readView
-    } = LikeC4MCPTools;
+    const isInEditor = this.services.shared.lsp.Connection !== void 0;
     const mcp = new McpServer({
       name: "LikeC4",
       version: packageJson.version
     }, {
-      instructions,
+      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
       }
     });
-    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));
-      }
-    );
+    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;
   }
 }

package/dist/mcp/sseserver/{with-mcp-server.d.ts → WithMCPServer.d.ts}

@@ -1,5 +1,5 @@
 import type { LikeC4Services } from '../../module';
-import type { LikeC4MCPServer } from '../LikeC4MCPServerFactory';
+import type { LikeC4MCPServer } from '../interfaces';
 import { LikeC4MCPServerFactory } from './MCPServerFactory';
 export declare const WithMCPServer: {
     mcp: {

package/dist/mcp/tools/_common.d.ts

@@ -0,0 +1,68 @@
+import z from 'zod';
+export declare const locationSchema: z.ZodObject<{
+    uri: z.ZodString;
+    range: z.ZodObject<{
+        start: z.ZodObject<{
+            line: z.ZodNumber;
+            character: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            line: number;
+            character: number;
+        }, {
+            line: number;
+            character: number;
+        }>;
+        end: z.ZodObject<{
+            line: z.ZodNumber;
+            character: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            line: number;
+            character: number;
+        }, {
+            line: number;
+            character: number;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        start: {
+            line: number;
+            character: number;
+        };
+        end: {
+            line: number;
+            character: number;
+        };
+    }, {
+        start: {
+            line: number;
+            character: number;
+        };
+        end: {
+            line: number;
+            character: number;
+        };
+    }>;
+}, "strip", z.ZodTypeAny, {
+    uri: string;
+    range: {
+        start: {
+            line: number;
+            character: number;
+        };
+        end: {
+            line: number;
+            character: number;
+        };
+    };
+}, {
+    uri: string;
+    range: {
+        start: {
+            line: number;
+            character: number;
+        };
+        end: {
+            line: number;
+            character: number;
+        };
+    };
+}>;

package/dist/mcp/tools/_common.js

@@ -0,0 +1,14 @@
+import z from "zod";
+export const locationSchema = z.object({
+  uri: z.string(),
+  range: z.object({
+    start: z.object({
+      line: z.number(),
+      character: z.number()
+    }),
+    end: z.object({
+      line: z.number(),
+      character: z.number()
+    })
+  })
+});

package/dist/mcp/tools/list-projects.d.ts

@@ -0,0 +1,6 @@
+import z from 'zod';
+export declare const listProjects: (languageServices: import("../..").LikeC4LanguageServices) => [string, {
+    inputSchema?: z.ZodRawShape | undefined;
+}, (args: {
+    [x: string]: any;
+}, extra: import("@modelcontextprotocol/sdk/shared/protocol").RequestHandlerExtra<import("@modelcontextprotocol/sdk/types").ServerRequest, import("@modelcontextprotocol/sdk/types").ServerNotification>) => import("@modelcontextprotocol/sdk/types").CallToolResult | Promise<import("@modelcontextprotocol/sdk/types").CallToolResult>];

package/dist/mcp/tools/list-projects.js

@@ -0,0 +1,31 @@
+import z from "zod";
+import { likec4Tool } from "../utils.js";
+export const listProjects = likec4Tool({
+  name: "list-projects",
+  description: `
+Lists all available LikeC4 projects in the workspace.
+Returns array of projects with:
+- name: project name (project id)
+- folder: project folder
+- sources: array of project sources
+`,
+  annotations: {
+    readOnlyHint: true
+  },
+  outputSchema: {
+    projects: z.array(z.object({
+      name: z.string(),
+      folder: z.string(),
+      sources: z.array(z.string())
+    }))
+  }
+}, async (languageServices) => {
+  const projects = await languageServices.projects();
+  return {
+    projects: projects.map((p) => ({
+      name: p.id,
+      folder: p.folder.toString(),
+      sources: p.documents?.map((d) => d.toString()) ?? []
+    }))
+  };
+});

package/dist/mcp/tools/open-view.d.ts

@@ -0,0 +1,10 @@
+import z from 'zod';
+export declare const openView: (languageServices: import("../..").LikeC4LanguageServices) => [string, {
+    inputSchema?: {
+        viewId: z.ZodString;
+        project: z.ZodOptional<z.ZodString>;
+    } | undefined;
+}, (args: {
+    viewId: string;
+    project?: string | undefined;
+}, extra: import("@modelcontextprotocol/sdk/shared/protocol").RequestHandlerExtra<import("@modelcontextprotocol/sdk/types").ServerRequest, import("@modelcontextprotocol/sdk/types").ServerNotification>) => import("@modelcontextprotocol/sdk/types").CallToolResult | Promise<import("@modelcontextprotocol/sdk/types").CallToolResult>];

package/dist/mcp/tools/open-view.js

@@ -0,0 +1,29 @@
+import { invariant } from "@likec4/core";
+import z from "zod";
+import { ProjectsManager } from "../../workspace/index.js";
+import { likec4Tool } from "../utils.js";
+export const openView = likec4Tool({
+  name: "open-view",
+  description: `
+Opens the panel with the LikeC4 view in the editor.
+Only one view can be opened at a time.
+`.trimStart(),
+  annotations: {
+    readOnlyHint: true
+  },
+  inputSchema: {
+    viewId: z.string().describe("View id (name)"),
+    project: z.string().optional().describe('Project name (optional, will use "default" if not specified)')
+  }
+}, async (languageServices, args) => {
+  const projectId = args.project ?? ProjectsManager.DefaultProjectId;
+  const project = languageServices.projects().find((p) => p.id === projectId);
+  invariant(project, `Project "${projectId}" not found`);
+  const model = await languageServices.computedModel(project.id);
+  const view = model.findView(args.viewId);
+  if (!view) {
+    throw new Error(`View with ID '${args.viewId}' not found in project ${project.id}`);
+  }
+  await languageServices.views.openView(view.id, project.id);
+  return `Command was sent to the editor to open the view "${view.id}"`;
+});

package/dist/mcp/tools/read-element.d.ts

@@ -0,0 +1,10 @@
+import z from 'zod';
+export declare const readElement: (languageServices: import("../..").LikeC4LanguageServices) => [string, {
+    inputSchema?: {
+        id: z.ZodString;
+        project: z.ZodOptional<z.ZodString>;
+    } | undefined;
+}, (args: {
+    id: string;
+    project?: string | undefined;
+}, extra: import("@modelcontextprotocol/sdk/shared/protocol").RequestHandlerExtra<import("@modelcontextprotocol/sdk/types").ServerRequest, import("@modelcontextprotocol/sdk/types").ServerNotification>) => import("@modelcontextprotocol/sdk/types").CallToolResult | Promise<import("@modelcontextprotocol/sdk/types").CallToolResult>];

package/dist/mcp/tools/read-element.js

@@ -0,0 +1,135 @@
+import { invariant } from "@likec4/core";
+import z from "zod";
+import { safeCall } from "../../utils/index.js";
+import { ProjectsManager } from "../../workspace/index.js";
+import { likec4Tool } from "../utils.js";
+import { locationSchema } from "./_common.js";
+export const readElement = likec4Tool({
+  name: "read-element",
+  description: `
+Returns information about LikeC4 element, includes:
+- id (FQN)
+- parent id (FQN of the parent element, if this element is a nested)
+- kind (element kind)
+- title, description, technology
+- array of assigned tags
+- project name this element belongs to
+- metadata (key-value pairs)
+- shape
+- children (array of ids of the direct children elements)
+- name of the default view of this element if any
+- array of views that include this element
+- element relationships:
+  - incoming and outgoing
+  - direct and indirect (relationships with the nested elements)
+  (relationships include title, kind, description, technology, tags)
+- array of Deployment FQNs that represent deployed instances of this element
+- source location (where the element is defined, if running in the editor)
+`.trimStart(),
+  annotations: {
+    readOnlyHint: true
+  },
+  inputSchema: {
+    id: z.string().describe("Element id (FQN)"),
+    project: z.string().optional().describe('Project name (optional, will use "default" if not specified)')
+  },
+  outputSchema: {
+    id: z.string().describe("Element id (FQN)"),
+    kind: z.string().describe("Element kind"),
+    name: z.string().describe("Element name"),
+    title: z.string(),
+    description: z.string().nullish(),
+    technology: z.string().nullish(),
+    tags: z.array(z.string()),
+    project: z.string(),
+    metadata: z.record(z.string()),
+    shape: z.string(),
+    children: z.array(z.string()).describe("Children of this element (Array of FQNs)"),
+    defaultView: z.string().nullish().describe("Name of the default view of this element"),
+    includedInViews: z.array(z.string()).describe("Views that include this element (Array of view names)"),
+    relationships: z.object({
+      incoming: z.array(z.object({
+        source: z.object({
+          id: z.string(),
+          title: z.string(),
+          kind: z.string()
+        }),
+        kind: z.string().nullish().describe("Relationship kind"),
+        target: z.string().describe(
+          "Target element id (FQN), either this element or nested element, if relationship is indirect"
+        ),
+        title: z.string().nullish().describe("Relationship title"),
+        description: z.string().nullish().describe("Relationship description"),
+        technology: z.string().nullish().describe("Relationship technology"),
+        tags: z.array(z.string()).describe("Relationship tags")
+      })),
+      outgoing: z.array(z.object({
+        source: z.string().describe("Source element id (FQN), either this element or nested element"),
+        target: z.object({
+          id: z.string(),
+          title: z.string(),
+          kind: z.string()
+        }),
+        kind: z.string().nullish().describe("Relationship kind"),
+        title: z.string().nullish().describe("Relationship title"),
+        description: z.string().nullish().describe("Relationship description"),
+        technology: z.string().nullish().describe("Relationship technology"),
+        tags: z.array(z.string()).describe("Relationship tags")
+      }))
+    }).describe("Relationships of this element (including indirect, incoming/outgoing to/from nested elements)"),
+    deployedInstances: z.array(z.string()).describe("Deployed instances of this element (Array of Deployment FQNs)"),
+    sourceLocation: locationSchema.nullish()
+  }
+}, async (languageServices, args) => {
+  const projectId = args.project ?? ProjectsManager.DefaultProjectId;
+  const project = languageServices.projects().find((p) => p.id === projectId);
+  invariant(project, `Project "${projectId}" not found`);
+  const model = await languageServices.computedModel(project.id);
+  const element = model.findElement(args.id);
+  invariant(element, `Element "${args.id}" not found in project "${projectId}"`);
+  return {
+    id: element.id,
+    name: element.name,
+    kind: element.kind,
+    title: element.title,
+    description: element.description.text,
+    technology: element.technology,
+    tags: [...element.tags],
+    project: project.id,
+    metadata: element.getMetadata(),
+    shape: element.shape,
+    children: [...element.children()].map((c) => c.id),
+    defaultView: element.defaultView?.id,
+    includedInViews: [...element.views()].map((v) => v.id),
+    relationships: {
+      incoming: [...element.incoming()].map((r) => ({
+        source: {
+          id: r.source.id,
+          title: r.source.title,
+          kind: r.source.kind
+        },
+        kind: r.kind,
+        target: r.target.id,
+        title: r.title,
+        description: r.description.text,
+        technology: r.technology,
+        tags: [...r.tags]
+      })),
+      outgoing: [...element.outgoing()].map((r) => ({
+        source: r.source.id,
+        target: {
+          id: r.target.id,
+          title: r.target.title,
+          kind: r.target.kind
+        },
+        kind: r.kind,
+        title: r.title,
+        description: r.description.text,
+        technology: r.technology,
+        tags: [...r.tags]
+      }))
+    },
+    deployedInstances: [...element.deployments()].map((i) => i.id),
+    sourceLocation: safeCall(() => languageServices.locate({ element: element.id, projectId }))
+  };
+});

package/dist/mcp/tools/read-project-elements.d.ts

@@ -0,0 +1,8 @@
+import z from 'zod';
+export declare const readProjectElements: (languageServices: import("../..").LikeC4LanguageServices) => [string, {
+    inputSchema?: {
+        project: z.ZodOptional<z.ZodString>;
+    } | undefined;
+}, (args: {
+    project?: string | undefined;
+}, extra: import("@modelcontextprotocol/sdk/shared/protocol").RequestHandlerExtra<import("@modelcontextprotocol/sdk/types").ServerRequest, import("@modelcontextprotocol/sdk/types").ServerNotification>) => import("@modelcontextprotocol/sdk/types").CallToolResult | Promise<import("@modelcontextprotocol/sdk/types").CallToolResult>];

package/dist/mcp/tools/read-project-elements.js

@@ -0,0 +1,93 @@
+import { invariant } from "@likec4/core";
+import z from "zod";
+import { safeCall } from "../../utils/index.js";
+import { ProjectsManager } from "../../workspace/index.js";
+import { likec4Tool } from "../utils.js";
+import { locationSchema } from "./_common.js";
+const elementSchema = z.array(
+  z.discriminatedUnion("type", [
+    z.object({
+      type: z.literal("logical"),
+      id: z.string().describe("Element ID (FQN)"),
+      kind: z.string(),
+      title: z.string(),
+      description: z.string().nullish(),
+      technology: z.string().nullish(),
+      shape: z.string(),
+      tags: z.array(z.string()),
+      defaultView: z.string().nullish().describe("Name of the default view of this element"),
+      sourceLocation: locationSchema.nullish()
+    }),
+    z.object({
+      type: z.literal("deployment-node"),
+      id: z.string().describe("Deployment ID (FQN)"),
+      kind: z.string(),
+      title: z.string(),
+      description: z.string().nullish(),
+      technology: z.string().nullish(),
+      shape: z.string(),
+      tags: z.array(z.string()),
+      defaultView: z.string().nullish().describe("Name of the default view of this element"),
+      sourceLocation: locationSchema.nullish()
+    })
+  ])
+);
+export const readProjectElements = likec4Tool({
+  name: "read-project-elements",
+  annotations: {
+    readOnlyHint: true
+  },
+  description: `
+Returns array of all elements in the project:
+- type (logical or deployment-node)
+- id (FQN)
+- kind
+- title, description and technology
+- shape
+- assigned tags
+- name of the default view of this element if any (applies to logical elements only)
+- source location (where the element is defined, if running in the editor)
+`,
+  inputSchema: {
+    project: z.string().optional().describe('Project name (optional, will use "default" if not specified)')
+  },
+  outputSchema: {
+    elements: elementSchema
+  }
+}, async (languageServices, args) => {
+  const projectId = args.project ?? ProjectsManager.DefaultProjectId;
+  const project = languageServices.projects().find((p) => p.id === projectId);
+  invariant(project, `Project "${projectId}" not found`);
+  const model = await languageServices.computedModel(project.id);
+  const elements = [];
+  for (const el of model.elements()) {
+    elements.push({
+      type: "logical",
+      id: el.id,
+      title: el.title,
+      description: el.description.text,
+      technology: el.technology,
+      kind: el.kind,
+      tags: [...el.tags],
+      shape: el.shape,
+      defaultView: el.defaultView?.id,
+      sourceLocation: safeCall(() => languageServices.locate({ element: el.id, projectId }))
+    });
+  }
+  for (const el of model.deployment.nodes()) {
+    elements.push({
+      type: "deployment-node",
+      id: el.id,
+      title: el.title,
+      description: el.description.text,
+      technology: el.technology,
+      kind: el.kind,
+      tags: [...el.tags],
+      shape: el.shape,
+      sourceLocation: safeCall(() => languageServices.locate({ deployment: el.id, projectId }))
+    });
+  }
+  return {
+    elements
+  };
+});

package/dist/mcp/tools/read-project-summary.d.ts

@@ -0,0 +1,8 @@
+import z from 'zod';
+export declare const readProjectSummary: (languageServices: import("../..").LikeC4LanguageServices) => [string, {
+    inputSchema?: {
+        project: z.ZodOptional<z.ZodString>;
+    } | undefined;
+}, (args: {
+    project?: string | undefined;
+}, extra: import("@modelcontextprotocol/sdk/shared/protocol").RequestHandlerExtra<import("@modelcontextprotocol/sdk/types").ServerRequest, import("@modelcontextprotocol/sdk/types").ServerNotification>) => import("@modelcontextprotocol/sdk/types").CallToolResult | Promise<import("@modelcontextprotocol/sdk/types").CallToolResult>];