@likec4/language-server 1.46.4 → 1.47.0

package/dist/index.d.ts

@@ -3,7 +3,6 @@ import { LikeC4FileSystem } from './filesystem/LikeC4FileSystem';
 import { WithMCPServer } from './mcp/server/WithMCPServer';
 import { type LikeC4Services, type LikeC4SharedServices } from './module';
 import { WithLikeC4ManualLayouts } from './views/LikeC4ManualLayouts';
-export { getLspConnectionSink, logger as lspLogger } from './logger';
 export type { DocumentParser, LikeC4ModelBuilder, LikeC4ModelLocator, LikeC4ModelParser } from './model';
 export type { LikeC4LanguageServices } from './LikeC4LanguageServices';
 export { isLikeC4Builtin } from './likec4lib';

package/dist/index.js

@@ -10,7 +10,6 @@ import { WithMCPServer } from './mcp/server/WithMCPServer';
 import { createLanguageServices } from './module';
 import { ConfigurableLayouter } from './views/ConfigurableLayouter';
 import { WithLikeC4ManualLayouts } from './views/LikeC4ManualLayouts';
-export { getLspConnectionSink, logger as lspLogger } from './logger';
 export { isLikeC4Builtin } from './likec4lib';
 export { createLanguageServices } from './module';
 export { LikeC4FileSystem, NoopFileSystem, WithMCPServer };

package/dist/lsp/CodeLensProvider.js

