@likec4/language-server 1.43.0 → 1.44.0

package/dist/mcp/MCPServerFactory.mjs

@@ -1,70 +0,0 @@
-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.mjs";
-import { findRelationships } from "./tools/find-relationships.mjs";
-import { listProjects } from "./tools/list-projects.mjs";
-import { openView } from "./tools/open-view.mjs";
-import { readDeployment } from "./tools/read-deployment.mjs";
-import { readElement } from "./tools/read-element.mjs";
-import { readProjectSummary } from "./tools/read-project-summary.mjs";
-import { readView } from "./tools/read-view.mjs";
-import { searchElement } from "./tools/search-element.mjs";
-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/metadata. Input: { search }.
-- read-element \u2014 Full element details including relationships, includedInViews, deployedInstances, metadata 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/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.mjs

@@ -1,17 +0,0 @@
-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.mjs

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

package/dist/mcp/server/StdioLikeC4MCPServer.mjs

@@ -1,46 +0,0 @@
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { logger } from "../utils.mjs";
-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();
-    if (this._mcp) {
-      await this._mcp.close();
-    }
-    this._mcp = void 0;
-    this.transport = void 0;
-  }
-}

package/dist/mcp/server/StreamableLikeC4MCPServer.mjs

@@ -1,153 +0,0 @@
-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.mjs";
-export class StreamableLikeC4MCPServer {
-  constructor(services, _port = 33335) {
-    this.services = services;
-    this._port = _port;
-  }
-  // Store transports by session ID to send notifications
-  server = void 0;
-  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: void 0
-          });
-          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: -32e3,
-              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: -32e3,
-              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: -32e3,
-              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 = void 0;
-    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.mjs

