@likec4/language-server 1.37.0 → 1.38.1

package/dist/empty.d.ts

@@ -0,0 +1,2 @@
+declare const _default: {};
+export default _default;

package/dist/empty.js

@@ -0,0 +1 @@
+export default {};

package/dist/filesystem/ChokidarWatcher.d.ts

@@ -0,0 +1,14 @@
+import type { LikeC4SharedServices } from '../module';
+import type { FileSystemWatcher, FileSystemWatcherModuleContext } from './FileSystemWatcher';
+export declare const chokidarFileSystemWatcher: FileSystemWatcherModuleContext;
+/**
+ * A no-op file system watcher.
+ */
+export declare class ChokidarFileSystemWatcher implements FileSystemWatcher {
+    protected services: LikeC4SharedServices;
+    private watcher?;
+    constructor(services: LikeC4SharedServices);
+    watch(folder: string): void;
+    dispose(): Promise<void>;
+    private createWatcher;
+}

package/dist/filesystem/ChokidarWatcher.js

@@ -0,0 +1,64 @@
+import { loggable } from "@likec4/log";
+import chokidar from "chokidar";
+import { URI } from "langium";
+import { logger as mainLogger } from "../logger.js";
+import { isAnyLikeC4File, isLikeC4ProjectFile } from "./LikeC4FileSystem.js";
+const logger = mainLogger.getChild("chokidar");
+export const chokidarFileSystemWatcher = {
+  fileSystemWatcher: (services) => new ChokidarFileSystemWatcher(services)
+};
+export class ChokidarFileSystemWatcher {
+  constructor(services) {
+    this.services = services;
+  }
+  watcher;
+  watch(folder) {
+    if (this.watcher) {
+      this.watcher.add(folder);
+    } else {
+      this.watcher = this.createWatcher(folder);
+    }
+    logger.debug(`watching folder: ${folder}`);
+  }
+  async dispose() {
+    if (this.watcher) {
+      await this.watcher.close();
+      this.watcher = void 0;
+    }
+    return;
+  }
+  createWatcher(folder) {
+    let watcher = chokidar.watch(folder, {
+      ignored: (path, stats) => path.includes("node_modules") || !!stats && stats.isFile() && !isAnyLikeC4File(path),
+      ignoreInitial: true
+    });
+    const onAddOrChange = async (path) => {
+      try {
+        if (isLikeC4ProjectFile(path)) {
+          logger.debug(`project file changed: ${path}`);
+          await this.services.workspace.ProjectsManager.reloadProjects();
+        } else {
+          logger.debug(`file changed: ${path}`);
+          await this.services.workspace.DocumentBuilder.update([URI.file(path)], []);
+        }
+      } catch (error) {
+        logger.error(loggable(error));
+      }
+    };
+    const onRemove = async (path) => {
+      try {
+        if (isLikeC4ProjectFile(path)) {
+          logger.debug(`project file removed: ${path}`);
+          await this.services.workspace.ProjectsManager.reloadProjects();
+        } else {
+          logger.debug(`file removed: ${path}`);
+          await this.services.workspace.DocumentBuilder.update([], [URI.file(path)]);
+        }
+      } catch (error) {
+        logger.error(loggable(error));
+      }
+    };
+    watcher.on("add", onAddOrChange).on("change", onAddOrChange).on("unlink", onRemove);
+    return watcher;
+  }
+}

package/dist/filesystem/FileSystemWatcher.d.ts

@@ -0,0 +1,19 @@
+import { type AsyncDisposable } from 'langium';
+import { type LikeC4SharedServices } from '../module';
+export interface FileSystemWatcherModuleContext {
+    fileSystemWatcher: (services: LikeC4SharedServices) => FileSystemWatcher;
+}
+export declare const noopFileSystemWatcher: FileSystemWatcherModuleContext;
+export interface FileSystemWatcher extends AsyncDisposable {
+    /**
+     * Watches a folder for changes and triggers a reload of the documents and projects.
+     */
+    watch(folder: string): void;
+}
+/**
+ * A no-op file system watcher.
+ */
+export declare class NoopFileSystemWatcher implements FileSystemWatcher {
+    watch(): void;
+    dispose(): Promise<void>;
+}

package/dist/filesystem/FileSystemWatcher.js

@@ -0,0 +1,11 @@
+export const noopFileSystemWatcher = {
+  fileSystemWatcher: () => new NoopFileSystemWatcher()
+};
+export class NoopFileSystemWatcher {
+  watch() {
+    return;
+  }
+  dispose() {
+    return Promise.resolve();
+  }
+}

