@likec4/language-server 1.37.0 → 1.38.0

package/dist/mcp/tools/read-view.js

@@ -1,9 +1,6 @@
-import { invariant } from "@likec4/core";
 import z from "zod";
-import { safeCall } from "../../utils/index.js";
-import { ProjectsManager } from "../../workspace/index.js";
 import { likec4Tool } from "../utils.js";
-import { locationSchema } from "./_common.js";
+import { locationSchema, mkLocate, projectIdSchema } from "./_common.js";
 const modelRef = (node) => {
   if (node.hasElement()) {
     return node.element.id;
@@ -13,152 +10,196 @@ const modelRef = (node) => {
   }
   return null;
 };
+const nodeSchema = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("element"),
+    id: z.string().describe("Node ID"),
+    elementId: z.string().describe("Element ID (FQN)"),
+    kind: z.string().describe("Element kind"),
+    title: z.string().describe("Node title"),
+    description: z.string().nullable(),
+    technology: z.string().nullable(),
+    children: z.array(z.string()).describe("Children nodes, array of node IDs"),
+    shape: z.string().describe("Rendered shape"),
+    color: z.string().describe("Rendered color"),
+    tags: z.array(z.string())
+  }),
+  z.object({
+    type: z.literal("deployment-node"),
+    id: z.string().describe("Node ID"),
+    deploymentId: z.string().describe("Deployment entity ID (FQN)"),
+    kind: z.string().describe("Deployment kind"),
+    title: z.string().describe("Node title"),
+    description: z.string().nullable(),
+    technology: z.string().nullable(),
+    children: z.array(z.string()).describe("Children nodes, array of node IDs"),
+    shape: z.string().describe("Rendered shape"),
+    color: z.string().describe("Rendered color"),
+    tags: z.array(z.string())
+  }),
+  z.object({
+    type: z.literal("deployed-instance"),
+    id: z.string().describe("Node ID"),
+    deploymentId: z.string().describe("Deployment entity ID (FQN)"),
+    title: z.string().describe("Node title"),
+    description: z.string().nullable(),
+    technology: z.string().nullable(),
+    referencedElement: z.object({
+      id: z.string().describe("Element ID (FQN)"),
+      kind: z.string().describe("Element kind"),
+      title: z.string().describe("Element title")
+    }),
+    shape: z.string().describe("Rendered shape"),
+    color: z.string().describe("Rendered color"),
+    tags: z.array(z.string())
+  })
+]);
 export const readView = likec4Tool({
   name: "read-view",
   description: `
-Returns information about LikeC4 view, includes:
-- id (view name)
-- type (element, deployment, dynamic)
-- title, description, tags
-- project name this view belongs to
-- array of elements included in this view
-- array of relationships in this view (source, target, title, description, technology, tags)
-- viewOf (element id this view is the default view of)
-- source location (if running in the editor)
-`.trimStart(),
+Read detailed information about a LikeC4 view.
+
+Request:
+- viewId: string \u2014 view id (name)
+- project: string (optional) \u2014 project id. Defaults to "default" if omitted.
+
+Response (JSON object):
+- id: string \u2014 view id
+- type: "element" | "deployment" | "dynamic" \u2014 view type
+- title: string \u2014 view title (falls back to id if not set)
+- description: string|null \u2014 optional description
+- tags: string[] \u2014 view tags
+- project: string \u2014 project id this view belongs to
+- nodes: Node[] \u2014 nodes included in the view
+- edges: Edge[] \u2014 relationships between nodes
+- sourceLocation: { path: string, range: { start: { line: number, character: number }, end: { line: number, character: number } } } | null \u2014 source location if available
+
+Node (discriminated union by "type"):
+- type = "element": { id: string, elementId: string, kind: string, title: string, description: string|null, technology: string|null, children: string[], shape: string, color: string, tags: string[] }
+- type = "deployment-node": { id: string, deploymentId: string, kind: string, title: string, description: string|null, technology: string|null, children: string[], shape: string, color: string, tags: string[] }
+- type = "deployed-instance": { id: string, deploymentId: string, title: string, description: string|null, technology: string|null, referencedElement: { id: string, kind: string, title: string }, shape: string, color: string, tags: string[] }
+
+Edge object:
+- { source: string, target: string, label: string|null, description: string|null, technology: string|null, tags: string[] }
+
+Notes:
+- Read-only, idempotent, no side effects.
+
+Example response:
+{
+  "id": "system-overview",
+  "type": "element",
+  "title": "System Overview",
+  "description": null,
+  "tags": [],
+  "project": "default",
+  "nodes": [
+    { "type": "logical", "id": "n1", "elementId": "shop.frontend", "kind": "container", "title": "Frontend", "description": null, "technology": "React", "children": [], "shape": "rounded-rectangle", "color": "#2F80ED", "tags": [] }
+  ],
+  "edges": [
+    { "source": "n1", "target": "n2", "label": "calls", "description": null, "technology": "HTTPS", "tags": [] }
+  ],
+  "sourceLocation": {
+    "path": "/abs/path/project/model.c4",
+    "range": { "start": { "line": 10, "character": 0 }, "end": { "line": 30, "character": 0 } }
+  }
+}
+`,
   annotations: {
-    readOnlyHint: true
+    readOnlyHint: true,
+    idempotentHint: true,
+    title: "Read view"
   },
   inputSchema: {
     viewId: z.string().describe("View id (name)"),
-    project: z.string().optional().describe('Project name (optional, will use "default" if not specified)')
+    project: projectIdSchema
   },
   outputSchema: {
     id: z.string(),
-    type: z.enum(["element", "deployment", "dynamic"]),
-    title: z.string().nullish(),
-    description: z.string().nullish(),
+    type: z.enum(["element", "deployment", "dynamic"]).describe("View type"),
+    title: z.string(),
+    description: z.string().nullable(),
     tags: z.array(z.string()),
     project: z.string(),
-    elements: z.array(
-      z.discriminatedUnion("type", [
-        z.object({
-          type: z.literal("logical"),
-          id: z.string().describe("Element ID (FQN)"),
-          kind: z.string().describe("Element kind"),
-          title: z.string().describe("Element title"),
-          description: z.string().nullish(),
-          technology: z.string().nullish(),
-          children: z.array(z.string()),
-          shape: z.string().describe("Element shape"),
-          tags: z.array(z.string())
-        }),
-        z.object({
-          type: z.literal("deployment-node"),
-          id: z.string().describe("Deployment ID (FQN)"),
-          kind: z.string().describe("Deployment kind"),
-          title: z.string().describe("Deployment title"),
-          description: z.string().nullish(),
-          technology: z.string().nullish(),
-          children: z.array(z.string()),
-          shape: z.string().describe("Deployment shape"),
-          tags: z.array(z.string())
-        }),
-        z.object({
-          type: z.literal("deployed-instance"),
-          id: z.string().describe("Deployment ID (FQN)"),
-          title: z.string().describe("Deployment title"),
-          description: z.string().nullish(),
-          technology: z.string().nullish(),
-          logicalElementId: z.string().describe("Logical element ID (FQN)"),
-          shape: z.string().describe("Deployment shape"),
-          tags: z.array(z.string())
-        })
-      ])
-    ).describe("Elements in this view"),
-    relationships: z.array(
+    nodes: z.array(nodeSchema),
+    edges: z.array(
       z.object({
-        source: z.string().describe("Source element ID"),
-        target: z.string().describe("Target element ID"),
-        title: z.string().nullish(),
-        description: z.string().nullish(),
-        technology: z.string().nullish(),
+        source: z.string().describe("Source node"),
+        target: z.string().describe("Target node"),
+        label: z.string().nullable(),
+        description: z.string().nullable(),
+        technology: z.string().nullable(),
         tags: z.array(z.string())
       })
-    ).describe("Relationships in this view"),
-    defaultViewOf: z.string().optional().describe("Element ID (FQN) this view is the default view of"),
-    sourceLocation: locationSchema.nullish()
+    ).describe("Edge represents relationship between nodes"),
+    sourceLocation: locationSchema
   }
 }, async (languageServices, args) => {
-  const projectId = args.project ?? ProjectsManager.DefaultProjectId;
-  const project = languageServices.projects().find((p) => p.id === projectId);
-  invariant(project, `Project "${projectId}" not found`);
-  const model = await languageServices.computedModel(project.id);
+  const projectId = languageServices.projectsManager.ensureProjectId(args.project);
+  const project = languageServices.project(projectId);
+  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 ${project.id}`);
   }
