@likec4/language-server 1.44.0 → 1.45.0

package/dist/filesystem/ChokidarWatcher.d.ts

@@ -7,8 +7,10 @@ export declare const chokidarFileSystemWatcher: FileSystemWatcherModuleContext;
 export declare class ChokidarFileSystemWatcher implements FileSystemWatcher {
     protected services: LikeC4SharedServices;
     private watcher?;
+    private queue;
     constructor(services: LikeC4SharedServices);
     watch(folder: string): void;
     dispose(): Promise<void>;
     private createWatcher;
+    private enqueueFileOp;
 }

package/dist/filesystem/ChokidarWatcher.js

@@ -2,6 +2,7 @@ import { isLikeC4Config } from '@likec4/config/node';
 import { loggable } from '@likec4/log';
 import chokidar from 'chokidar';
 import { URI } from 'langium';
+import PQueue from 'p-queue';
 import { logger as mainLogger } from '../logger';
 import { isManualLayoutFile } from '../views/LikeC4ManualLayouts';
 import { isLikeC4File } from './LikeC4FileSystem';
@@ -16,6 +17,7 @@ const isAnyLikeC4File = (path) => isLikeC4File(path) || isLikeC4Config(path) ||
 export class ChokidarFileSystemWatcher {
     services;
     watcher;
+    queue = new PQueue({ concurrency: 1, timeout: 5000 });
     constructor(services) {
         this.services = services;
     }
@@ -30,8 +32,9 @@ export class ChokidarFileSystemWatcher {
     }
     async dispose() {
         if (this.watcher) {
-            await this.watcher.close();
+            const watcher = this.watcher;
             this.watcher = undefined;
+            await watcher.close();
         }
         return;
     }
@@ -41,10 +44,11 @@ export class ChokidarFileSystemWatcher {
                 path => path.includes('node_modules') || path.includes('.git'),
                 (path, stats) => (!!stats && stats.isFile() && !isAnyLikeC4File(path)),
             ],
+            followSymlinks: true,
             ignoreInitial: true,
         });