package/dist/filesystem/LikeC4FileSystem.d.ts

@@ -0,0 +1,5 @@
+import type { FileSystemModuleContext } from './index';
+export declare const LikeC4FileSystem: (ehableWatcher?: boolean) => FileSystemModuleContext;
+export declare const isLikeC4ProjectFile: (path: string) => boolean;
+export declare const isLikeC4File: (path: string) => any;
+export declare const isAnyLikeC4File: (path: string) => any;

package/dist/filesystem/LikeC4FileSystem.js

@@ -0,0 +1,56 @@
+import { fdir } from "fdir";
+import { URI } from "langium";
+import { NodeFileSystemProvider } from "langium/node";
+import { LikeC4LanguageMetaData } from "../generated/module.js";
+import { Content, isLikeC4Builtin } from "../likec4lib.js";
+import { logError } from "../logger.js";
+import { ProjectsManager } from "../workspace/ProjectsManager.js";
+import { chokidarFileSystemWatcher } from "./ChokidarWatcher.js";
+import { noopFileSystemWatcher } from "./FileSystemWatcher.js";
+export const LikeC4FileSystem = (ehableWatcher = true) => ({
+  fileSystemProvider: () => new SymLinkTraversingFileSystemProvider(),
+  ...ehableWatcher ? chokidarFileSystemWatcher : noopFileSystemWatcher
+});
+export const isLikeC4ProjectFile = (path) => ProjectsManager.ConfigFileNames.some((ext) => path.endsWith(ext));
+export const isLikeC4File = (path) => LikeC4LanguageMetaData.fileExtensions.some((ext) => path.endsWith(ext));
+export const isAnyLikeC4File = (path) => isLikeC4File(path) || isLikeC4ProjectFile(path);
+class SymLinkTraversingFileSystemProvider extends NodeFileSystemProvider {
+  async readFile(uri) {
+    if (isLikeC4Builtin(uri)) {
+      return Promise.resolve(Content);
+    }
+    return await super.readFile(uri);
+  }
+  async readDirectory(folderPath) {
+    const entries = [];
+    try {
+      const crawled = await new fdir().withSymlinks({ resolvePaths: false }).withFullPaths().filter(isLikeC4File).crawl(folderPath.fsPath).withPromise();
+      for (const path of crawled) {
+        entries.push({
+          isFile: true,
+          isDirectory: false,
+          uri: URI.file(path)
+        });
+      }
+    } catch (error) {
+      logError(error);
+    }
+    return entries;
+  }
+  async scanProjectFiles(folderUri) {
+    const entries = [];
+    try {
+      const crawled = await new fdir().withSymlinks({ resolvePaths: false }).withFullPaths().filter(isLikeC4ProjectFile).crawl(folderUri.fsPath).withPromise();
+      for (const path of crawled) {
+        entries.push({
+          isFile: true,
+          isDirectory: false,
+          uri: URI.file(path)
+        });
+      }
+    } catch (error) {
+      logError(error);
+    }
+    return entries;
+  }
+}

package/dist/filesystem/index.d.ts

@@ -0,0 +1,20 @@
+import type { FileSystemNode, FileSystemProvider as LangiumFileSystemProvider, LangiumSharedCoreServices } from 'langium';
+import { URI } from 'vscode-uri';
+import { type FileSystemWatcherModuleContext } from './FileSystemWatcher';
+export type { FileSystemWatcher } from './FileSystemWatcher';
+export interface FileSystemProvider extends LangiumFileSystemProvider {
+    /**
+     * Scans the project files for the given URI.
+     * @returns The list of file system entries that are contained within the specified directory.
+     */
+    scanProjectFiles(folderUri: URI): Promise<FileSystemNode[]>;
+}
+export interface FileSystemModuleContext extends FileSystemWatcherModuleContext {
+    fileSystemProvider: (services: LangiumSharedCoreServices) => FileSystemProvider;
+}
+export declare class NoopFileSystemProvider implements FileSystemProvider {
+    scanProjectFiles(): Promise<FileSystemNode[]>;
+    readFile(): Promise<string>;
+    readDirectory(): Promise<FileSystemNode[]>;
+}
+export declare const NoopFileSystem: FileSystemModuleContext;

package/dist/filesystem/index.js

@@ -0,0 +1,16 @@
+import { noopFileSystemWatcher } from "./FileSystemWatcher.js";
+export class NoopFileSystemProvider {
+  scanProjectFiles() {
+    return Promise.resolve([]);
+  }
+  readFile() {
+    throw new Error("No file system is available.");
+  }
+  readDirectory() {
+    return Promise.resolve([]);
+  }
+}
+export const NoopFileSystem = {
+  fileSystemProvider: () => new NoopFileSystemProvider(),
+  ...noopFileSystemWatcher
+};

