@likec4/language-server 1.33.0 → 1.34.1

package/dist/mcp/tools/read-project-summary.js

@@ -0,0 +1,68 @@
+import { invariant } from "@likec4/core";
+import { keys } from "remeda";
+import z from "zod";
+import { ProjectsManager } from "../../workspace/index.js";
+import { likec4Tool } from "../utils.js";
+import { locationSchema } from "./_common.js";
+export const readProjectSummary = likec4Tool({
+  name: "read-project-summary",
+  annotations: {
+    readOnlyHint: true
+  },
+  description: `
+Searches for LikeC4 project by name in workspace and returns its summary:
+- project folder
+- array of the source filenames
+- specification:
+  - all element kinds
+  - all relationship kinds
+  - all deployment kinds
+  - all tags (used and unused)
+  - used metadata keys
+- array of the views, where each view:
+  - name
+  - type ("element", "deployment", "dynamic")
+  - title
+  `,
+  inputSchema: {
+    project: z.string().optional().describe('Project name (optional, will use "default" if not specified)')
+  },
+  outputSchema: {
+    folder: z.string(),
+    sources: z.array(z.string()),
+    specification: z.object({
+      elementKinds: z.array(z.string()),
+      relationshipKinds: z.array(z.string()),
+      deploymentKinds: z.array(z.string()),
+      tags: z.array(z.string()),
+      metadataKeys: z.array(z.string())
+    }),
+    views: z.array(z.object({
+      name: z.string(),
+      title: z.string().nullable(),
+      type: z.enum(["element", "deployment", "dynamic"]),
+      sourceLocation: locationSchema.nullish()
+    }))
+  }
+}, 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);
+  return {
+    folder: project.folder.toString(),
+    sources: project.documents?.map((d) => d.toString()) ?? [],
+    specification: {
+      elementKinds: keys(model.specification.elements),
+      relationshipKinds: keys(model.specification.relationships),
+      deploymentKinds: keys(model.specification.deployments),
+      tags: [...model.tags],
+      metadataKeys: model.specification.metadataKeys ?? []
+    },
+    views: [...model.views()].map((v) => ({
+      name: v.id,
+      title: v.title,
+      type: v.$view._type
+    }))
+  };
+});

package/dist/mcp/tools/read-view.d.ts

@@ -0,0 +1,10 @@
+import z from 'zod';
+export declare const readView: (languageServices: import("../..").LikeC4LanguageServices) => [string, {
+    inputSchema?: {
+        viewId: z.ZodString;
+        project: z.ZodOptional<z.ZodString>;
+    } | undefined;
+}, (args: {
+    viewId: string;
+    project?: string | undefined;
+}, extra: import("@modelcontextprotocol/sdk/shared/protocol").RequestHandlerExtra<import("@modelcontextprotocol/sdk/types").ServerRequest, import("@modelcontextprotocol/sdk/types").ServerNotification>) => import("@modelcontextprotocol/sdk/types").CallToolResult | Promise<import("@modelcontextprotocol/sdk/types").CallToolResult>];

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

@@ -0,0 +1,164 @@
+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";
+const modelRef = (node) => {
+  if (node.hasElement()) {
+    return node.element.id;
+  }
+  if (node.hasDeployment()) {
+    return node.deployment.id;
+  }
+  return null;
+};
+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(),
+  annotations: {
+    readOnlyHint: true
+  },
+  inputSchema: {
+    viewId: z.string().describe("View id (name)"),
+    project: z.string().optional().describe('Project name (optional, will use "default" if not specified)')
+  },
+  outputSchema: {
+    id: z.string(),
+    type: z.enum(["element", "deployment", "dynamic"]),
+    title: z.string().nullish(),
+    description: z.string().nullish(),
+    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(
+      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(),
+        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()
+  }
+}, 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 view = model.findView(args.viewId);
+  if (!view) {
+    throw new Error(`View with ID '${args.viewId}' not found in project ${project.id}`);
+  }
+  return {
+    id: view.id,
+    type: view.$view._type,
+    title: view.title,
+    description: view.description.text,
+    tags: [...view.tags],
+    project: project.id,
+    elements: [...view.nodes()].flatMap((node) => {
+      if (node.hasDeployedInstance()) {
+        return {
+          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]
+        };
+      }
+      if (node.hasDeployment()) {
+        return {
+          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) ?? [])
+        };
+      }
+      if (node.hasElement()) {
+        return {
+          type: "logical",
+          id: node.element.id,
+          title: node.title,
+          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 }))
+  };
+});

