@likec4/language-server 1.42.1 → 1.44.0

package/dist/lsp/SemanticTokenProvider.d.ts

@@ -1,7 +1,12 @@
 import type { AstNode } from 'langium';
 import { type SemanticTokenAcceptor, AbstractSemanticTokenProvider } from 'langium/lsp';
+import type { LikeC4Services } from '../module';
 export declare class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
+    private rules;
+    constructor(services: LikeC4Services);
+    protected initRules(): void;
     protected highlightElement(node: AstNode, acceptor: SemanticTokenAcceptor): void | undefined | 'prune';
     private highlightNameAndKind;
     private highlightView;
+    private mark;
 }

package/dist/lsp/SemanticTokenProvider.js

@@ -0,0 +1,257 @@
+import { invariant, isAnyOf, nonNullable } from '@likec4/core/utils';
+import { AbstractSemanticTokenProvider, } from 'langium/lsp';
+import { isTruthy } from 'remeda';
+import { SemanticTokenModifiers, SemanticTokenTypes } from 'vscode-languageserver-types';
+import { ast } from '../ast';
+import { logger } from '../logger';
+const SemanticTypes = { ...SemanticTokenTypes };
+const SemanticModifiers = { ...SemanticTokenModifiers };
+function createSemanticTypeMethods(applyHighlight) {
+    const modifier = [];
+    const self = new Proxy({}, {
+        get(_, prop) {
+            if (prop === 'modifier') {
+                return (mod) => {
+                    modifier.push(mod);
+                    return self;
+                };
+            }
+            if (prop in SemanticModifiers) {
+                modifier.push(SemanticModifiers[prop]);
+                return self;
+            }
+            if (prop in SemanticTypes) {
+                return () => applyHighlight(SemanticTypes[prop], modifier);
+            }
+            throw new Error(`Unknown semantic token type or modifier: ${prop}`);
+        },
+    });
+    return self;
+}
+const PRUNE = 'Stop Highlighting';
+/**
+ * Used to stop further highlighting for the current node (processing of its children
+ */
+const stopHighlight = () => {
+    throw PRUNE;
+};
+export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
+    rules = [];
+    constructor(services) {
+        super(services);
+        this.initRules();
+    }
+    initRules() {
+        this.rules = [];
+        const when = (predicate, highlightFn) => {
+            const rule = { predicate, highlightFn };
+            this.rules.push(rule);
+        };
+        when(ast.isRelationshipKind, mark => {
+            mark.property('name').function();
+        });
+        when(isAnyOf(ast.isRelation, ast.isOutgoingRelationExpr, ast.isDeploymentRelation), mark => {
+            mark.property('kind').function();
+        });
+        when(ast.isLibIcon, mark => {
+            mark.property('name').definition.function();
+            stopHighlight();
+        });
+        when(isAnyOf(ast.isNavigateToProperty, ast.isRelationNavigateToProperty), mark => {
+            mark.property('value').readonly.definition.interface();
+            stopHighlight();
+        });
+        when(isAnyOf(ast.isFqnRefExpr, ast.isWildcardExpression), mark => {
+            mark.cst().readonly.definition.variable();
+            stopHighlight();
+        });
+        when(ast.isTagRef, mark => {
+            mark.cst().type();
+            stopHighlight();
+        });
+        when(ast.isRelationKindDotRef, mark => {
+            mark.cst().function();
+            stopHighlight();
+        });
+        when(ast.isWhereRelationKind, mark => {
+            if (isTruthy(mark.node.value)) {
+                mark.property('value').function();
+            }
+        });
+        when(isAnyOf(ast.isWhereElement, ast.isWhereRelation), mark => {
+            if (isTruthy(mark.node.value)) {
+                mark.property('value').readonly.definition.type();
+            }
+        });
+        when(isAnyOf(ast.isWhereRelationParticipantKind, ast.isWhereRelationParticipantTag), mark => {
+            mark.property('participant').keyword();
+        });
+        when(ast.isElementKindExpression, mark => {
+            if (isTruthy(mark.node.kind)) {
+                mark.property('kind').definition.type();
+            }
+        });
+        when(isAnyOf(ast.isGlobalStyleGroup, ast.isGlobalStyle), mark => {
+            mark.property('id').readonly.definition.variable();
+        });
+        when(ast.isViewRuleGlobalStyle, mark => {
+            mark.property('style').readonly.definition.variable();
+        });
+        when(isAnyOf(ast.isGlobalPredicateGroup, ast.isGlobalDynamicPredicateGroup), mark => {
+            mark.property('name').readonly.definition.variable();
+        });
+        when(ast.isViewRuleGlobalPredicateRef, mark => {
+            mark.property('predicate').readonly.definition.variable();
+        });
+        when(ast.isElementTagExpression, mark => {
+            if (isTruthy(mark.node.tag)) {
+                mark.property('tag').definition.type();
+            }
+        });
+        when(isAnyOf(ast.isFqnRef, ast.isStrictFqnRef), mark => {
+            mark.property('value').readonly.definition.variable();
+            if (!mark.node.parent) {
+                stopHighlight();
+            }
+        });
+        when(ast.isStrictFqnElementRef, mark => {
+            mark.property('el').readonly.definition.variable();
+            if (!mark.node.parent) {
+                stopHighlight();
+            }
+        });
+        when(ast.isSpecificationColor, mark => {
+            mark.keyword('color').keyword();
+            mark.property('name').readonly.declaration.type();
+        });
+        when(ast.isSpecificationTag, mark => {
+            if (isTruthy(mark.node.color)) {
+                mark.keyword('color').property();
+            }
+        });
+        when(isAnyOf(ast.isSpecificationElementKind, ast.isSpecificationRelationshipKind, ast.isSpecificationDeploymentNodeKind), mark => {
+            mark.property('kind').readonly.declaration.type();
+        });
+        when(ast.isTag, mark => {
+            mark.property('name').definition.type();
+        });
+        when(ast.isOpacityProperty, mark => {
+            mark.property('value').number();
+        });
+        when(ast.isIconProperty, mark => {
+            if (mark.node.libicon || mark.node.value === 'none') {
+                mark.property(mark.node.libicon ? 'libicon' : 'value').defaultLibrary.enum();
+                return;
+            }
+            mark.property('value').string();
+        });
+        when(ast.isLinkProperty, mark => {
+            if (isTruthy(mark.node.value)) {
+                mark.property('value').string();
+            }
+        });
+        when(ast.isColorProperty, mark => {
+            if (isTruthy(mark.node.customColor)) {
+                mark.property('customColor').enum();
+            }
+            if (isTruthy(mark.node.themeColor)) {
+                mark.property('themeColor').enum();
+            }
+        });
+        when(isAnyOf(ast.isShapeProperty, ast.isArrowProperty, ast.isLineProperty, ast.isBorderProperty, ast.isSizeProperty, ast.isDynamicViewDisplayVariantProperty), mark => {
+            if (isTruthy(mark.node.value)) {
+                mark.property('value').enum();
+            }
+        });
+    }
+    highlightElement(node, acceptor) {
+        try {
+            if (isAnyOf(ast.isElement, ast.isDeploymentNode, ast.isDeployedInstance)(node)) {
+                return this.highlightNameAndKind(node);
+            }
+            if (ast.isLikeC4View(node)) {
+                return this.highlightView(node);
+            }
+            if (ast.isAnyProperty(node) &&
+                !isAnyOf(ast.isMetadataProperty, ast.isElementStyleProperty, ast.isRelationStyleProperty)(node)) {
+                invariant(node.key);
+                acceptor({
+                    node,
+                    property: 'key',
+                    type: SemanticTokenTypes.property,
+                });
+            }
+            for (const { predicate, highlightFn } of this.rules) {
+                if (predicate(node)) {
+                    highlightFn(this.mark(node));
+                    break;
+                }
+            }
+        }
+        catch (error) {
+            if (error === PRUNE) {
+                return 'prune';
+            }
+            logger.warn(`Error highlighting node of type ${node._type}`, { error });
+        }
+    }
+    highlightNameAndKind(node) {
+        const mark = this.mark(node);
+        mark.property('name').declaration.readonly.variable();
+        if (!ast.isDeployedInstance(node)) {
+            this.mark(node).property('kind').keyword();
+        }
+        if (ast.isElement(node)) {
+            if (node.props.length > 0) {
+                this.mark(node).property('props').string();
+            }
+            return;
+        }
+        // This is DeploymentNode
+        if (node.title) {
+            this.mark(node).property('title').string();
+        }
+    }
+    highlightView(node) {
+        if (node.name) {
+            const mark = this.mark(node);
+            mark.property('name')
+                .modifier('local')
+                .declaration
+                .readonly
+                .interface();
+        }
+    }
+    mark(node) {
+        const cst = (cstNode) => {
+            return createSemanticTypeMethods((type, modifier) => this.highlightToken({
+                range: nonNullable(cstNode ?? node.$cstNode, 'AST node has no CST node').range,
+                type,
+                modifier,
+            }));
+        };
+        const keyword = (keyword) => {
+            return createSemanticTypeMethods((type, modifier) => this.highlightKeyword({
+                node,
+                keyword,
+                type,
+                modifier,
+            }));
+        };
+        const property = (property, index) => {
+            return createSemanticTypeMethods((type, modifier) => this.highlightProperty({
+                node,
+                property,
+                type,
+                modifier,
+                ...(index !== undefined ? { index } : {}),
+            }));
+        };
+        return {
+            node,
+            cst,
+            keyword,
+            property,
+        };
+    }
+}

