@likec4/language-server 1.46.4 → 1.48.0

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

@@ -1,177 +0,0 @@
-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
-- <value>       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,18 +0,0 @@
-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/v3';
-import type { ToolCallback } from '@modelcontextprotocol/sdk/server/mcp.js';
-import type { LikeC4LanguageServices } from '../LikeC4LanguageServices';
-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: {
-    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,48 +0,0 @@
-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: loggable(err),
-                    }],
-                isError: true,
-            };
-        }
-    });
-}

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

@@ -1,13 +0,0 @@
-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 | string[]>;
-    }>(el: E): E;
-}

package/dist/model/builder/MergedExtends.js

@@ -1,74 +0,0 @@
-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.d.ts

@@ -1,32 +0,0 @@
-import type * as c4 from '@likec4/core';
-import { MultiMap } from '@likec4/core/utils';
-import type { ParsedAstDeployment, ParsedAstDeploymentRelation, ParsedAstElement, ParsedAstRelation, ParsedAstSpecification, ParsedLikeC4LangiumDocument } from '../../ast';
-/**
- * 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 declare class MergedSpecification {
-    readonly specs: Omit<ParsedAstSpecification, 'tags'>;
-    readonly tags: Readonly<Record<c4.Tag, c4.TagSpecification>>;
-    readonly globals: c4.ModelGlobals;
-    readonly imports: MultiMap<c4.ProjectId, c4.Fqn, Set<c4.Fqn>>;
-    constructor(docs: ReadonlyArray<ParsedLikeC4LangiumDocument>);
-    /**
-     * Converts a parsed model into a C4 model element.
-     */
-    toModelElement: ({ tags, links, style, id, kind, title, description, technology, summary, metadata, }: ParsedAstElement) => c4.Element | null;
-    /**
-     * Converts a parsed model into a C4 model relation.
-     */
-    toModelRelation: ({ astPath: _astPath, source, target, kind, links, id, ...model }: ParsedAstRelation) => c4.Relationship | null;
-    /**
-     * Converts a parsed deployment model into a C4 deployment model
-     */
-    toDeploymentElement: (parsed: ParsedAstDeployment) => c4.DeploymentElement | null;
-    /**
-     * Converts a parsed deployment relation into a C4 deployment relation.
-     */
-    toDeploymentRelation: ({ astPath: _astPath, source, target, kind, links, id, ...model }: ParsedAstDeploymentRelation) => c4.DeploymentRelationship | null;
-}

package/dist/model/builder/MergedSpecification.js

@@ -1,175 +0,0 @@
-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.d.ts

@@ -1,16 +0,0 @@
-import type * as c4 from '@likec4/core';
-import { type MultiMap } from '@likec4/core';
-import type { ParsedLikeC4LangiumDocument } from '../../ast';
-import type { Project } from '../../workspace/ProjectsManager';
-export type BuildModelData = {
-    data: c4.ParsedLikeC4ModelData;
-    imports: MultiMap<c4.ProjectId, c4.Fqn, Set<c4.Fqn>>;
-};
-/**
- * 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 declare function buildModelData(project: Project, docs: ReadonlyArray<ParsedLikeC4LangiumDocument>): BuildModelData;