+  const locate = mkLocate(languageServices, project.id);
   return {
     id: view.id,
     type: view.$view._type,
-    title: view.title,
+    title: view.title ?? view.id,
     description: view.description.text,
     tags: [...view.tags],
     project: project.id,
-    elements: [...view.nodes()].flatMap((node) => {
+    nodes: [...view.nodes()].flatMap((node) => {
+      const base = {
+        id: node.id,
+        title: node.title,
+        description: node.description.text,
+        technology: node.technology,
+        shape: node.shape,
+        color: node.color,
+        tags: [...node.tags]
+      };
       if (node.hasDeployedInstance()) {
         return {
+          ...base,
           type: "deployed-instance",
-          id: node.deployment.id,
-          title: node.title,
-          logicalElementId: node.deployment.element.id,
-          description: node.description.text,
-          technology: node.technology,
-          shape: node.shape,
-          tags: [...node.tags]
+          deploymentId: node.deployment.id,
+          referencedElement: {
+            id: node.deployment.element.id,
+            kind: node.deployment.element.kind,
+            title: node.deployment.element.title
+          }
         };
       }
       if (node.hasDeployment()) {
         return {
+          ...base,
           type: "deployment-node",
-          id: node.deployment.id,
-          title: node.title,
           kind: node.deployment.kind,
-          description: node.description.text,
-          technology: node.technology,
-          shape: node.shape,
-          tags: [...node.tags],
-          children: [...node.children()].flatMap((c) => modelRef(c) ?? [])
+          deploymentId: node.deployment.id,
+          children: [...node.children()].map((c) => c.id)
         };
       }
       if (node.hasElement()) {
         return {
-          type: "logical",
-          id: node.element.id,
-          title: node.title,
+          ...base,
+          type: "element",
+          elementId: node.element.id,
           kind: node.element.kind,
-          description: node.description.text,
-          technology: node.technology,
-          shape: node.shape,
-          tags: [...node.tags],
           children: [...node.children()].flatMap((c) => modelRef(c) ?? [])
         };
       }
       return [];
     }),
-    viewOf: view.viewOf?.id,
-    relationships: [...view.edges()].flatMap((r) => {
-      const source = modelRef(r.source);
-      const target = modelRef(r.target);
-      return source && target ? [{
-        source,
-        target,
-        title: r.label,
-        description: r.description.text,
-        technology: r.technology,
-        tags: [...r.tags]
-      }] : [];
-    }),
-    sourceLocation: safeCall(() => languageServices.locate({ view: view.id, projectId }))
+    edges: [...view.edges()].map((r) => ({
+      source: r.source.id,
+      target: r.target.id,
+      label: r.label,
+      description: r.description.text,
+      technology: r.technology,
+      tags: [...r.tags]
+    })),
+    sourceLocation: locate({ view: view.id })
   };
 });

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