package/dist/lsp/index.d.ts

@@ -4,4 +4,5 @@ export * from './DocumentHighlightProvider';
 export * from './DocumentLinkProvider';
 export * from './DocumentSymbolProvider';
 export * from './HoverProvider';
+export * from './CodeActionProvider';
 export * from './SemanticTokenProvider';

package/dist/lsp/index.js

@@ -0,0 +1,9 @@
+export * from './CodeLensProvider';
+export * from './CompletionProvider';
+export * from './DocumentHighlightProvider';
+export * from './DocumentLinkProvider';
+export * from './DocumentSymbolProvider';
+export * from './HoverProvider';
+// export * from './RenameProvider'
+export * from './CodeActionProvider';
+export * from './SemanticTokenProvider';

package/dist/mcp/MCPServerFactory.js

@@ -0,0 +1,73 @@
+import { loggable } from '@likec4/log';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import packageJson from '../../package.json' with { type: 'json' };
+import { logger } from '../logger';
+import { findRelationships } from './tools/find-relationships';
+import { listProjects } from './tools/list-projects';
+import { openView } from './tools/open-view';
+import { readDeployment } from './tools/read-deployment';
+import { readElement } from './tools/read-element';
+import { readProjectSummary } from './tools/read-project-summary';
+import { readView } from './tools/read-view';
+import { searchElement } from './tools/search-element';
+export class LikeC4MCPServerFactory {
+    services;
+    constructor(services) {
+        this.services = services;
+    }
+    create(options) {
+        const isInEditor = this.services.shared.lsp.Connection !== undefined;
+        const mcp = new McpServer({
+            name: 'LikeC4',
+            version: packageJson.version,
+        }, {
+            instructions: `LikeC4 MCP – query and navigate LikeC4 models.
+
+Conventions:
+- All tools are read-only and idempotent.
+- "project" is optional and defaults to "default".
+
+Available tools:
+- list-projects — List all LikeC4 projects in the workspace.
+- read-project-summary — Project specification (element kinds, deployment node kinds, tags, metadata keys), all elements, deployment nodes and views. Input: { project? }.
+- search-element — Search elements and deployment nodes across all projects by id/title/kind/shape/tags/metadata. Input: { search }.
+- read-element — Full element details including relationships, includedInViews, deployedInstances, metadata and sourceLocation. Input: { id, project? }.
+- read-deployment — Details of a deployment node or deployed instance. Input: { id, project? }.
+- read-view — Full view details (nodes/edges) and sourceLocation. Input: { viewId, project? }.
+- find-relationships — Direct and indirect relationships between two elements in a project. Input: { element1, element2, project? }.
+${isInEditor
+                ? '- open-view — Opens the LikeC4 view panel in the editor. Triggers UI; at most one preview panel at a time. Input: { viewId, project? }.'
+                : ''}
+
+Instructions:
+- Identify the project first  
+  - Use "search-element" to find elements by id/title/kind/shape/tags/metadata and select the project
+  - Use "read-project-summary" to find all elements and deployment nodes inside the project, what kinds, tags, metadata keys are available
+  - Use "list-projects" to list all available projects
+- If response returns "sourceLocation", provide link to this location in the editor
+
+Full documentation: https://likec4.dev/llms-full.txt
+`,
+            enforceStrictCapabilities: true,
+            ...options,
+            capabilities: {
+                tools: {},
+                ...options?.capabilities,
+            },
+        });
+        mcp.registerTool(...listProjects(this.services.likec4.LanguageServices));
+        mcp.registerTool(...readProjectSummary(this.services.likec4.LanguageServices));
+        mcp.registerTool(...readElement(this.services.likec4.LanguageServices));
+        mcp.registerTool(...readDeployment(this.services.likec4.LanguageServices));
+        mcp.registerTool(...readView(this.services.likec4.LanguageServices));
+        mcp.registerTool(...searchElement(this.services.likec4.LanguageServices));
+        mcp.registerTool(...findRelationships(this.services.likec4.LanguageServices));
+        if (isInEditor) {
+            mcp.registerTool(...openView(this.services.likec4.LanguageServices));
+        }
+        mcp.server.onerror = (err) => {
+            logger.error(loggable(err));
+        };
+        return mcp;
+    }
+}