package/dist/mcp/tools/search-element.d.ts

@@ -0,0 +1,8 @@
+import z from 'zod';
+export declare const searchElement: (languageServices: import("../..").LikeC4LanguageServices) => [string, {
+    inputSchema?: {
+        search: z.ZodString;
+    } | undefined;
+}, (args: {
+    search: string;
+}, extra: import("@modelcontextprotocol/sdk/shared/protocol").RequestHandlerExtra<import("@modelcontextprotocol/sdk/types").ServerRequest, import("@modelcontextprotocol/sdk/types").ServerNotification>) => import("@modelcontextprotocol/sdk/types").CallToolResult | Promise<import("@modelcontextprotocol/sdk/types").CallToolResult>];

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

@@ -0,0 +1,105 @@
+import { ifilter } from "@likec4/core/utils";
+import z from "zod";
+import { likec4Tool } from "../utils.js";
+const searchResultSchema = z.array(
+  z.discriminatedUnion("type", [
+    z.object({
+      type: z.literal("logical"),
+      id: z.string().describe("Element ID (FQN)"),
+      kind: z.string(),
+      title: z.string(),
+      shape: z.string(),
+      project: z.string().describe("Project name"),
+      tags: z.array(z.string())
+    }),
+    z.object({
+      type: z.literal("deployment-node"),
+      id: z.string().describe("Deployment ID (FQN)"),
+      kind: z.string(),
+      title: z.string(),
+      shape: z.string(),
+      project: z.string().describe("Project name"),
+      tags: z.array(z.string())
+    })
+  ])
+);
+export const searchElement = likec4Tool({
+  name: "search-element",
+  annotations: {
+    readOnlyHint: true
+  },
+  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 "#")
+
+Returns array of found elements with:
+- type (logical or deployment-node)
+- id (FQN)
+- kind
+- title
+- shape
+- project name this element belongs to
+- assigned tags
+
+Can be used for further requests (like read-element or read-project-summary)
+`.trimStart(),
+  inputSchema: {
+    search: z.string().min(2, "Search must be at least 2 characters long")
+  },
+  outputSchema: {
+    found: searchResultSchema
+  }
+}, async (languageServices, args) => {
+  const projects = languageServices.projects();
+  const found = [];
+  let search = args.search.toLowerCase();
+  let predicate;
+  if (search.startsWith("kind:")) {
+    search = search.slice(5);
+    predicate = (el) => el.kind.toLowerCase().includes(search);
+  } else if (search.startsWith("shape:")) {
+    search = search.slice(6);
+    predicate = (el) => el.shape.toLowerCase().includes(search);
+  } else if (search.startsWith("#")) {
+    search = search.slice(1);
+    predicate = (el) => el.tags.some((tag) => tag.toLowerCase().includes(search));
+  } else {
+    predicate = (el) => el.id.toLowerCase().includes(search) || el.title.toLowerCase().includes(search);
+  }
+  for (const project of projects) {
+    try {
+      const model = await languageServices.computedModel(project.id);
+      for (const el of ifilter(model.elements(), predicate)) {
+        found.push({
+          type: "logical",
+          id: el.id,
+          kind: el.kind,
+          title: el.title,
+          shape: el.shape,
+          project: project.id,
+          tags: [...el.tags]
+        });
+      }
+      for (const el of ifilter(model.deployment.nodes(), predicate)) {
+        found.push({
+          type: "deployment-node",
+          id: el.id,
+          kind: el.kind,
+          title: el.title,
+          shape: el.shape,
+          project: project.id,
+          tags: [...el.tags]
+        });
+      }
+    } catch (error) {
+      console.error(`Error searching in project ${project.id}:`, error);
+    }
+  }
+  return {
+    found
+  };
+});

package/dist/mcp/utils.d.ts

@@ -1,35 +1,18 @@
-import { type Any, type aux, type ProjectId } from '@likec4/core';
-import { type ElementModel, type LikeC4ViewModel } from '@likec4/core/model';
+import type { RequestHandlerExtra } from '@modelcontextprotocol/sdk/shared/protocol.js';
+import type { ServerNotification, ServerRequest, ToolAnnotations } from '@modelcontextprotocol/sdk/types.js';
+import type { z, ZodRawShape, ZodTypeAny } from 'zod';
+import type { ToolCallback } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { LikeC4LanguageServices } from '../LikeC4LanguageServices';
-export declare function elementResource<A extends Any = Any>(languageServices: LikeC4LanguageServices, el: ElementModel<A>, projectId?: aux.ProjectId<A>): {
-    id: any;
-    parent: {
-        id: any;
-        title: any;
-        kind: any;
-    } | null;
-    projectId: any;
-    title: any;
-    kind: any;
-    shape: any;
-    technology: any;
-    description: any;
-    tags: any;
-    children: any;
-    relations: {
-        incoming: any;
-        outgoing: any;
-    };
-    views: any;
-    sourceFile: import("../protocol").Locate.Res;
-};
-export declare function modelViewResource(languageServices: LikeC4LanguageServices, view: LikeC4ViewModel<aux.Any>, projectId?: ProjectId): {
-    id: any;
-    title: any;
-    projectId: any;
-    viewType: LikeC4ViewModel<aux.Any>;
-    description: any;
-    tags: any;
-    nodes: any;
-    sourceFile: import("../protocol").Locate.Res;
-};
+export declare const logger: any;
+type ToolResult<Out extends undefined | ZodRawShape = undefined> = Out extends ZodRawShape ? z.objectOutputType<Out, ZodTypeAny> : string;
+type LikeC4ToolCallback<Args extends undefined | ZodRawShape, Out extends undefined | ZodRawShape> = Args extends ZodRawShape ? (languageServices: LikeC4LanguageServices, args: z.objectOutputType<Args, ZodTypeAny>, extra: RequestHandlerExtra<ServerRequest, ServerNotification>) => Promise<ToolResult<Out>> : (languageServices: LikeC4LanguageServices, extra: RequestHandlerExtra<ServerRequest, ServerNotification>) => Promise<ToolResult<Out>>;
+export declare function likec4Tool<InputArgs extends ZodRawShape, OutputArgs extends ZodRawShape, Cb extends LikeC4ToolCallback<InputArgs, OutputArgs>>(config: {
+    name: string;
+    description?: string;
+    inputSchema?: InputArgs;
+    outputSchema?: OutputArgs;
+    annotations?: ToolAnnotations;
+}, cb: Cb): (languageServices: LikeC4LanguageServices) => [string, {
+    inputSchema?: InputArgs;
+}, ToolCallback<InputArgs>];
+export {};

package/dist/mcp/utils.js

@@ -1,104 +1,44 @@
-import { _type, imap, toArray } from "@likec4/core";
-export function elementResource(languageServices, el, projectId) {
-  return {
-    id: el.id,
-    parent: !el.parent ? null : {
-      id: el.parent.id,
-      title: el.parent.title,
-      kind: el.parent.kind
-    },
-    projectId,
-    title: el.title,
-    kind: el.kind,
-    shape: el.shape,
-    technology: el.technology,
-    description: el.description,
-    tags: el.tags,
-    children: toArray(imap(el.children(), (c) => ({
-      id: c.id,
-      title: c.title,
-      kind: el.kind
-    }))),
-    relations: {
-      incoming: toArray(imap(el.incoming(), (r) => ({
-        id: r.id,
-        title: r.title,
-        description: r.description,
-        technology: r.technology,
-        source: {
-          id: r.source.id,
-          title: r.source.title,
-          kind: r.source.kind
-        },
-        ...r.target.id === el.id ? {
-          type: "direct"
-        } : {
-          type: "implicit, to nested",
-          target: {
-            id: r.target.id,
-            title: r.target.title,
-            kind: r.target.kind
-          }
-        }
-      }))),
-      outgoing: toArray(imap(el.outgoing(), (r) => ({
-        id: r.id,
-        title: r.title,
-        description: r.description,
-        technology: r.technology,
-        target: {
-          id: r.target.id,
-          title: r.target.title,
-          kind: r.target.kind
-        },
-        ...r.source.id === el.id ? {
-          type: "direct"
-        } : {
-          type: "implicit, from nested",
-          source: {
-            id: r.source.id,
-            title: r.source.title,
-            kind: r.source.kind
-          }
-        }
-      })))
-    },
-    views: toArray(imap(el.views(), (v) => ({
-      id: v.id,
-      title: v.title
-    }))),
-    sourceFile: languageServices.locate({
-      element: el.id,
-      projectId
-    })
-  };
+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;
+  return (languageServices) => [
+    name,
+    rest,
+    mkcallTool(name, languageServices, cb)
+  ];
 }
-export function modelViewResource(languageServices, view, projectId) {
-  return {
-    id: view.id,
-    title: view.title,
-    projectId,
-    viewType: view[_type],
-    description: view.$view.description ?? "",
-    tags: view.tags,
-    nodes: toArray(imap(view.nodes(), (node) => ({
-      id: node.id,
-      title: node.title,
-      represents: node.element ? {
-        element: node.element.id
-      } : {}
-    }))),
-    sourceFile: languageServices.locate({
-      view: view.id,
-      projectId
-    })
-    // edges: toArray(imap(view.edges(), edge => ({
-    //   id: edge.id,
-    //   title: edge.title,
-    // }))),
-    // elements: toArray(imap(view.elements(), el => ({
-    //   id: el.id,
-    //   title: el.title,
-    // }))),
+function mkcallTool(name, languageServices, cb) {
+  const tool = cb.bind(null, languageServices);
+  return async function callTool(args, extra) {
+    logger.debug("Calling tool {name}", { name, args });
+    try {
+      const result = await tool.call(null, args, extra);
+      if (typeof result === "string") {
+        return {
+          content: [{
+            type: "text",
+            text: result
+          }]
+        };
+      }
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(result)
+        }],
+        structuredContent: result
+      };
+    } catch (err) {
+      logger.error(`Tool ${name} failed`, { err });
+      return {
+        content: [{
+          type: "text",
+          text: loggable(err)
+        }],
+        isError: true
+      };
+    }
   };
 }

package/dist/model/model-parser-where.d.ts

@@ -1,3 +1,4 @@
 import type * as c4 from '@likec4/core';
 import { ast } from '../ast';
 export declare function parseWhereClause(astNode: ast.WhereExpression): c4.WhereOperator;
+export declare function createBinaryOperator(operator: Lowercase<ast.WhereBinaryExpression['operator']>, left: c4.WhereOperator, right: c4.WhereOperator | null): c4.WhereOperator;

package/dist/model/model-parser-where.js

@@ -45,32 +45,38 @@ export function parseWhereClause(astNode) {
       const left = parseWhereClause(astNode.left);
       const right = parseWhereClause(astNode.right);
       const operator = astNode.operator.toLowerCase();
-      switch (operator) {
-        case "and": {
-          const operands = [
-            isAndOperator(left) ? left.and : left,
-            isAndOperator(right) ? right.and : right
-          ].flat();
-          invariant(isNonEmptyArray(operands), "Expected non-empty array");
-          return {
-            and: operands
-          };
-        }
-        case "or": {
-          const operands = [
-            isOrOperator(left) ? left.or : left,
-            isOrOperator(right) ? right.or : right
-          ].flat();
-          invariant(isNonEmptyArray(operands), "Expected non-empty array");
-          return {
-            or: operands
-          };
-        }
-        default:
-          nonexhaustive(operator);
-      }
+      return createBinaryOperator(operator, left, right);
     }
     default:
       nonexhaustive(astNode);
   }
 }
+export function createBinaryOperator(operator, left, right) {
+  if (right === null) {
+    return left;
+  }
+  switch (operator) {
+    case "and": {
+      const operands = [
+        isAndOperator(left) ? left.and : left,
+        isAndOperator(right) ? right.and : right
+      ].flat();
+      invariant(isNonEmptyArray(operands), "Expected non-empty array");
+      return {
+        and: operands
+      };
+    }
+    case "or": {
+      const operands = [
+        isOrOperator(left) ? left.or : left,
+        isOrOperator(right) ? right.or : right
+      ].flat();
+      invariant(isNonEmptyArray(operands), "Expected non-empty array");
+      return {
+        or: operands
+      };
+    }
+    default:
+      nonexhaustive(operator);
+  }
+}