@likec4/language-server 1.42.1 → 1.44.0

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

@@ -0,0 +1,177 @@
+import { ifilter } from '@likec4/core/utils';
+import * as z from 'zod/v3';
+import { likec4Tool, logger } from '../utils';
+import { includedInViews, includedInViewsSchema } from './_common';
+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 — 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 — view identifier
+- title: string — 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);
+            // filter elements
+            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()),
+                });
+            }
+            // filter deployment nodes
+            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.d.ts

@@ -1,9 +1,9 @@
 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 { z, ZodRawShape, ZodTypeAny } from 'zod/v3';
 import type { ToolCallback } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { LikeC4LanguageServices } from '../LikeC4LanguageServices';
-export declare const logger: any;
+export declare const logger: import("@logtape/logtape").Logger;
 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: {

package/dist/mcp/utils.js

@@ -0,0 +1,48 @@
+import { loggable } from '@likec4/log';
+import { logger as mainLogger } from '../logger';
+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.d.ts

@@ -2,11 +2,12 @@ import type * as c4 from '@likec4/core';
 import type { ParsedAstExtend } from '../../ast';
 export declare class MergedExtends {
     private mergedData;
+    private mergeMetadata;
     merge(parsedExtends: ParsedAstExtend[]): void;
     applyExtended<E extends {
         id: string;
         tags?: readonly string[] | null;
         links?: readonly c4.Link[] | null;
-        metadata?: Record<string, string>;
+        metadata?: Record<string, string | string[]>;
     }>(el: E): E;
 }

package/dist/model/builder/MergedExtends.js

@@ -0,0 +1,74 @@
+import { hasAtLeast, isEmpty, unique, } from 'remeda';
+export class MergedExtends {
+    mergedData = new Map();
+    mergeMetadata(existing, incoming) {
+        const result = { ...existing };
+        for (const [key, incomingValue] of Object.entries(incoming)) {
+            const existingValue = result[key];
+            if (existingValue === undefined) {
+                result[key] = incomingValue;
+                continue;
+            }
+            // Convert both values to arrays to make merging easier.
+            const existingArray = Array.isArray(existingValue) ? existingValue : [existingValue];
+            const incomingArray = Array.isArray(incomingValue) ? incomingValue : [incomingValue];
+            // Merge and deduplicate based on value.
+            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.js

@@ -0,0 +1,175 @@
+import { assignTagColors } from '@likec4/core/styles';
+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';
+/**
+ * The `MergedSpecification` class is responsible for merging multiple parsed
+ * LikeC4Langium documents into a single specification. It consolidates tags,
+ * elements, deployments, relationships, and colors from the provided documents
+ * and provides methods to convert parsed models into C4 model elements and relations.
+ */
+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 : undefined,
+                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/buildModel.js

@@ -0,0 +1,176 @@
+import { isDeploymentNode, isGlobalFqn, } from '@likec4/core';
+import { resolveRulesExtendedViews } from '@likec4/core/compute-view';
+import { computeColorValues } from '@likec4/core/styles';
+import { _stage, _type, exact, FqnRef, isExtendsElementView } from '@likec4/core/types';
+import { compareNatural, parentFqn, sortByFqnHierarchically, } from '@likec4/core/utils';
+import { UriUtils } from 'langium';
+import { filter, flatMap, forEach, indexBy, isDefined, isNullish, isTruthy, keys, map, mapValues, omitBy, pipe, prop, reduce, } from 'remeda';
+import { logger } from '../../logger';
+import { MergedExtends } from './MergedExtends';
+import { MergedSpecification } from './MergedSpecification';
+/**
+ * Each document was parsed into a ParsedLikeC4LangiumDocument, where elements
+ * do not inherit styles from specification.
+ *
+ * This function builds a model from all documents, merging the specifications
+ * and globals, and applying the extends to the elements.
+ */
+export function buildModelData(project, docs) {
+    const c4Specification = new MergedSpecification(docs);
+    const customColors = mapValues(c4Specification.specs.colors, c => computeColorValues(c.color));
+    const metadataKeys = new Set();
+    const elementExtends = new MergedExtends();
+    const deploymentExtends = new MergedExtends();
+    const scanMetadataKeys = (obj) => {
+        if (obj?.metadata) {
+            keys(obj.metadata).forEach(key => metadataKeys.add(key));
+        }
+    };
+    const elements = pipe(docs, flatMap(d => {
+        elementExtends.merge(d.c4ExtendElements);
+        return map(d.c4Elements, c4Specification.toModelElement);
+    }), filter(isTruthy), 
+    // sort from root elements to nested, so that parent is always present
+    // Import to preserve the order from the source
+    sortByFqnHierarchically, reduce((acc, el) => {
+        const parent = parentFqn(el.id);
+        if (parent && isNullish(acc[parent])) {
+            logger.debug `No parent found for ${el.id}`;
+            return acc;
+        }
+        acc[el.id] = elementExtends.applyExtended(el);
+        scanMetadataKeys(acc[el.id]);
+        return acc;
+    }, {}));
+    const relations = pipe(docs, flatMap(d => map(d.c4Relations, c4Specification.toModelRelation)), filter((rel) => {
+        if (!rel)
+            return false;
+        const source = FqnRef.flatten(rel.source), target = FqnRef.flatten(rel.target);
+        if ((isNullish(elements[source]) && !isGlobalFqn(source)) ||
+            (isNullish(elements[target]) && !isGlobalFqn(target))) {
+            logger.debug `Invalid relation ${rel.id}
+  source: ${source} resolved: ${!!elements[source]}
+  target: ${target} resolved: ${!!elements[target]}\n`;
+            return false;
+        }
+        return true;
+    }), forEach(scanMetadataKeys), indexBy(prop('id')));
+    const deploymentElements = pipe(docs, flatMap(d => {
+        deploymentExtends.merge(d.c4ExtendDeployments);
+        return map(d.c4Deployments, c4Specification.toDeploymentElement);
+    }), filter(isTruthy), 
+    // sort from root elements to nested, so that parent is always present
+    // Import to preserve the order from the source
+    sortByFqnHierarchically, reduce((acc, el) => {
+        const parent = parentFqn(el.id);
+        if (parent && isNullish(acc[parent])) {
+            logger.debug `No parent found for deployment element ${el.id}`;
+            return acc;
+        }
+        acc[el.id] = isDeploymentNode(el) ? deploymentExtends.applyExtended(el) : el;
+        scanMetadataKeys(acc[el.id]);
+        return acc;
+    }, {}));
+    const deploymentRelations = pipe(docs, flatMap(d => map(d.c4DeploymentRelations, c4Specification.toDeploymentRelation)), filter((rel) => {
+        if (!rel)
+            return false;
+        if (isNullish(deploymentElements[rel.source.deployment]) || isNullish(deploymentElements[rel.target.deployment])) {
+            logger.debug `Invalid deployment relation ${rel.id}
+  source: ${rel.source.deployment} resolved: ${!!deploymentElements[rel.source.deployment]}
+  target: ${rel.target.deployment} resolved: ${!!deploymentElements[rel.target.deployment]}\n`;
+            return false;
+        }
+        return true;
+    }), reduce((acc, el) => {
+        if (isDefined(acc[el.id])) {
+            logger.debug `Duplicate deployment relation ${el.id}`;
+            return acc;
+        }
+        scanMetadataKeys(el);
+        acc[el.id] = el;
+        return acc;
+    }, {}));
+    function toC4View(doc) {
+        const docUri = doc.uri.toString();
+        return (parsedAstView) => {
+            let { id, title, description, 
+            // ignore this property
+            astPath: _ignore, 
+            // model should include discriminant __
+            ...model } = parsedAstView;
+            if (parsedAstView[_type] === 'element' && isNullish(title) && 'viewOf' in parsedAstView) {
+                title = elements[parsedAstView.viewOf]?.title ?? null;
+            }
+            if (isNullish(title) && id === 'index') {
+                title = 'Landscape view';
+            }
+            return {
+                ...omitBy(model, v => v === undefined),
+                [_stage]: 'parsed',
+                sourcePath: UriUtils.relative(project.folderUri, docUri),
+                docUri,
+                description,
+                title,
+                id,
+            };
+        };
+    }
+    const parsedViews = docs.flatMap(d => map(d.c4Views, toC4View(d)));
+    // Add index view if not present
+    if (!parsedViews.some(v => v.id === 'index')) {
+        parsedViews.unshift({
+            [_stage]: 'parsed',
+            [_type]: 'element',
+            id: 'index',
+            title: 'Landscape view',
+            description: null,
+            rules: [
+                {
+                    include: [
+                        {
+                            wildcard: true,
+                        },
+                    ],
+                },
+            ],
+        });
+    }
+    let views = pipe(parsedViews, indexBy(prop('id')));
+    if (parsedViews.some(isExtendsElementView)) {
+        views = resolveRulesExtendedViews(views);
+    }
+    return {
+        data: {
+            [_stage]: 'parsed',
+            projectId: project.id,
+            project: exact({
+                id: project.id,
+                title: project.config.title ?? project.config.name,
+                styles: project.config.styles,
+                manualLayouts: project.config.manualLayouts,
+            }),
+            specification: {
+                tags: c4Specification.tags,
+                elements: c4Specification.specs.elements,
+                relationships: mapValues(c4Specification.specs.relationships, ({ notation, technology, ...style }) => ({
+                    ...(notation && { notation }),
+                    ...(technology && { technology }),
+                    style,
+                })),
+                deployments: c4Specification.specs.deployments,
+                ...(metadataKeys.size > 0 && { metadataKeys: [...metadataKeys].sort(compareNatural) }),
+                customColors,
+            },
+            elements,
+            relations,
+            globals: c4Specification.globals,
+            views,
+            deployments: {
+                elements: deploymentElements,
+                relations: deploymentRelations,
+            },
+            imports: {},
+        },
+        imports: c4Specification.imports,
+    };
+}