@@ -1,24 +1,31 @@
 import { ifilter } from "@likec4/core/utils";
 import z from "zod";
-import { likec4Tool } from "../utils.js";
+import { likec4Tool, logger } from "../utils.js";
+import { includedInViews, includedInViewsSchema } from "./_common.js";
 const searchResultSchema = z.array(
   z.discriminatedUnion("type", [
     z.object({
-      type: z.literal("logical"),
+      type: z.literal("element"),
+      project: z.string().describe("Project ID"),
       id: z.string().describe("Element ID (FQN)"),
+      name: z.string().describe("Element name"),
       kind: z.string(),
       title: z.string(),
+      technology: z.string().nullable(),
       shape: z.string(),
-      project: z.string().describe("Project name"),
+      includedInViews: includedInViewsSchema,
       tags: z.array(z.string())
     }),
     z.object({
       type: z.literal("deployment-node"),
+      project: z.string().describe("Project ID"),
       id: z.string().describe("Deployment ID (FQN)"),
+      name: z.string().describe("Deployment name"),
       kind: z.string(),
       title: z.string(),
+      technology: z.string().nullable(),
       shape: z.string(),
-      project: z.string().describe("Project name"),
+      includedInViews: includedInViewsSchema,
       tags: z.array(z.string())
     })
   ])
@@ -26,32 +33,69 @@ const searchResultSchema = z.array(
 export const searchElement = likec4Tool({
   name: "search-element",
   annotations: {
-    readOnlyHint: true
+    readOnlyHint: true,
+    idempotentHint: true,
+    title: "Search elements"
   },
   description: `
-Search for LikeC4 elements and deployment nodes by partial match of:
-- id (FQN)
-- title
-- kind (if search string starts with "kind:")
-- shape (if search string starts with "shape:")
-- any assigned tags (if search string starts with "#")
+Search LikeC4 elements and deployment nodes across all projects.
 
-Returns array of found elements with:
-- type (logical or deployment-node)
-- id (FQN)
-- kind
-- title
-- shape
-- project name this element belongs to
-- assigned tags
+Query syntax (case-insensitive):
+- Free text: matches id (FQN) or title
+- kind:<value>: filters by kind
+- shape:<value>: filters by shape
+- #<value>: matches assigned tags
 
-Can be used for further requests (like read-element or read-project-summary)
-`.trimStart(),
+Request:
+- search: string \u2014 at least 2 characters
+
+Response (JSON object):
+- found: Result[] - returns top 20 results
+- total: number - total number of results
+
+Result (discriminated union by "type"):
+- type = "element": { id: string, name: string, kind: string, title: string, technology: string|null, shape: string, project: string, includedInViews: View[], tags: string[] }
+- type = "deployment-node": { id: string, name: string, kind: string, title: string, technology: string|null, shape: string, project: string, includedInViews: View[], tags: string[] }
+
+View (object) fields:
+- id: string \u2014 view identifier
+- title: string \u2014 view title
+- type: "element" | "deployment" | "dynamic"
+
+Notes:
+- Read-only, idempotent.
+- Use results as input to other tools (e.g., read-element, read-view).
+
+Example response:
+{
+  "found": [
+    {
+      "type": "logical",
+      "project": "default",
+      "id": "shop.frontend",
+      "name": "frontend",
+      "kind": "container",
+      "title": "Frontend",
+      "technology": "React",
+      "shape": "rectangle",      
+      "includedInViews": [
+        {
+          "id": "system-overview",
+          "title": "System Overview",
+          "type": "element"
+        }
+      ],
+      "tags": ["public"]
+    }
+  ]
+}
+`,
   inputSchema: {
     search: z.string().min(2, "Search must be at least 2 characters long")
   },
   outputSchema: {
-    found: searchResultSchema
+    found: searchResultSchema,
+    total: z.number()
   }
 }, async (languageServices, args) => {
   const projects = languageServices.projects();
@@ -73,33 +117,40 @@ Can be used for further requests (like read-element or read-project-summary)
   for (const project of projects) {
     try {
       const model = await languageServices.computedModel(project.id);
-      for (const el of ifilter(model.elements(), predicate)) {
+      for (const el of ifilter(model.elements(), (e) => !e.imported && predicate(e))) {
         found.push({
-          type: "logical",
+          type: "element",
+          project: project.id,
           id: el.id,
+          name: el.name,
           kind: el.kind,
           title: el.title,
+          technology: el.technology,
           shape: el.shape,
-          project: project.id,
-          tags: [...el.tags]
+          tags: [...el.tags],
+          includedInViews: includedInViews(el.views())
         });
       }
       for (const el of ifilter(model.deployment.nodes(), predicate)) {
         found.push({
           type: "deployment-node",
+          project: project.id,
           id: el.id,
+          name: el.name,
           kind: el.kind,
           title: el.title,
+          technology: el.technology,
           shape: el.shape,
-          project: project.id,
-          tags: [...el.tags]
+          tags: [...el.tags],
+          includedInViews: includedInViews(el.views())
         });
       }
     } catch (error) {
-      console.error(`Error searching in project ${project.id}:`, error);
+      logger.error(`Error searching in project ${project.id}:`, { error });
     }
   }
   return {
-    found
+    found: found.slice(0, 20),
+    total: found.length
   };
 });

package/dist/mcp/utils.js

@@ -2,17 +2,20 @@ import { loggable } from "@likec4/log";
 import { logger as mainLogger } from "../logger.js";
 export const logger = mainLogger.getChild("mcp");
 export function likec4Tool(config, cb) {
-  const { name, ...rest } = config;
+  const { name, description, ...rest } = config;
   return (languageServices) => [
     name,
-    rest,
+    {
+      description: description?.trim() ?? "",
+      ...rest
+    },
     mkcallTool(name, languageServices, cb)
   ];
 }
 function mkcallTool(name, languageServices, cb) {
   const tool = cb.bind(null, languageServices);
   return async function callTool(args, extra) {
-    logger.debug("Calling tool {name}", { name, args });
+    logger.debug("Calling tool {name}, args: {args}", { name, args });
     try {
       const result = await tool.call(null, args, extra);
       if (typeof result === "string") {
@@ -35,7 +38,7 @@ function mkcallTool(name, languageServices, cb) {
       return {
         content: [{
           type: "text",
-          text: loggable(err)
+          text: err instanceof Error ? err.message : loggable(err)
         }],
         isError: true
       };

package/dist/module.d.ts

@@ -2,9 +2,11 @@ import { QueueGraphvizLayoter } from '@likec4/layouts';
 import { type Module, WorkspaceCache } from 'langium';
 import { type DefaultSharedModuleContext, type LangiumServices, type LangiumSharedServices, type PartialLangiumServices } from 'langium/lsp';
 import { LikeC4DocumentationProvider } from './documentation';
+import { type FileSystemModuleContext, type FileSystemProvider, type FileSystemWatcher } from './filesystem';
 import { type LikeC4LanguageServices } from './LikeC4LanguageServices';
 import { LikeC4CodeLensProvider, LikeC4CompletionProvider, LikeC4DocumentHighlightProvider, LikeC4DocumentLinkProvider, LikeC4DocumentSymbolProvider, LikeC4HoverProvider, LikeC4SemanticTokenProvider } from './lsp';
-import { type LikeC4MCPServer, type LikeC4MCPServerFactory } from './mcp/interfaces';
+import { type LikeC4MCPServer, type LikeC4MCPServerModuleContext } from './mcp/interfaces';
+import { LikeC4MCPServerFactory } from './mcp/MCPServerFactory';
 import { type LikeC4ModelBuilder, DeploymentsIndex, FqnIndex, LikeC4ModelLocator, LikeC4ModelParser, LikeC4ValueConverter } from './model';
 import { LikeC4ModelChanges } from './model-change/ModelChanges';
 import { LikeC4NameProvider, LikeC4ScopeComputation, LikeC4ScopeProvider } from './references';
@@ -13,6 +15,7 @@ import { NodeKindProvider, WorkspaceSymbolProvider } from './shared';
 import { LikeC4DocumentValidator } from './validation';
 import { type LikeC4Views } from './views';
 import { IndexManager, LangiumDocuments, LikeC4WorkspaceManager, ProjectsManager } from './workspace';
+export type LanguageServicesContext = Omit<DefaultSharedModuleContext, 'fileSystemProvider'> & FileSystemModuleContext & LikeC4MCPServerModuleContext;
 interface LikeC4AddedSharedServices {
     lsp: {
         NodeKindProvider: NodeKindProvider;
@@ -23,6 +26,8 @@ interface LikeC4AddedSharedServices {
         IndexManager: IndexManager;
         LangiumDocuments: LangiumDocuments;
         WorkspaceManager: LikeC4WorkspaceManager;
+        FileSystemProvider: FileSystemProvider;
+        FileSystemWatcher: FileSystemWatcher;
     };
 }
 export type LikeC4SharedServices = LangiumSharedServices & LikeC4AddedSharedServices;
@@ -73,15 +78,10 @@ export interface LikeC4AddedServices {
     };
 }
 export type LikeC4Services = LangiumServices & LikeC4AddedServices;
-export declare const LikeC4Module: Module<LikeC4Services, PartialLangiumServices & LikeC4AddedServices>;
-export type LanguageServicesContext = Partial<DefaultSharedModuleContext>;
-export declare function createCustomLanguageServices<I1, I2, I3, I extends I1 & I2 & I3 & LikeC4Services>(context: LanguageServicesContext, module?: Module<I, I1>, module2?: Module<I, I2>, module3?: Module<I, I3>): {
+export declare const createLikeC4Module: (context: LikeC4MCPServerModuleContext) => Module<LikeC4Services, PartialLangiumServices & LikeC4AddedServices>;
+export declare function createLanguageServices<I1, I2, I3, I extends I1 & I2 & I3 & LikeC4Services>(context: Partial<LanguageServicesContext>, module?: Module<I, I1>, module2?: Module<I, I2>, module3?: Module<I, I3>): {
     shared: LikeC4SharedServices;
     likec4: I;
 };
-export declare function createSharedServices(context?: LanguageServicesContext): LikeC4SharedServices;
-export declare function createLanguageServices(context?: LanguageServicesContext): {
-    shared: LikeC4SharedServices;
-    likec4: LikeC4Services;
-};
+export declare function createSharedServices(context?: Partial<LanguageServicesContext>): LikeC4SharedServices;
 export {};