@likec4/language-server 1.43.0 → 1.44.0

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

@@ -1,205 +0,0 @@
-import z from "zod";
-import { likec4Tool } from "../utils.mjs";
-import { locationSchema, mkLocate, projectIdSchema } from "./_common.mjs";
-const modelRef = (node) => {
-  if (node.hasElement()) {
-    return node.element.id;
-  }
-  if (node.hasDeployment()) {
-    return node.deployment.id;
-  }
-  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: `
-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,
-    idempotentHint: true,
-    title: "Read view"
-  },
-  inputSchema: {
-    viewId: z.string().describe("View id (name)"),
-    project: projectIdSchema
-  },
-  outputSchema: {
-    id: z.string(),
-    type: z.enum(["element", "deployment", "dynamic"]).describe("View type"),
-    title: z.string(),
-    description: z.string().nullable(),
-    tags: z.array(z.string()),
-    project: z.string(),
-    nodes: z.array(nodeSchema),
-    edges: z.array(
-      z.object({
-        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("Edge represents relationship between nodes"),
-    sourceLocation: locationSchema
-  }
-}, async (languageServices, args) => {
-  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 ?? view.id,
-    description: view.description.text,
-    tags: [...view.tags],
-    project: project.id,
-    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",
-          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",
-          kind: node.deployment.kind,
-          deploymentId: node.deployment.id,
-          children: [...node.children()].map((c) => c.id)
-        };
-      }
-      if (node.hasElement()) {
-        return {
-          ...base,
-          type: "element",
-          elementId: node.element.id,
-          kind: node.element.kind,
-          children: [...node.children()].flatMap((c) => modelRef(c) ?? [])
-        };
-      }
-      return [];
-    }),
-    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.mjs

@@ -1,171 +0,0 @@
-import { ifilter } from "@likec4/core/utils";
-import z from "zod";
-import { likec4Tool, logger } from "../utils.mjs";
-import { includedInViews, includedInViewsSchema } from "./_common.mjs";
-const searchResultSchema = z.array(
-  z.discriminatedUnion("type", [
-    z.object({
-      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(),
-      includedInViews: includedInViewsSchema,
-      metadata: z.record(z.union([z.string(), z.array(z.string())])),
-      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(),
-      includedInViews: includedInViewsSchema,
-      metadata: z.record(z.union([z.string(), z.array(z.string())])),
-      tags: z.array(z.string())
-    })
-  ])
-);
-export const searchElement = likec4Tool({
-  name: "search-element",
-  annotations: {
-    readOnlyHint: true,
-    idempotentHint: true,
-    title: "Search elements"
-  },
-  description: `
-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
-
-Request:
-- search: string \u2014 at least 2 characters
-
-Response (JSON object):
-- total: number - total number of results
-- found: Result[] - returns top 20 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[], metadata: Record<string, string> }
-- type = "deployment-node": { id: string, name: string, kind: string, title: string, technology: string|null, shape: string, project: string, includedInViews: View[], tags: string[], metadata: Record<string, 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:
-{
-  "total": 1,
-  "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"],
-      "metadata": {}
-    }
-  ]
-}
-`,
-  inputSchema: {
-    search: z.string().min(2, "Search must be at least 2 characters long")
-  },
-  outputSchema: {
-    total: z.number(),
-    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);
-    logger.debug("search by kind: {search}", { search });
-    predicate = (el) => el.kind.toLowerCase() === search;
-  } else if (search.startsWith("shape:")) {
-    search = search.slice(6);
-    logger.debug("search by shape: {search}", { search });
-    predicate = (el) => el.shape.toLowerCase() === search;
-  } else if (search.startsWith("meta:")) {
-    search = search.slice(5);
-    logger.debug("search by metadata: {search}", { search });
-    predicate = (el) => !!el.getMetadata(search);
-  } else if (search.startsWith("#")) {
-    search = search.slice(1);
-    logger.debug("search by tag: {search}", { search });
-    predicate = (el) => el.tags.some((tag) => tag.toLowerCase().includes(search));
-  } else {
-    logger.debug("search by id/title: {search}", { search });
-    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(), (e) => !e.imported && predicate(e))) {
-        found.push({
-          type: "element",
-          project: project.id,
-          id: el.id,
-          name: el.name,
-          kind: el.kind,
-          title: el.title,
-          technology: el.technology,
-          shape: el.shape,
-          tags: [...el.tags],
-          metadata: el.getMetadata(),
-          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,
-          tags: [...el.tags],
-          metadata: el.getMetadata(),
-          includedInViews: includedInViews(el.views())
-        });
-      }
-    } catch (error) {
-      logger.error(`Error searching in project ${project.id}:`, { error });
-    }
-  }
-  return {
-    total: found.length,
-    found: found.slice(0, 20)
-  };
-});

package/dist/mcp/utils.mjs

@@ -1,47 +0,0 @@
-import { loggable } from "@likec4/log";
-import { logger as mainLogger } from "../logger.mjs";
-export const logger = mainLogger.getChild("mcp");
-export function likec4Tool(config, cb) {
-  const { name, description, ...rest } = config;
-  return (languageServices) => [
-    name,
-    {
-      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}, args: {args}", { 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: err instanceof Error ? err.message : loggable(err)
-        }],
-        isError: true
-      };
-    }
-  });
-}

package/dist/model/builder/MergedExtends.mjs

@@ -1,76 +0,0 @@
-import {
-  hasAtLeast,
-  isEmpty,
-  unique
-} from "remeda";
-export class MergedExtends {
-  mergedData = /* @__PURE__ */ new Map();
-  mergeMetadata(existing, incoming) {
-    const result = { ...existing };
-    for (const [key, incomingValue] of Object.entries(incoming)) {
-      const existingValue = result[key];
-      if (existingValue === void 0) {
-        result[key] = incomingValue;
-        continue;
-      }
-      const existingArray = Array.isArray(existingValue) ? existingValue : [existingValue];
-      const incomingArray = Array.isArray(incomingValue) ? incomingValue : [incomingValue];
-      const merged = unique([...existingArray, ...incomingArray]);
-      result[key] = merged.length === 1 ? merged[0] : merged;
-    }
-    return result;
-  }
-  merge(parsedExtends) {
-    for (const parsedExtend of parsedExtends) {
-      const { id, links, tags, metadata } = parsedExtend;
-      const existing = this.mergedData.get(id) ?? {
-        links: [],
-        tags: [],
-        metadata: {}
-      };
-      if (links) {
-        existing.links.push(...links);
-      }
-      if (tags) {
-        existing.tags = unique([
-          ...existing.tags,
-          ...tags
-        ]);
-      }
-      if (metadata) {
-        existing.metadata = this.mergeMetadata(existing.metadata, metadata);
-      }
-      this.mergedData.set(id, existing);
-    }
-  }
-  applyExtended(el) {
-    const extendData = this.mergedData.get(el.id);
-    if (!extendData) {
-      return el;
-    }
-    let links = extendData.links;
-    if (el.links && el.links.length > 0) {
-      links = [
-        ...el.links,
-        ...links
-      ];
-    }
-    let tags = extendData.tags;
-    if (el.tags && el.tags.length > 0) {
-      tags = unique([
-        ...el.tags,
-        ...tags
-      ]);
-    }
-    let metadata = extendData.metadata;
-    if (el.metadata) {
-      metadata = this.mergeMetadata(el.metadata, extendData.metadata);
-    }
-    return {
-      ...el,
-      tags: hasAtLeast(tags, 1) ? tags : null,
-      links: hasAtLeast(links, 1) ? links : null,
-      ...!isEmpty(metadata) && { metadata }
-    };
-  }
-}

package/dist/model/builder/MergedSpecification.mjs

@@ -1,205 +0,0 @@
-import { exact, FqnRef } from "@likec4/core/types";
-import { isNonEmptyArray, MultiMap, nameFromFqn } from "@likec4/core/utils";
-import {
-  isEmpty,
-  isNonNullish,
-  unique
-} from "remeda";
-import { logger, logWarnError } from "../../logger.mjs";
-import { assignTagColors } from "./assignTagColors.mjs";
-export class MergedSpecification {
-  specs = {
-    elements: {},
-    deployments: {},
-    relationships: {},
-    colors: {}
-  };
-  tags;
-  globals = {
-    predicates: {},
-    dynamicPredicates: {},
-    styles: {}
-  };
-  imports = new MultiMap(Set);
-  constructor(docs) {
-    const tags = {};
-    for (const doc of docs) {
-      const {
-        c4Specification: spec,
-        c4Globals,
-        c4Imports
-      } = doc;
-      Object.assign(tags, spec.tags);
-      Object.assign(this.specs.elements, spec.elements);
-      Object.assign(this.specs.relationships, spec.relationships);
-      Object.assign(this.specs.colors, spec.colors);
-      Object.assign(this.specs.deployments, spec.deployments);
-      Object.assign(this.globals.predicates, c4Globals.predicates);
-      Object.assign(this.globals.dynamicPredicates, c4Globals.dynamicPredicates);
-      Object.assign(this.globals.styles, c4Globals.styles);
-      for (const [projectId, fqn] of c4Imports) {
-        this.imports.set(projectId, fqn);
-      }
-    }
-    this.tags = assignTagColors(tags);
-  }
-  /**
-   * Converts a parsed model into a C4 model element.
-   */
-  toModelElement = ({
-    tags,
-    links,
-    style,
-    id,
-    kind,
-    title,
-    description,
-    technology,
-    summary,
-    metadata
-  }) => {
-    try {
-      const __kind = this.specs.elements[kind];
-      if (!__kind) {
-        logger.warn`No kind '${kind}' found for ${id}`;
-        return null;
-      }
-      technology ??= __kind.technology;
-      description ??= __kind.description;
-      summary ??= __kind.summary;
-      links ??= __kind.links;
-      title = title === nameFromFqn(id) && __kind.title ? __kind.title : title;
-      if (__kind.tags && isNonEmptyArray(__kind.tags)) {
-        tags = tags ? unique([
-          ...__kind.tags,
-          ...tags
-        ]) : __kind.tags;
-      }
-      return exact({
-        metadata: metadata && !isEmpty(metadata) ? metadata : void 0,
-        notation: __kind.notation,
-        style: exact({
-          ...__kind.style,
-          ...style
-        }),
-        links,
-        tags,
-        summary,
-        technology,
-        description,
-        title,
-        kind,
-        id
-      });
-    } catch (e) {
-      logWarnError(e);
-    }
-    return null;
-  };
-  /**
-   * Converts a parsed model into a C4 model relation.
-   */
-  toModelRelation = ({
-    astPath: _astPath,
-    // omit
-    source,
-    target,
-    kind,
-    links,
-    id,
-    ...model
-  }) => {
-    if (isNonNullish(kind) && this.specs.relationships[kind]) {
-      return {
-        ...this.specs.relationships[kind],
-        ...model,
-        ...links && { links },
-        source,
-        target,
-        kind,
-        id
-      };
-    }
-    return {
-      ...links && { links },
-      ...model,
-      source,
-      target,
-      id
-    };
-  };
-  /**
-   * Converts a parsed deployment model into a C4 deployment model
-   */
-  toDeploymentElement = (parsed) => {
-    if ("element" in parsed && !("kind" in parsed)) {
-      return {
-        ...parsed,
-        element: FqnRef.flatten(parsed.element)
-      };
-    }
-    if ("element" in parsed) {
-      logger.warn`Invalid ParsedAstDeployment ${parsed.id}, has both element and kind properties`;
-      return null;
-    }
-    try {
-      const __kind = this.specs.deployments[parsed.kind];
-      if (!__kind) {
-        logger.warn`No kind ${parsed.kind} found for ${parsed.id}`;
-        return null;
-      }
-      let {
-        id,
-        style,
-        title,
-        ...rest
-      } = parsed;
-      title = title === nameFromFqn(parsed.id) && __kind.title ? __kind.title : title;
-      return exact({
-        ...__kind,
-        ...rest,
-        title,
-        style: exact({
-          ...__kind.style,
-          ...style
-        }),
-        id
-      });
-    } catch (e) {
-      logWarnError(e);
-    }
-    return null;
-  };
-  /**
-   * Converts a parsed deployment relation into a C4 deployment relation.
-   */
-  toDeploymentRelation = ({
-    astPath: _astPath,
-    // omit
-    source,
-    target,
-    kind,
-    links,
-    id,
-    ...model
-  }) => {
-    if (isNonNullish(kind) && this.specs.relationships[kind]) {
-      return {
-        ...this.specs.relationships[kind],
-        ...model,
-        ...links && { links },
-        source,
-        target,
-        kind,
-        id
-      };
-    }
-    return {
-      ...links && { links },
-      ...model,
-      source,
-      target,
-      id
-    };
-  };
-}