package/dist/index.d.ts

@@ -1,14 +1,28 @@
-import { LikeC4FileSystem } from './LikeC4FileSystem';
+import { NoopFileSystem } from './filesystem';
+import { LikeC4FileSystem } from './filesystem/LikeC4FileSystem';
+import { WithMCPServer } from './mcp/server/WithMCPServer';
 import { type LikeC4Services, type LikeC4SharedServices } from './module';
 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 { createCustomLanguageServices, createLanguageServices, LikeC4Module } from './module';
+export { createLanguageServices } from './module';
 export type { LikeC4Services, LikeC4SharedServices } from './module';
 export type { LikeC4Views } from './views';
-export { LikeC4FileSystem };
-export declare function startLanguageServer(): {
+export { LikeC4FileSystem, NoopFileSystem, WithMCPServer };
+type StartLanguageServerOptions = {
+    /**
+     * Whether to enable the file system watcher.
+     * @default true
+     */
+    enableWatcher?: boolean;
+    /**
+     * Whether to enable the MCP server.
+     * @default 'sse'
+     */
+    enableMCP?: false | 'sse' | 'stdio';
+};
+export declare function startLanguageServer(options?: StartLanguageServerOptions): {
     shared: LikeC4SharedServices;
     likec4: LikeC4Services;
 };

package/dist/index.js

@@ -1,16 +1,22 @@
 import { configureLogger, getConsoleSink, getTextFormatter } from "@likec4/log";
+import { defu } from "defu";
 import { startLanguageServer as startLanguim } from "langium/lsp";
 import { createConnection, ProposedFeatures } from "vscode-languageserver/node";
-import { LikeC4FileSystem } from "./LikeC4FileSystem.js";
+import { NoopFileSystem } from "./filesystem/index.js";
+import { LikeC4FileSystem } from "./filesystem/LikeC4FileSystem.js";
 import { getTelemetrySink, logger } from "./logger.js";
-import { WithMCPServer } from "./mcp/sseserver/WithMCPServer.js";
-import { createCustomLanguageServices } from "./module.js";
+import { WithMCPServer } from "./mcp/server/WithMCPServer.js";
+import { createLanguageServices } from "./module.js";
 import { ConfigurableLayouter } from "./views/configurable-layouter.js";
 export { getLspConnectionSink, logger as lspLogger } from "./logger.js";
 export { isLikeC4Builtin } from "./likec4lib.js";
-export { createCustomLanguageServices, createLanguageServices, LikeC4Module } from "./module.js";
-export { LikeC4FileSystem };
-export function startLanguageServer() {
+export { createLanguageServices } from "./module.js";
+export { LikeC4FileSystem, NoopFileSystem, WithMCPServer };
+export function startLanguageServer(options) {
+  const opts = defu(options, {
+    enableWatcher: true,
+    enableMCP: "sse"
+  });
   const connection = createConnection(ProposedFeatures.all);
   configureLogger({
     sinks: {
@@ -27,10 +33,17 @@ export function startLanguageServer() {
     ]
   });
   logger.info("Starting LikeC4 language server");
-  const services = createCustomLanguageServices(
-    { connection, ...LikeC4FileSystem },
-    ConfigurableLayouter,
-    WithMCPServer
+  const services = createLanguageServices(
+    {
+      connection,
+      ...LikeC4FileSystem(opts.enableWatcher),
+      ...opts.enableMCP && WithMCPServer(opts.enableMCP)
+    },
+    {
+      likec4: {
+        ...ConfigurableLayouter.likec4
+      }
+    }
   );
   startLanguim(services.shared);
   return services;

package/dist/mcp/{sseserver/MCPServerFactory.d.ts → MCPServerFactory.d.ts}

@@ -1,6 +1,6 @@
 import type { ServerOptions } from '@modelcontextprotocol/sdk/server/index.js';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import type { LikeC4Services } from '../../module';
+import type { LikeC4Services } from '../module';
 export declare class LikeC4MCPServerFactory {
     private services;
     constructor(services: LikeC4Services);

package/dist/mcp/MCPServerFactory.js

@@ -0,0 +1,69 @@
+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.js";
+import { findRelationships } from "./tools/find-relationships.js";
+import { listProjects } from "./tools/list-projects.js";
+import { openView } from "./tools/open-view.js";
+import { readDeployment } from "./tools/read-deployment.js";
+import { readElement } from "./tools/read-element.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 isInEditor = this.services.shared.lsp.Connection !== void 0;
+    const mcp = new McpServer({
+      name: "LikeC4",
+      version: packageJson.version
+    }, {
+      instructions: `LikeC4 MCP \u2013 query and navigate LikeC4 models.
+
+Conventions:
+- All tools are read-only and idempotent.
+- "project" is optional and defaults to "default".
+
+Available tools:
+- list-projects \u2014 List all LikeC4 projects in the workspace.
+- read-project-summary \u2014 Project specification (element kinds, deployment node kinds, tags, metadata keys), all elements, deployment nodes and views. Input: { project? }.
+- search-element \u2014 Search elements and deployment nodes across all projects by id/title/kind/shape/tags. Input: { search }.
+- read-element \u2014 Full element details including relationships, includedInViews, deployedInstances, and sourceLocation. Input: { id, project? }.
+- read-deployment \u2014 Details of a deployment node or deployed instance. Input: { id, project? }.
+- read-view \u2014 Full view details (nodes/edges) and sourceLocation. Input: { viewId, project? }.
+- find-relationships \u2014 Direct and indirect relationships between two elements in a project. Input: { element1, element2, project? }.
+${isInEditor ? "- open-view \u2014 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 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 resource returns "sourceLocation", provide link to this location in the editor
+
+Docs: https://likec4.dev/llms-full.txt
+`,
+      ...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.d.ts

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

package/dist/mcp/NoopLikeC4MCPServer.js

@@ -1,4 +1,7 @@
 export class NoopLikeC4MCPServer {
+  get mcp() {
+    throw new Error("NoopLikeC4MCPServer does not have a McpServer");
+  }
   get isStarted() {
     return false;
   }
@@ -6,17 +9,9 @@ export class NoopLikeC4MCPServer {
     return NaN;
   }
   start(port) {
-    return Promise.reject(new Error("Not implemented"));
+    return Promise.resolve();
   }
   stop() {
-    return Promise.reject(new Error("Not implemented"));
-  }
-}
-export class NoopLikeC4MCPServerFactory {
-  constructor(services) {
-    this.services = services;
-  }
-  create(options) {
-    throw new Error("NoopLikeC4MCPServerFactory - switch to implementation");
+    return Promise.resolve();
   }
 }

package/dist/mcp/interfaces.d.ts

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

package/dist/mcp/interfaces.js

@@ -0,0 +1,4 @@
+import { NoopLikeC4MCPServer } from "./NoopLikeC4MCPServer.js";
+export const NoMCPServer = {
+  mcpServer: () => new NoopLikeC4MCPServer()
+};

package/dist/mcp/server/StdioLikeC4MCPServer.d.ts

@@ -0,0 +1,16 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { AsyncDisposable } from 'langium';
+import type { LikeC4Services } from '../../module';
+import type { LikeC4MCPServer } from '../interfaces';
+export declare class StdioLikeC4MCPServer implements LikeC4MCPServer, AsyncDisposable {
+    private services;
+    private transport;
+    private _mcp;
+    constructor(services: LikeC4Services);
+    get mcp(): McpServer;
+    get isStarted(): boolean;
+    get port(): number;
+    dispose(): Promise<void>;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+}

package/dist/mcp/server/StdioLikeC4MCPServer.js

@@ -0,0 +1,43 @@
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { logger } from "../utils.js";
+export class StdioLikeC4MCPServer {
+  constructor(services) {
+    this.services = services;
+  }
+  transport = void 0;
+  _mcp = void 0;
+  get mcp() {
+    if (!this._mcp) {
+      throw new Error("MCP server is not started");
+    }
+    return this._mcp;
+  }
+  get isStarted() {
+    return this.transport !== void 0;
+  }
+  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();
+    this._mcp?.close();
+    this.transport = void 0;
+  }
+}

package/dist/mcp/{sseserver/MCPServer.d.ts → server/StreamableLikeC4MCPServer.d.ts}

@@ -1,12 +1,13 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { AsyncDisposable } from 'langium';
 import type { LikeC4Services } from '../../module';
 import type { LikeC4MCPServer } from '../interfaces';
-export declare class SSELikeC4MCPServer implements LikeC4MCPServer, AsyncDisposable {
+export declare class StreamableLikeC4MCPServer implements LikeC4MCPServer, AsyncDisposable {
     private services;
-    private transports;
     private server;
     private _port;
     constructor(services: LikeC4Services);
+    get mcp(): McpServer;
     get isStarted(): boolean;
     get port(): number;
     dispose(): Promise<void>;