package/dist/mcp/NoopLikeC4MCPServer.js

@@ -0,0 +1,17 @@
+export class NoopLikeC4MCPServer {
+    get mcp() {
+        throw new Error('NoopLikeC4MCPServer does not have a McpServer');
+    }
+    get isStarted() {
+        return false;
+    }
+    get port() {
+        return NaN;
+    }
+    start() {
+        return Promise.resolve();
+    }
+    stop() {
+        return Promise.resolve();
+    }
+}

package/dist/mcp/interfaces.js

@@ -0,0 +1,5 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { NoopLikeC4MCPServer } from './NoopLikeC4MCPServer';
+export const NoMCPServer = {
+    mcpServer: () => new NoopLikeC4MCPServer(),
+};

package/dist/mcp/server/StdioLikeC4MCPServer.js

@@ -0,0 +1,47 @@
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { logger } from '../utils';
+export class StdioLikeC4MCPServer {
+    services;
+    transport = undefined;
+    _mcp = undefined;
+    constructor(services) {
+        this.services = services;
+    }
+    get mcp() {
+        if (!this._mcp) {
+            throw new Error('MCP server is not started');
+        }
+        return this._mcp;
+    }
+    get isStarted() {
+        return this.transport !== undefined;
+    }
+    get port() {
+        return NaN;
+    }
+    async dispose() {
+        await this.stop();
+    }
+    async start() {
+        if (this.transport) {
+            return;
+        }
+        logger.info('Starting MCP stdio server');
+        this._mcp = this.services.mcp.ServerFactory.create();
+        this.transport = new StdioServerTransport();
+        await this._mcp.connect(this.transport);
+        logger.info('LikeC4 MCP Server running on stdio');
+    }
+    async stop() {
+        if (!this.transport) {
+            return;
+        }
+        logger.info('Stopping MCP stdio server');
+        await this.transport.close();
+        if (this._mcp) {
+            await this._mcp.close();
+        }
+        this._mcp = undefined;
+        this.transport = undefined;
+    }
+}

