@likec4/language-server 1.42.1 → 1.44.0

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.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.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,67 +0,0 @@
-import {
-  hasAtLeast,
-  isEmpty,
-  unique
-} from "remeda";
-export class MergedExtends {
-  mergedData = /* @__PURE__ */ new Map();
-  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 = {
-          ...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 = {
-        ...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
-    };
-  };
-}

package/dist/model/builder/assignTagColors.d.ts

@@ -1,7 +0,0 @@
-import type * as c4 from '@likec4/core/types';
-import type { ParsedAstSpecification } from '../../ast';
-/**
- * Colors are taken from the styles presets of the LikeC4
- */
-export declare const radixColors: string[];
-export declare function assignTagColors(tags: ParsedAstSpecification['tags']): Record<c4.Tag, c4.TagSpecification>;

package/dist/model/builder/assignTagColors.mjs

@@ -1,51 +0,0 @@
-import { compareNatural, nonNullable } from "@likec4/core/utils";
-import { concat, entries, isTruthy, map, pipe, prop, pullObject, sort } from "remeda";
-export const radixColors = [
-  "tomato",
-  "grass",
-  "blue",
-  "ruby",
-  "orange",
-  "indigo",
-  "pink",
-  "teal",
-  "purple",
-  "amber",
-  "crimson",
-  "red",
-  "lime",
-  "yellow",
-  "violet"
-];
-export function assignTagColors(tags) {
-  const tagsWithColors = [];
-  const tagsWithoutColors = [];
-  for (const [tag, spec] of entries(tags)) {
-    if (isTruthy(spec.color)) {
-      tagsWithColors.push({
-        tag,
-        spec: {
-          color: spec.color
-        }
-      });
-    } else {
-      tagsWithoutColors.push(tag);
-    }
-  }
-  return pipe(
-    tagsWithoutColors,
-    sort(compareNatural),
-    map((tag, idx) => {
-      const color = nonNullable(radixColors[idx % radixColors.length]);
-      return {
-        tag,
-        spec: {
-          color
-        }
-      };
-    }),
-    concat(tagsWithColors),
-    sort((a, b) => compareNatural(a.tag, b.tag)),
-    pullObject(prop("tag"), prop("spec"))
-  );
-}