-        const onAddOrChange = async (path) => {
-            try {
+        const onAddOrChange = (path) => {
+            this.enqueueFileOp('addOrChange: ' + path, async () => {
                 if (isLikeC4Config(path)) {
                     logger.debug `project file changed: ${path}`;
                     await this.services.workspace.ProjectsManager.reloadProjects();
@@ -61,16 +65,14 @@ export class ChokidarFileSystemWatcher {
                 else {
                     logger.warn `Unknown file change: ${path}`;
                 }
-            }
-            catch (error) {
-                logger.error(loggable(error));
-            }
+            });
         };
-        const onRemove = async (path) => {
-            try {
+        const onRemove = (path) => {
+            this.enqueueFileOp('remove: ' + path, async () => {
+                const pm = this.services.workspace.ProjectsManager;
                 if (isLikeC4Config(path)) {
                     logger.debug `project file removed: ${path}`;
-                    await this.services.workspace.ProjectsManager.reloadProjects();
+                    await pm.reloadProjects();
                 }
                 else if (isLikeC4File(path)) {
                     logger.debug `file removed: ${path}`;
@@ -78,20 +80,29 @@ export class ChokidarFileSystemWatcher {
                 }
                 else if (isManualLayoutFile(path)) {
                     logger.debug `manual layout file removed: ${path}`;
-                    // TODO: optimize to only reload manual layouts instead of all projects
-                    await this.services.workspace.ProjectsManager.reloadProjects();
+                    const project = pm.belongsTo(path);
+                    await pm.rebuidProject(project);
                 }
                 else {
                     logger.warn `Unknown file removal: ${path}`;
                 }
-            }
-            catch (error) {
-                logger.error(loggable(error));
-            }
+            });
         };
         watcher.on('add', onAddOrChange)
             .on('change', onAddOrChange)
             .on('unlink', onRemove);
         return watcher;
     }
+    enqueueFileOp(fileop, fn) {
+        this.queue.add(async () => {
+            try {
+                await fn();
+            }
+            catch (error) {
+                logger.warn(`Failed on ${fileop}`, { error });
+            }
+        }).catch(error => {
+            logger.error(loggable(error));
+        });
+    }
 }

package/dist/filesystem/LikeC4FileSystem.js

@@ -4,7 +4,7 @@ import { URI } from 'langium';
 import { NodeFileSystemProvider } from 'langium/node';
 import { mkdirSync } from 'node:fs';
 import { stat, unlink, writeFile } from 'node:fs/promises';
-import { dirname } from 'node:path';
+import { basename, dirname } from 'node:path';
 import { LikeC4LanguageMetaData } from '../generated/module';
 import { Content, isLikeC4Builtin } from '../likec4lib';
 import { logger as rootLogger } from '../logger';

package/dist/index.d.ts

@@ -23,7 +23,9 @@ type StartLanguageServerOptions = {
      * Whether to enable the MCP server.
      * @default 'sse'
      */
-    enableMCP?: false | 'sse' | 'stdio';
+    enableMCP?: false | 'stdio' | 'sse' | {
+        port: number;
+    };
     /**
      * Whether to enable manual layouts, stored in json5 files.
      * @default true

package/dist/index.js

@@ -1,5 +1,6 @@
-import { configureLogger, getConsoleSink, getTextFormatter } from '@likec4/log';
+import { configureLogger, getConsoleSink, getConsoleStderrSink, getTextFormatter } from '@likec4/log';
 import { defu } from 'defu';
+import { DEV } from 'esm-env';
 import { startLanguageServer as startLanguim } from 'langium/lsp';
 import { createConnection, ProposedFeatures } from 'vscode-languageserver/node';
 import { NoopFileSystem } from './filesystem';
@@ -23,7 +24,7 @@ export function startLanguageServer(options) {
     const connection = createConnection(ProposedFeatures.all);
     configureLogger({
         sinks: {
-            console: getConsoleSink({
+            console: opts.enableMCP === 'stdio' ? getConsoleStderrSink() : getConsoleSink({
                 formatter: getTextFormatter(),
             }),
             telemetry: getTelemetrySink(connection),
@@ -32,6 +33,7 @@ export function startLanguageServer(options) {
             {
                 category: ['likec4'],
                 sinks: ['console', 'telemetry'],
+                lowestLevel: DEV ? 'trace' : 'debug',
             },
         ],
     });
@@ -40,7 +42,7 @@ export function startLanguageServer(options) {
     const services = createLanguageServices({
         connection,
         ...LikeC4FileSystem(opts.enableWatcher),
-        ...opts.enableMCP && WithMCPServer(opts.enableMCP),
+        ...!!opts.enableMCP && WithMCPServer(opts.enableMCP),
         ...opts.enableManualLayouts && WithLikeC4ManualLayouts,
     }, {
         likec4: {

package/dist/mcp/server/StdioLikeC4MCPServer.js

@@ -36,12 +36,16 @@ export class StdioLikeC4MCPServer {
         if (!this.transport) {
             return;
         }
-        logger.info('Stopping MCP stdio server');
-        await this.transport.close();
-        if (this._mcp) {
-            await this._mcp.close();
+        try {
+            logger.info('Stopping MCP stdio server');
+            await this.transport.close();
+            if (this._mcp) {
+                await this._mcp.close();
+            }
+        }
+        finally {
+            this._mcp = undefined;
+            this.transport = undefined;
         }
-        this._mcp = undefined;
-        this.transport = undefined;
     }
 }

package/dist/mcp/server/StreamableLikeC4MCPServer.js

@@ -1,10 +1,91 @@
 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';
+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) => {
+        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 });
+    });
+}
+function startServer(params) {
+    return new Promise((resolve, reject) => {
+        const { factory, port } = params;
+        const app = createHonoApp(factory);
+        const server = serve({
+            fetch: app.fetch,
+            hostname: '0.0.0.0',
+            port,
+        })
+            .prependOnceListener('error', reject)
+            .prependOnceListener('listening', () => {
+            server.removeListener('error', reject);
+            resolve(server.unref());
+        });
+    });
+}
 export class StreamableLikeC4MCPServer {
     services;
     _port;
@@ -27,107 +108,24 @@ export class StreamableLikeC4MCPServer {
         await this.stop();
     }
     async start(port = this._port) {
-        try {
-            if (this.server) {
-                if (this.port === port) {
-                    return;
-                }
-                await this.stop();
+        if (this.server) {
+            if (this.port === port) {
+                return;
             }
-            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);
+            await this.stop();
         }
+        logger.info('Starting MCP server on port {port}', { port });
+        this._port = port;
+        this.server = await startServer({
+            factory: this.services.mcp.ServerFactory,
+            port,
+        });
+        logger.info('MCP server ready at http://0.0.0.0:{port}/mcp', { port });
     }
     stop() {
         const server = this.server;
         if (!server) {
+            logger.info('MCP server is not running, nothing to stop');
             return Promise.resolve();
         }
         logger.info('Stopping MCP server');
@@ -137,7 +135,9 @@ export class StreamableLikeC4MCPServer {
                 if (err) {
                     logger.error('Failed to stop MCP server', { err });
                 }
-                logger.info('MCP server stopped');
+                else {
+                    logger.info('MCP server stopped');
+                }
                 resolve();
             });
         });

package/dist/mcp/server/WithMCPServer.js

@@ -1,4 +1,5 @@
 import { loggable } from '@likec4/log';
+import { error } from 'console';
 import { isError } from 'remeda';
 import { logger } from '../utils';
 import { StdioLikeC4MCPServer } from './StdioLikeC4MCPServer';
@@ -13,7 +14,6 @@ const streamableLikeC4MCPServer = (services, defaultPort = 33335) => {
             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();
@@ -28,15 +28,15 @@ const streamableLikeC4MCPServer = (services, defaultPort = 33335) => {
             });
         })
             .catch(err => {
-            const message = isError(err) ? err.message : undefined;
+            const message = loggable(err);
             connection?.telemetry?.logEvent({
                 eventName: 'mcp-server-start-failed',
                 mcpPort: port,
-                ...message && { message },
+                message,
             });
-            logger.error('Failed to start LikeC4 MCP Server', { err });
+            logger.warn(`Failed to start LikeC4 MCP Server: \n${message}`);
             if (connection) {
-                connection.window.showErrorMessage(`LikeC4: Failed to start MCP Server\n\n${loggable(err)}`);
+                connection.window.showErrorMessage(`LikeC4: Failed to start MCP Server\n\n${message}`);
             }
         });
     });

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

@@ -41,11 +41,11 @@ export const searchElement = likec4Tool({
 Search LikeC4 elements and deployment nodes across all projects.
 
 Query syntax (case-insensitive):
-- kind:<value>: filters by kind
-- shape:<value>: filters by shape
-- meta:<key>: filters by having metadata with the given key
-- #<value>: matches assigned tags
-- Free text: matches id (FQN) or title
+- kind:<value>  filters by kind
+- shape:<value> filters by shape
+- meta:<key>    filters by having metadata with the given key
+- #<value>      matches assigned tags
+- <value>       matches id (FQN) or title
 
 Request:
 - search: string — at least 2 characters

package/dist/mcp/utils.js

@@ -39,7 +39,7 @@ function mkcallTool(name, languageServices, cb) {
             return {
                 content: [{
                         type: 'text',
-                        text: err instanceof Error ? err.message : loggable(err),
+                        text: loggable(err),
                     }],
                 isError: true,
             };

package/dist/model/deployments-index.js

@@ -9,7 +9,7 @@ export class DeploymentsIndex extends FqnIndex {
     services;
     Names;
     constructor(services) {
-        super(services, 'deployments-index');
+        super(services);
         this.services = services;
         this.Names = services.references.NameProvider;
     }
@@ -18,7 +18,7 @@ export class DeploymentsIndex extends FqnIndex {
         if (rootNodes.length === 0) {
             return DocumentFqnIndex.EMPTY;
         }
-        const projectId = document.likec4ProjectId ??= this.projects.belongsTo(document);
+        const projectId = this.projects.belongsTo(document);
         const root = new Array();
         const children = new MultiMap();
         const descendants = new MultiMap();

package/dist/model/fqn-index.d.ts

@@ -7,12 +7,11 @@ import { ADisposable } from '../utils';
 import { type LangiumDocuments, ProjectsManager } from '../workspace';
 export declare class FqnIndex<AstNd = ast.Element> extends ADisposable {
     protected services: LikeC4Services;
-    private cachePrefix;
     protected projects: ProjectsManager;
     protected langiumDocuments: LangiumDocuments;
     protected documentCache: DefaultWeakMap<LikeC4LangiumDocument, DocumentFqnIndex>;
     protected workspaceCache: WorkspaceCache<string, AstNodeDescriptionWithFqn[]>;
-    constructor(services: LikeC4Services, cachePrefix?: string);
+    constructor(services: LikeC4Services);
     private documents;
     get(document: LikeC4LangiumDocument): DocumentFqnIndex;
     resolve(reference: ast.Referenceable): Fqn;

package/dist/model/fqn-index.js

@@ -10,22 +10,20 @@ import { readStrictFqn } from '../utils/elementRef';
 import { ProjectsManager } from '../workspace';
 export class FqnIndex extends ADisposable {
     services;
-    cachePrefix;
     projects;
     langiumDocuments;
     documentCache;
     workspaceCache;
-    constructor(services, cachePrefix = 'fqn-index') {
+    constructor(services) {
         super();
         this.services = services;
-        this.cachePrefix = cachePrefix;
         this.langiumDocuments = services.shared.workspace.LangiumDocuments;
         this.projects = services.shared.workspace.ProjectsManager;
         this.documentCache = new DefaultWeakMap(doc => this.createDocumentIndex(doc));
         this.workspaceCache = new WorkspaceCache(services.shared, DocumentState.IndexedContent);
         this.onDispose(services.shared.workspace.DocumentBuilder.onDocumentPhase(DocumentState.IndexedContent, (doc) => {
             if (isLikeC4LangiumDocument(doc)) {
-                this.documentCache.set(doc, this.createDocumentIndex(doc));
+                this.documentCache.delete(doc);
             }
         }));
     }
@@ -57,23 +55,23 @@ export class FqnIndex extends ADisposable {
         // Document index is not yet created
         const doc = AstUtils.getDocument(el);
         invariant(isLikeC4LangiumDocument(doc));
-        logWarnError(`Document ${doc.uri.path} is not indexed, but getFqn was called`);
-        // This will create the document index
+        // Ensure the document is indexed
         this.get(doc);
+        // This will create the document index
         return nonNullable(ElementOps.readId(el), 'Element fqn must be set, invalid state');
     }
     byFqn(projectId, fqn) {
-        return stream(this.workspaceCache.get(`${this.cachePrefix}:${projectId}:fqn:${fqn}`, () => {
+        return stream(this.workspaceCache.get(`${projectId}:fqn:${fqn}`, () => {
             return this
                 .documents(projectId)
-                .toArray()
                 .flatMap(doc => {
                 return this.get(doc).byFqn(fqn);
-            });
+            })
+                .toArray();
         }));
     }
     rootElements(projectId) {
-        return stream(this.workspaceCache.get(`${this.cachePrefix}:${projectId}:rootElements`, () => {
+        return stream(this.workspaceCache.get(`${projectId}:rootElements`, () => {
             const allchildren = this.documents(projectId)
                 .reduce((map, doc) => {
                 this.get(doc).rootElements().forEach(desc => {
@@ -85,7 +83,7 @@ export class FqnIndex extends ADisposable {
         }));
     }
     directChildrenOf(projectId, parent) {
-        return stream(this.workspaceCache.get(`${this.cachePrefix}:${projectId}:directChildrenOf:${parent}`, () => {
+        return stream(this.workspaceCache.get(`${projectId}:directChildrenOf:${parent}`, () => {
             const allchildren = this.documents(projectId)
                 .reduce((map, doc) => {
                 this.get(doc).children(parent).forEach(desc => {
@@ -100,7 +98,7 @@ export class FqnIndex extends ADisposable {
      * Returns descedant elements with unique names in the scope
      */
     uniqueDescedants(projectId, parent) {
-        return stream(this.workspaceCache.get(`${this.cachePrefix}:${projectId}:uniqueDescedants:${parent}`, () => {
+        return stream(this.workspaceCache.get(`${projectId}:uniqueDescedants:${parent}`, () => {
             const { children, descendants } = this.documents(projectId)
                 .reduce((map, doc) => {
                 const docIndex = this.get(doc);
@@ -129,18 +127,17 @@ export class FqnIndex extends ADisposable {
         if (rootElements.length === 0) {
             return DocumentFqnIndex.EMPTY;
         }
-        const projectId = document.likec4ProjectId ??= this.projects.belongsTo(document);
+        const projectId = document.likec4ProjectId ?? this.projects.belongsTo(document);
         const root = new Array();
         const children = new MultiMap();
         const descendants = new MultiMap();
         const byfqn = new MultiMap();
         const Descriptions = this.services.workspace.AstNodeDescriptionProvider;
         const createAndSaveDescription = (node, name, fqn) => {
-            const desc = {
-                ...Descriptions.createDescription(node, name, document),
+            const desc = Object.assign(Descriptions.createDescription(node, name, document), {
                 id: fqn,
                 likec4ProjectId: projectId,
-            };
+            });
             ElementOps.writeId(node, fqn);
             byfqn.set(fqn, desc);
             return desc;

package/dist/model/model-builder.js

@@ -132,7 +132,6 @@ export class DefaultLikeC4ModelBuilder extends ADisposable {
     unsafeSyncComputeModel(projectId, manualLayouts) {
         const logger = builderLogger.getChild(projectId);
         const cache = this.cache;
-        const viewsCache = this.cache;
         const hasManualLayouts = !!manualLayouts && !isEmpty(manualLayouts);
         const key = computedModelCacheKey(projectId) + (hasManualLayouts ? '+manualLayouts' : '');
         if (cache.has(key)) {
@@ -163,7 +162,6 @@ export class DefaultLikeC4ModelBuilder extends ADisposable {
                 const previous = this.previousViews[key];
                 const view = previous && eq(v, previous) ? previous : v;
                 this.previousViews[key] = view;
-                viewsCache.set(key, view);
                 return [v.id, view];
             });
             const data = {