@@ -11,7 +11,7 @@ export class LikeC4CodeLensProvider {
         if (!isLikeC4LangiumDocument(doc)) {
             return;
         }
-        if (doc.state <= DocumentState.Linked) {
+        if (doc.state < DocumentState.Linked) {
             logger.debug(`Waiting for document ${doc.uri.path} to be Linked`);
             await this.services.shared.workspace.DocumentBuilder.waitUntil(DocumentState.Linked, doc.uri, cancelToken);
             logger.debug(`Document is linked`);

package/dist/lsp/CompletionProvider.d.ts

@@ -1,5 +1,5 @@
-import { type GrammarAST, type MaybePromise } from 'langium';
-import { type CompletionAcceptor, type CompletionContext, DefaultCompletionProvider } from 'langium/lsp';
+import { type MaybePromise, GrammarAST } from 'langium';
+import { type CompletionAcceptor, type CompletionContext, type NextFeature, DefaultCompletionProvider } from 'langium/lsp';
 import type { LikeC4Services } from '../module';
 export declare class LikeC4CompletionProvider extends DefaultCompletionProvider {
     protected services: LikeC4Services;
@@ -7,5 +7,7 @@ export declare class LikeC4CompletionProvider extends DefaultCompletionProvider
     readonly completionOptions: {
         triggerCharacters: string[];
     };
+    protected completionFor(context: CompletionContext, next: NextFeature, acceptor: CompletionAcceptor): MaybePromise<void>;
     protected completionForKeyword(context: CompletionContext, keyword: GrammarAST.Keyword, acceptor: CompletionAcceptor): MaybePromise<void>;
+    protected completionForImportedProject(context: CompletionContext, acceptor: CompletionAcceptor): void;
 }

package/dist/lsp/CompletionProvider.js

@@ -1,8 +1,8 @@
 import { ThemeColors } from '@likec4/core/styles';
-import { AstUtils } from 'langium';
+import { AstUtils, GrammarAST } from 'langium';
 import { DefaultCompletionProvider, } from 'langium/lsp';
-import { anyPass } from 'remeda';
-import { CompletionItemKind, InsertTextFormat } from 'vscode-languageserver-types';
+import { anyPass, isEmpty } from 'remeda';
+import { CompletionItemKind, InsertTextFormat, TextEdit } from 'vscode-languageserver-types';
 import { ast } from '../ast';
 const STYLE_FIELDS = [
     'color',
@@ -14,6 +14,11 @@ const STYLE_FIELDS = [
     'size',
     'textSize',
 ].join(',');
+function isCompletionForPojectName(context, next) {
+    return GrammarAST.isRuleCall(next.feature)
+        && next.property === 'project'
+        && ast.isImportsFromPoject(context.node);
+}
 export class LikeC4CompletionProvider extends DefaultCompletionProvider {
     services;
     constructor(services) {
@@ -23,6 +28,16 @@ export class LikeC4CompletionProvider extends DefaultCompletionProvider {
     completionOptions = {
         triggerCharacters: ['.', '#'],
     };
+    completionFor(context, next, acceptor) {
+        switch (true) {
+            case GrammarAST.isKeyword(next.feature):
+                return this.completionForKeyword(context, next.feature, acceptor);
+            case GrammarAST.isCrossReference(next.feature) && !!context.node:
+                return this.completionForCrossReference(context, next, acceptor);
+            case isCompletionForPojectName(context, next):
+                return this.completionForImportedProject(context, acceptor);
+        }
+    }
     completionForKeyword(context, keyword, acceptor) {
         if (!this.filterKeyword(context, keyword)) {
             return;
@@ -197,4 +212,27 @@ export class LikeC4CompletionProvider extends DefaultCompletionProvider {
                 });
         }
     }
+    completionForImportedProject(context, acceptor) {
+        const projectsManager = this.services.shared.workspace.ProjectsManager;
+        const txtDoc = context.document.textDocument;
+        const range = {
+            start: txtDoc.positionAt(context.tokenOffset),
+            end: txtDoc.positionAt(context.tokenEndOffset),
+        };
+        const txt = txtDoc.getText(range);
+        // What is the current character used for quoting
+        const currentQuote = isEmpty(txt) ? `'` : txt.substring(0, 1);
+        for (const projectId of projectsManager.all) {
+            const insertText = currentQuote + projectId + currentQuote;
+            acceptor(context, {
+                label: projectId,
+                kind: CompletionItemKind.Folder,
+                insertText,
+                filterText: insertText,
+                textEdit: TextEdit.replace(range, insertText),
+                detail: 'Project',
+                sortText: '0_' + projectId,
+            });
+        }
+    }
 }

package/dist/lsp/DocumentSymbolProvider.js

@@ -29,7 +29,7 @@ export class LikeC4DocumentSymbolProvider {
         if (!isLikeC4LangiumDocument(doc) || this.services.shared.workspace.ProjectsManager.isExcluded(doc)) {
             return [];
         }
-        if (doc.state <= DocumentState.Linked) {
+        if (doc.state < DocumentState.Linked) {
             logger.debug(`Waiting for document ${doc.uri.path} to be Linked`);
             await this.services.shared.workspace.DocumentBuilder.waitUntil(DocumentState.Linked, doc.uri, cancelToken);
             logger.debug(`document is Linked`);

package/dist/lsp/SemanticTokenProvider.d.ts

@@ -1,10 +1,17 @@
-import type { AstNode } from 'langium';
+import { type AstNode, type LangiumDocument } from 'langium';
 import { type SemanticTokenAcceptor, AbstractSemanticTokenProvider } from 'langium/lsp';
+import { type SemanticTokensDeltaParams, type SemanticTokensParams, type SemanticTokensRangeParams, CancellationToken } from 'vscode-languageserver-protocol';
+import { type SemanticTokens, type SemanticTokensDelta } from 'vscode-languageserver-types';
 import type { LikeC4Services } from '../module';
 export declare class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
+    protected services: LikeC4Services;
     private rules;
     constructor(services: LikeC4Services);
     protected initRules(): void;
+    semanticHighlight(document: LangiumDocument, params: SemanticTokensParams, cancelToken?: CancellationToken): Promise<SemanticTokens>;
+    semanticHighlightRange(document: LangiumDocument, params: SemanticTokensRangeParams, cancelToken?: CancellationToken): Promise<SemanticTokens>;
+    semanticHighlightDelta(document: LangiumDocument, params: SemanticTokensDeltaParams, cancelToken?: CancellationToken): Promise<SemanticTokens | SemanticTokensDelta>;
+    protected ensureState(document: LangiumDocument, cancelToken: CancellationToken): Promise<void>;
     protected highlightElement(node: AstNode, acceptor: SemanticTokenAcceptor): void | undefined | 'prune';
     private highlightNameAndKind;
     private highlightView;

package/dist/lsp/SemanticTokenProvider.js

@@ -1,9 +1,12 @@
 import { isAnyOf, nonNullable } from '@likec4/core/utils';
+import { DocumentState } from 'langium';
 import { AbstractSemanticTokenProvider, } from 'langium/lsp';
 import { isTruthy } from 'remeda';
-import { SemanticTokenModifiers, SemanticTokenTypes } from 'vscode-languageserver-types';
+import { CancellationToken, } from 'vscode-languageserver-protocol';
+import { SemanticTokenModifiers, SemanticTokenTypes, } from 'vscode-languageserver-types';
 import { ast } from '../ast';
-import { logger } from '../logger';
+import { logger as rootLogger } from '../logger';
+const logger = rootLogger.getChild('SemanticTokenProvider');
 const SemanticTypes = { ...SemanticTokenTypes };
 const SemanticModifiers = { ...SemanticTokenModifiers };
 function createSemanticTypeMethods(applyHighlight) {
@@ -36,9 +39,11 @@ const stopHighlight = () => {
     throw PRUNE;
 };
 export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
+    services;
     rules = [];
     constructor(services) {
         super(services);
+        this.services = services;
         this.initRules();
     }
     initRules() {
@@ -61,10 +66,21 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
             mark.property('value').readonly.definition.interface();
             stopHighlight();
         });
-        when(isAnyOf(ast.isFqnRefExpr, ast.isWildcardExpression), mark => {
+        when(ast.isWildcardExpression, mark => {
             mark.cst().readonly.definition.variable();
             stopHighlight();
         });
+        when(ast.isFqnRefExpr, mark => {
+            if (!mark.node.selector) {
+                return;
+            }
+            if (mark.node.ref.parent) {
+                mark.property('selector').property();
+            }
+            else {
+                mark.property('selector').readonly.definition.variable();
+            }
+        });
         when(ast.isTagRef, mark => {
             mark.cst().type();
             stopHighlight();
@@ -109,22 +125,22 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
             }
         });
         when(isAnyOf(ast.isFqnRef, ast.isStrictFqnRef), mark => {
-            const text = mark.node.$cstNode?.text ?? '';
-            if (text !== '' && text !== 'this' && text !== 'it') {
-                mark.property('value').readonly.definition.variable();
-            }
             if (!mark.node.parent) {
+                mark.property('value').readonly.definition.variable();
                 stopHighlight();
             }
+            else {
+                mark.property('value').property();
+            }
         });
         when(ast.isStrictFqnElementRef, mark => {
-            const text = mark.node.el.$refText ?? '';
-            if (text !== '') {
-                mark.property('el').readonly.definition.variable();
-            }
             if (!mark.node.parent) {
+                mark.property('el').readonly.definition.variable();
                 stopHighlight();
             }
+            else {
+                mark.property('el').property();
+            }
         });
         when(ast.isSpecificationColor, mark => {
             mark.keyword('color').keyword();
@@ -170,6 +186,31 @@ export class LikeC4SemanticTokenProvider extends AbstractSemanticTokenProvider {
             }
         });
     }
+    async semanticHighlight(document, params, cancelToken = CancellationToken.None) {
+        if (document.state < DocumentState.Linked) {
+            await this.ensureState(document, cancelToken);
+        }
+        return await super.semanticHighlight(document, params, cancelToken);
+    }
+    async semanticHighlightRange(document, params, cancelToken = CancellationToken.None) {
+        if (document.state < DocumentState.Linked) {
+            await this.ensureState(document, cancelToken);
+        }
+        return await super.semanticHighlightRange(document, params, cancelToken);
+    }
+    async semanticHighlightDelta(document, params, cancelToken = CancellationToken.None) {
+        if (document.state < DocumentState.Linked) {
+            await this.ensureState(document, cancelToken);
+        }
+        return await super.semanticHighlightDelta(document, params, cancelToken);
+    }
+    async ensureState(document, cancelToken) {
+        if (document.state < DocumentState.Linked) {
+            logger.debug `waiting for document ${document.uri.path} to be ${'Linked'}`;
+            await this.services.shared.workspace.DocumentBuilder.waitUntil(DocumentState.Linked, document.uri, cancelToken);
+            logger.debug `document ${document.uri.path} is ${'Linked'}`;
+        }
+    }
     highlightElement(node, acceptor) {
         if (isAnyOf(ast.isElement, ast.isDeploymentNode, ast.isDeployedInstance)(node)) {
             return this.highlightNameAndKind(node);

package/dist/mcp/interfaces.d.ts

@@ -1,4 +1,4 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { LikeC4Services } from '../module';
 export interface LikeC4MCPServer {
     readonly mcp: McpServer;

package/dist/mcp/interfaces.js

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

package/dist/mcp/server/StreamableLikeC4MCPServer.js

@@ -1,53 +1,27 @@
 import { serve } from '@hono/node-server';
 import { loggable } from '@likec4/log';
-import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
-import { toFetchResponse, toReqRes } from 'fetch-to-node';
+import { WebStandardStreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js';
 import { Hono } from 'hono';
+import { cors } from 'hono/cors';
+import { nanoid } from 'nanoid';
 import { logger } from '../utils';
-function createHonoApp(factory) {
-    return new Hono()
-        .post('/mcp', async (c) => {
-        const { req, res } = toReqRes(c.req.raw);
-        const mcp = factory.create();
-        try {
-            const transport = new StreamableHTTPServerTransport({
-                sessionIdGenerator: undefined,
-            });
-            // Added for extra debuggability
-            transport.onerror = (err) => {
-                logger.error(loggable(err));
-            };
-            await mcp.connect(transport);
-            await transport.handleRequest(req, res, await c.req.json());
-            res.on('close', async () => {
-                await transport.close();
-                await mcp.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 });
-        }
-    })
-        .all('/mcp', async (c) => {
-        return c.json({
-            jsonrpc: '2.0',
-            error: {
-                code: -32000,
-                message: 'Method not allowed.',
-            },
-            id: null,
-        }, { status: 405 });
-    })
-        .notFound((c) => {
+async function createHonoApp(factory) {
+    const mcp = factory.create();
+    const transport = new WebStandardStreamableHTTPServerTransport({
+        sessionIdGenerator: () => nanoid(),
+    });
+    const app = new Hono();
+    // Enable CORS for all origins
+    app.use('*', cors({
+        origin: '*',
+        allowHeaders: ['Content-Type', 'mcp-session-id', 'Last-Event-ID', 'mcp-protocol-version'],
+        exposeHeaders: ['mcp-session-id', 'mcp-protocol-version'],
+    }));
+    // Health check endpoint
+    app.get('/health', c => c.json({ status: 'ok' }));
+    // MCP endpoint
+    app.all('/mcp', c => transport.handleRequest(c.req.raw));
+    app.notFound((c) => {
         logger.debug(`${c.req.method} ${c.req.url} not found`);
         return c.json({
             jsonrpc: '2.0',
@@ -57,8 +31,8 @@ function createHonoApp(factory) {
             },
             id: null,
         }, { status: 404 });
-    })
-        .onError((e, c) => {
+    });
+    app.onError((e, c) => {
         logger.error(loggable(e));
         return c.json({
             jsonrpc: '2.0',
@@ -69,11 +43,13 @@ function createHonoApp(factory) {
             id: null,
         }, { status: 500 });
     });
+    await mcp.connect(transport);
+    return app;
 }
-function startServer(params) {
+async function startServer(params) {
+    const { factory, port } = params;
+    const app = await createHonoApp(factory);
     return new Promise((resolve, reject) => {
-        const { factory, port } = params;
-        const app = createHonoApp(factory);
         const server = serve({
             fetch: app.fetch,
             hostname: '0.0.0.0',

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

@@ -76,13 +76,13 @@ export declare const includedInViewsSchema: z.ZodArray<z.ZodObject<{
     title: z.ZodString;
     type: z.ZodEnum<["element", "deployment", "dynamic"]>;
 }, "strip", z.ZodTypeAny, {
+    type: "element" | "deployment" | "dynamic";
     id: string;
     title: string;
-    type: "deployment" | "element" | "dynamic";
 }, {
+    type: "element" | "deployment" | "dynamic";
     id: string;
     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>;

package/dist/mcp/tools/find-relationships.d.ts

@@ -5,8 +5,198 @@ export declare const findRelationships: (languageServices: import("../..").LikeC
         element2: z.ZodString;
         project: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodString, import("@likec4/core").ProjectId, string>>>;
     };
-}, (args: {
-    project: string & import("type-fest/source/tagged").Tag<"ProjectID", never>;
-    element1: string;
-    element2: string;
-}, extra: import("@modelcontextprotocol/sdk/shared/protocol.js").RequestHandlerExtra<import("@modelcontextprotocol/sdk/types.js").ServerRequest, import("@modelcontextprotocol/sdk/types.js").ServerNotification>) => import("@modelcontextprotocol/sdk/types.js").CallToolResult | Promise<import("@modelcontextprotocol/sdk/types.js").CallToolResult>];
+}, (args: import("@modelcontextprotocol/sdk/server/zod-compat.js").ShapeOutput<{
+    element1: z.ZodString;
+    element2: z.ZodString;
+    project: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodString, import("@likec4/core").ProjectId, string>>>;
+}>, extra: import("@modelcontextprotocol/sdk/shared/protocol.js").RequestHandlerExtra<import("@modelcontextprotocol/sdk/types.js").ServerRequest, import("@modelcontextprotocol/sdk/types.js").ServerNotification>) => {
+    [x: string]: unknown;
+    content: ({
+        type: "text";
+        text: string;
+        annotations?: {
+            audience?: ("user" | "assistant")[] | undefined;
+            priority?: number | undefined;
+            lastModified?: string | undefined;
+        } | undefined;
+        _meta?: {
+            [x: string]: unknown;
+        } | undefined;
+    } | {
+        type: "image";
+        data: string;
+        mimeType: string;
+        annotations?: {
+            audience?: ("user" | "assistant")[] | undefined;
+            priority?: number | undefined;
+            lastModified?: string | undefined;
+        } | undefined;
+        _meta?: {
+            [x: string]: unknown;
+        } | undefined;
+    } | {
+        type: "audio";
+        data: string;
+        mimeType: string;
+        annotations?: {
+            audience?: ("user" | "assistant")[] | undefined;
+            priority?: number | undefined;
+            lastModified?: string | undefined;
+        } | undefined;
+        _meta?: {
+            [x: string]: unknown;
+        } | undefined;
+    } | {
+        uri: string;
+        name: string;
+        type: "resource_link";
+        description?: string | undefined;
+        mimeType?: string | undefined;
+        annotations?: {
+            audience?: ("user" | "assistant")[] | undefined;
+            priority?: number | undefined;
+            lastModified?: string | undefined;
+        } | undefined;
+        _meta?: {
+            [x: string]: unknown;
+        } | undefined;
+        icons?: {
+            src: string;
+            mimeType?: string | undefined;
+            sizes?: string[] | undefined;
+            theme?: "light" | "dark" | undefined;
+        }[] | undefined;
+        title?: string | undefined;
+    } | {
+        type: "resource";
+        resource: {
+            uri: string;
+            text: string;
+            mimeType?: string | undefined;
+            _meta?: {
+                [x: string]: unknown;
+            } | undefined;
+        } | {
+            uri: string;
+            blob: string;
+            mimeType?: string | undefined;
+            _meta?: {
+                [x: string]: unknown;
+            } | undefined;
+        };
+        annotations?: {
+            audience?: ("user" | "assistant")[] | undefined;
+            priority?: number | undefined;
+            lastModified?: string | undefined;
+        } | undefined;
+        _meta?: {
+            [x: string]: unknown;
+        } | undefined;
+    })[];
+    _meta?: {
+        [x: string]: unknown;
+        progressToken?: string | number | undefined;
+        "io.modelcontextprotocol/related-task"?: {
+            taskId: string;
+        } | undefined;
+    } | undefined;
+    structuredContent?: {
+        [x: string]: unknown;
+    } | undefined;
+    isError?: boolean | undefined;
+} | Promise<{
+    [x: string]: unknown;
+    content: ({
+        type: "text";
+        text: string;
+        annotations?: {
+            audience?: ("user" | "assistant")[] | undefined;
+            priority?: number | undefined;
+            lastModified?: string | undefined;
+        } | undefined;
+        _meta?: {
+            [x: string]: unknown;
+        } | undefined;
+    } | {
+        type: "image";
+        data: string;
+        mimeType: string;
+        annotations?: {
+            audience?: ("user" | "assistant")[] | undefined;
+            priority?: number | undefined;
+            lastModified?: string | undefined;
+        } | undefined;
+        _meta?: {
+            [x: string]: unknown;
+        } | undefined;
+    } | {
+        type: "audio";
+        data: string;
+        mimeType: string;
+        annotations?: {
+            audience?: ("user" | "assistant")[] | undefined;
+            priority?: number | undefined;
+            lastModified?: string | undefined;
+        } | undefined;
+        _meta?: {
+            [x: string]: unknown;
+        } | undefined;
+    } | {
+        uri: string;
+        name: string;
+        type: "resource_link";
+        description?: string | undefined;
+        mimeType?: string | undefined;
+        annotations?: {
+            audience?: ("user" | "assistant")[] | undefined;
+            priority?: number | undefined;
+            lastModified?: string | undefined;
+        } | undefined;
+        _meta?: {
+            [x: string]: unknown;
+        } | undefined;
+        icons?: {
+            src: string;
+            mimeType?: string | undefined;
+            sizes?: string[] | undefined;
+            theme?: "light" | "dark" | undefined;
+        }[] | undefined;
+        title?: string | undefined;
+    } | {
+        type: "resource";
+        resource: {
+            uri: string;
+            text: string;
+            mimeType?: string | undefined;
+            _meta?: {
+                [x: string]: unknown;
+            } | undefined;
+        } | {
+            uri: string;
+            blob: string;
+            mimeType?: string | undefined;
+            _meta?: {
+                [x: string]: unknown;
+            } | undefined;
+        };
+        annotations?: {
+            audience?: ("user" | "assistant")[] | undefined;
+            priority?: number | undefined;
+            lastModified?: string | undefined;
+        } | undefined;
+        _meta?: {
+            [x: string]: unknown;
+        } | undefined;
+    })[];
+    _meta?: {
+        [x: string]: unknown;
+        progressToken?: string | number | undefined;
+        "io.modelcontextprotocol/related-task"?: {
+            taskId: string;
+        } | undefined;
+    } | undefined;
+    structuredContent?: {
+        [x: string]: unknown;
+    } | undefined;
+    isError?: boolean | undefined;
+}>];