@@ -1,58 +0,0 @@
-import { loggable } from "@likec4/log";
-import { isError } from "remeda";
-import { logger } from "../utils.mjs";
-import { StdioLikeC4MCPServer } from "./StdioLikeC4MCPServer.mjs";
-import { StreamableLikeC4MCPServer } from "./StreamableLikeC4MCPServer.mjs";
-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 : void 0;
-      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
-
-${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.mjs

@@ -1,42 +0,0 @@
-import { URI } from "vscode-uri";
-import z from "zod";
-import { ProjectsManager } from "../../workspace/index.mjs";
-import { logger } from "../utils.mjs";
-export const locationSchema = z.object({
-  path: z.string().describe("Path to the file"),
-  range: z.object({
-    start: z.object({
-      line: z.number(),
-      character: z.number()
-    }),
-    end: z.object({
-      line: z.number(),
-      character: z.number()
-    })
-  }).describe("Range in the file")
-}).nullable();
-export const projectIdSchema = z.string().refine((_v) => true).optional().default(ProjectsManager.DefaultProjectId).describe('Project id (optional, will use "default" if not specified)');
-export const includedInViewsSchema = z.array(z.object({
-  id: z.string().describe("View id"),
-  title: z.string().describe("View title"),
-  type: z.enum(["element", "deployment", "dynamic"]).describe("View type")
-}));
-export const includedInViews = (views) => {
-  return [...views].map((v) => ({
-    id: v.id,
-    title: v.titleOrId,
-    type: v.$view._type
-  }));
-};
-export const mkLocate = (languageServices, projectId) => (params) => {
-  try {
-    const loc = languageServices.locate({ projectId, ...params });
-    return loc ? {
-      path: URI.parse(loc.uri).fsPath,
-      range: loc.range
-    } : null;
-  } catch (e) {
-    logger.debug(`Failed to locate {params}`, { error: e, params });
-    return null;
-  }
-};

package/dist/mcp/tools/find-relationships.mjs

@@ -1,151 +0,0 @@
-import { modelConnection } from "@likec4/core/model";
-import { invariant, isSameHierarchy } from "@likec4/core/utils";
-import z from "zod";
-import { likec4Tool } from "../utils.mjs";
-import { includedInViews, includedInViewsSchema, locationSchema, mkLocate, projectIdSchema } from "./_common.mjs";
-const endpointSchema = z.object({
-  id: z.string(),
-  title: z.string(),
-  kind: z.string()
-});
-const searchResultSchema = z.object({
-  type: z.enum(["direct", "indirect"]).describe(
-    'Type of relationship, "direct" for direct relationships, "indirect" for relationships through nested elements'
-  ),
-  source: endpointSchema,
-  target: endpointSchema,
-  kind: z.string().nullable().describe("Relationship kind"),
-  title: z.string().nullable().describe("Relationship title"),
-  description: z.string().nullable().describe("Relationship description"),
-  technology: z.string().nullable().describe("Relationship technology"),
-  tags: z.array(z.string()).describe("Relationship tags"),
-  includedInViews: includedInViewsSchema.describe("Views that include this relationship"),
-  sourceLocation: locationSchema
-});
-export const findRelationships = likec4Tool({
-  name: "find-relationships",
-  annotations: {
-    readOnlyHint: true,
-    idempotentHint: true,
-    title: "Find relationships between two elements"
-  },
-  description: `
-Find relationships between two LikeC4 elements within a project.
-
-What it does:
-- Finds both direct relationships (element1 \u2194 element2) and indirect ones that arise via containment (e.g. via nested elements).
-- Returns rich metadata for each relationship and where it appears in views.
-
-Inputs:
-- element1: string \u2014 Element ID (FQN)
-- element2: string \u2014 Element ID (FQN)
-- project: string (optional, defaults to "default") \u2014 Project id
-
-Output:
-- found: Relationship[]
-
-Relationship (object) fields:
-- type: "direct" | "indirect" \u2014 direct is between the specified endpoints; indirect is via nested elements
-- source: Endpoint
-- target: Endpoint
-- kind: string|null \u2014 relationship kind from the model
-- title: string|null \u2014 relationship title if provided
-- description: string|null \u2014 relationship description text
-- technology: string|null \u2014 relationship technology
-- tags: string[] \u2014 relationship tags
-- includedInViews: View[] \u2014 views where this relationship appears
-- sourceLocation: { path: string, range: { start: { line: number, character: number }, end: { line: number, character: number } } } | null
-
-Endpoint (object) fields:
-- id: string \u2014 Element ID (FQN)
-- title: string \u2014 element title
-- kind: string \u2014 element kind
-
-View (object) fields:
-- id: string \u2014 view identifier
-- title: string \u2014 view title
-- type: "element" | "deployment" | "dynamic"
-
-Notes:
-- Read-only, idempotent; does not mutate the model. May trigger UI navigation in supporting clients.
-- The order of results is not guaranteed.
-
-Example:
-Request:
-{
-  "element1": "shop.frontend",
-  "element2": "shop.backend",
-  "project": "default"
-}
-
-Response:
-{
-  "found": [
-    {
-      "type": "direct",
-      "source": { "id": "shop.frontend", "title": "Frontend", "kind": "component" },
-      "target": { "id": "shop.backend", "title": "Backend", "kind": "component" },
-      "kind": "sync",
-      "title": "Calls",
-      "description": "Frontend calls Backend",
-      "technology": "HTTP",
-      "tags": ["public"],
-      "includedInViews": [
-        { "id": "system-overview", "title": "System Overview", "type": "element" }
-      ],
-      "sourceLocation": {
-        "path": "/abs/path/project/model.c4",
-        "range": { "start": { "line": 12, "character": 0 }, "end": { "line": 14, "character": 0 } }
-      }
-    }
-  ]
-}
-`,
-  inputSchema: {
-    element1: z.string().describe("Element ID (FQN)"),
-    element2: z.string().describe("Element ID (FQN)"),
-    project: projectIdSchema
-  },
-  outputSchema: {
-    found: z.array(searchResultSchema)
-  }
-}, async (languageServices, args) => {
-  const projectId = languageServices.projectsManager.ensureProjectId(args.project);
-  if (isSameHierarchy(args.element1, args.element2)) {
-    throw new Error("No relationships possible between parent-child");
-  }
-  const found = [];
-  const model = await languageServices.computedModel(projectId);
-  const el1 = model.findElement(args.element1);
-  invariant(el1, `Element "${args.element1}" not found in project "${projectId}"`);
-  const el2 = model.findElement(args.element2);
-  invariant(el2, `Element "${args.element2}" not found in project "${projectId}"`);
-  const locate = mkLocate(languageServices, projectId);
-  const relationships = modelConnection.findConnection(el1, el2, "both").flatMap((c) => [...c.relations]);
-  for (const relationship of relationships) {
-    const isDirect = relationship.source === el1 && relationship.target === el2 || relationship.source === el2 && relationship.target === el1;
-    found.push({
-      type: isDirect ? "direct" : "indirect",
-      source: {
-        id: relationship.source.id,
-        title: relationship.source.title,
-        kind: relationship.source.kind
-      },
-      target: {
-        id: relationship.target.id,
-        title: relationship.target.title,
-        kind: relationship.target.kind
-      },
-      kind: relationship.kind,
-      title: relationship.title,
-      description: relationship.description.text,
-      technology: relationship.technology,
-      tags: [...relationship.tags],
-      includedInViews: includedInViews(relationship.views()),
-      sourceLocation: locate({ relation: relationship.id })
-    });
-  }
-  return {
-    found
-  };
-});

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

@@ -1,62 +0,0 @@
-import z from "zod";
-import { likec4Tool } from "../utils.mjs";
-export const listProjects = likec4Tool({
-  name: "list-projects",
-  description: `
-List LikeC4 projects discoverable in the current workspace.
-
-Request:
-- No input parameters.
-
-Response (JSON object):
-- projects: Project[]
-
-Project (object) fields:
-- id: string \u2014 stable project identifier
-- title: string \u2014 human-readable project title
-- folder: string \u2014 absolute path to the project root
-- sources: string[] \u2014 absolute file paths of related documents
-
-Notes:
-- Read-only, idempotent, no side effects.
-- Safe to call repeatedly.
-
-Example response:
-{
-  "projects": [
-    {
-      "id": "docs",
-      "title": "Documentation",
-      "folder": "/abs/path/to/workspace/docs",
-      "sources": [
-        "/abs/path/to/workspace/docs/model/contexts.likec4",
-        "/abs/path/to/workspace/docs/model/relations.likec4"
-      ]
-    }
-  ]
-}
-`,
-  annotations: {
-    readOnlyHint: true,
-    idempotentHint: true,
-    title: "List projects"
-  },
-  outputSchema: {
-    projects: z.array(z.object({
-      id: z.string(),
-      title: z.string(),
-      folder: z.string(),
-      sources: z.array(z.string())
-    }))
-  }
-}, async (languageServices) => {
-  const projects = languageServices.projects();
-  return {
-    projects: projects.map((p) => ({
-      id: p.id,
-      title: p.title,
-      folder: p.folder.fsPath,
-      sources: p.documents.map((d) => d.fsPath)
-    }))
-  };
-});

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

@@ -1,52 +0,0 @@
-import z from "zod";
-import { likec4Tool } from "../utils.mjs";
-import { locationSchema, mkLocate, projectIdSchema } from "./_common.mjs";
-export const openView = likec4Tool({
-  name: "open-view",
-  description: `
-Open a LikeC4 view in the editor's preview panel.
-
-Request:
-- viewId: string \u2014 view id (name)
-- project: string (optional) \u2014 project id. Defaults to "default" if omitted.
-
-Response (JSON object):
-- location: { path: string, range: { start: { line: number, character: number }, end: { line: number, character: number } } } | null \u2014 source location of the view if available
-
-Notes:
-- Read-only and idempotent with respect to the project model. Triggers a UI action in the editor.
-- Only one preview panel can be open at a time.
-
-Example response:
-{
-  "location": {
-    "path": "/abs/path/project/model.c4",
-    "range": { "start": { "line": 10, "character": 0 }, "end": { "line": 30, "character": 0 } }
-  }
-}
-`,
-  annotations: {
-    readOnlyHint: true,
-    idempotentHint: true,
-    title: "Open view in preview panel"
-  },
-  inputSchema: {
-    viewId: z.string().describe("View id (name)"),
-    project: projectIdSchema
-  },
-  outputSchema: {
-    location: locationSchema
-  }
-}, async (languageServices, args) => {
-  const projectId = languageServices.projectsManager.ensureProjectId(args.project);
-  const model = await languageServices.computedModel(projectId);
-  const view = model.findView(args.viewId);
-  if (!view) {
-    throw new Error(`View with ID '${args.viewId}' not found in project ${projectId}`);
-  }
-  await languageServices.views.openView(view.id, projectId);
-  const locate = mkLocate(languageServices, projectId);
-  return {
-    location: locate({ view: view.id })
-  };
-});