package/dist/mcp/server/StreamableLikeC4MCPServer.js

@@ -0,0 +1,145 @@
+import { serve } from '@hono/node-server';
+import { promiseNextTick } from '@likec4/core/utils';
+import { loggable } from '@likec4/log';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { toFetchResponse, toReqRes } from 'fetch-to-node';
+import { Hono } from 'hono';
+import { logger } from '../utils';
+export class StreamableLikeC4MCPServer {
+    services;
+    _port;
+    // Store transports by session ID to send notifications
+    server = undefined;
+    constructor(services, _port = 33335) {
+        this.services = services;
+        this._port = _port;
+    }
+    get mcp() {
+        throw new Error('StreamableLikeC4MCPServer has access to McpServer only during the request');
+    }
+    get isStarted() {
+        return this.server?.listening === true;
+    }
+    get port() {
+        return this._port;
+    }
+    async dispose() {
+        await this.stop();
+    }
+    async start(port = this._port) {
+        try {
+            if (this.server) {
+                if (this.port === port) {
+                    return;
+                }
+                await this.stop();
+            }
+            logger.info('Starting MCP server on port {port}', { port });
+            this._port = port;
+            await promiseNextTick();
+            const app = new Hono()
+                .post('/mcp', async (c) => {
+                const { req, res } = toReqRes(c.req.raw);
+                const server = this.services.mcp.ServerFactory.create();
+                try {
+                    const transport = new StreamableHTTPServerTransport({
+                        sessionIdGenerator: undefined,
+                    });
+                    // Added for extra debuggability
+                    transport.onerror = (err) => {
+                        logger.error(loggable(err));
+                    };
+                    await server.connect(transport);
+                    await transport.handleRequest(req, res, await c.req.json());
+                    res.on('close', async () => {
+                        logger.debug('Request closed');
+                        await transport.close();
+                        await server.close();
+                    });
+                    return toFetchResponse(res);
+                }
+                catch (e) {
+                    logger.error(loggable(e));
+                    return c.json({
+                        jsonrpc: '2.0',
+                        error: {
+                            code: -32603,
+                            message: 'Internal server error',
+                        },
+                        id: null,
+                    }, { status: 500 });
+                }
+            })
+                .get('/mcp', async (c) => {
+                logger.debug('Received GET MCP request');
+                return c.json({
+                    jsonrpc: '2.0',
+                    error: {
+                        code: -32000,
+                        message: 'Method not allowed.',
+                    },
+                    id: null,
+                }, { status: 405 });
+            })
+                .delete('/mcp', async (c) => {
+                logger.debug('Received DELETE MCP request');
+                return c.json({
+                    jsonrpc: '2.0',
+                    error: {
+                        code: -32000,
+                        message: 'Method not allowed.',
+                    },
+                    id: null,
+                }, { status: 405 });
+            })
+                .notFound((c) => {
+                logger.debug(`${c.req.method} ${c.req.url} not found`);
+                return c.json({
+                    jsonrpc: '2.0',
+                    error: {
+                        code: -32000,
+                        message: 'Method not found.',
+                    },
+                    id: null,
+                }, { status: 404 });
+            })
+                .onError((e, c) => {
+                logger.error(loggable(e));
+                return c.json({
+                    jsonrpc: '2.0',
+                    error: {
+                        code: -32603,
+                        message: 'Internal server error',
+                    },
+                    id: null,
+                }, { status: 500 });
+            });
+            this.server = serve({
+                fetch: app.fetch,
+                hostname: '0.0.0.0',
+                port: this._port,
+            }, (info) => logger.info('MCP server ready at http://0.0.0.0:{port}/mcp', { port: info.port }));
+        }
+        catch (err) {
+            logger.warn('Failed to start MCP server', { err });
+            return Promise.reject(err);
+        }
+    }
+    stop() {
+        const server = this.server;
+        if (!server) {
+            return Promise.resolve();
+        }
+        logger.info('Stopping MCP server');
+        this.server = undefined;
+        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/server/WithMCPServer.js

@@ -0,0 +1,56 @@
+import { loggable } from '@likec4/log';
+import { isError } from 'remeda';
+import { logger } from '../utils';
+import { StdioLikeC4MCPServer } from './StdioLikeC4MCPServer';
+import { StreamableLikeC4MCPServer } from './StreamableLikeC4MCPServer';
+const streamableLikeC4MCPServer = (services, defaultPort = 33335) => {
+    logger.debug('Creating StreamableLikeC4MCPServer');
+    const server = new StreamableLikeC4MCPServer(services, defaultPort);
+    const langId = services.LanguageMetaData.languageId;
+    const connection = services.shared.lsp.Connection;
+    services.shared.workspace.ConfigurationProvider.onConfigurationSectionUpdate((update) => {
+        if (update.section !== langId) {
+            logger.warn('Unexpected configuration update: {update}', { update });
+            return;
+        }
+        logger.debug('Configuration update: {update}', { update });
+        const { enabled = false, port = defaultPort, } = update.configuration.mcp;
+        if (!enabled) {
+            void server.stop();
+            return;
+        }
+        void Promise.resolve()
+            .then(() => server.start(port))
+            .then(() => {
+            connection?.telemetry?.logEvent({
+                eventName: 'mcp-server-started',
+                mcpPort: port,
+            });
+        })
+            .catch(err => {
+            const message = isError(err) ? err.message : undefined;
+            connection?.telemetry?.logEvent({
+                eventName: 'mcp-server-start-failed',
+                mcpPort: port,
+                ...message && { message },
+            });
+            logger.error('Failed to start LikeC4 MCP Server', { err });
+            if (connection) {
+                connection.window.showErrorMessage(`LikeC4: Failed to start MCP Server\n\n${loggable(err)}`);
+            }
+        });
+    });
+    return server;
+};
+const stdioLikeC4MCPServer = (services) => {
+    return new StdioLikeC4MCPServer(services);
+};
+export const WithMCPServer = (type = 'sse') => ({
+    mcpServer: (services) => {
+        if (type === 'stdio') {
+            return stdioLikeC4MCPServer(services);
+        }
+        const port = typeof type === 'object' ? type.port : 33335;
+        return streamableLikeC4MCPServer(services, port);
+    },
+});

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

@@ -1,5 +1,6 @@
 import type { LikeC4ViewModel } from '@likec4/core/model';
-import z from 'zod';
+import type { ProjectId } from '@likec4/core/types';
+import * as z from 'zod/v3';
 import type { LikeC4LanguageServices } from '../../LikeC4LanguageServices';
 import type { Locate } from '../../protocol';
 export declare const locationSchema: z.ZodNullable<z.ZodObject<{
@@ -45,6 +46,7 @@ export declare const locationSchema: z.ZodNullable<z.ZodObject<{
         };
     }>;
 }, "strip", z.ZodTypeAny, {
+    path: string;
     range: {
         start: {
             line: number;
@@ -55,8 +57,8 @@ export declare const locationSchema: z.ZodNullable<z.ZodObject<{
             character: number;
         };
     };
-    path: string;
 }, {
+    path: string;
     range: {
         start: {
             line: number;
@@ -67,7 +69,6 @@ export declare const locationSchema: z.ZodNullable<z.ZodObject<{
             character: number;
         };
     };
-    path: string;
 }>>;
 export declare const projectIdSchema: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodString, ProjectId, string>>>;
 export declare const includedInViewsSchema: z.ZodArray<z.ZodObject<{
@@ -75,13 +76,13 @@ export declare const includedInViewsSchema: z.ZodArray<z.ZodObject<{
     title: z.ZodString;
     type: z.ZodEnum<["element", "deployment", "dynamic"]>;
 }, "strip", z.ZodTypeAny, {
-    title: string;
     id: string;
-    type: "deployment" | "dynamic" | "element";
-}, {
     title: string;
+    type: "deployment" | "element" | "dynamic";
+}, {
     id: string;
-    type: "deployment" | "dynamic" | "element";
+    title: string;
+    type: "deployment" | "element" | "dynamic";
 }>, "many">;
 export declare const includedInViews: (views: Iterable<LikeC4ViewModel>) => z.infer<typeof includedInViewsSchema>;
 export declare const mkLocate: (languageServices: LikeC4LanguageServices, projectId: string) => (params: Locate.Params) => z.infer<typeof locationSchema>;