@likec4/language-server 1.42.1 → 1.44.0

package/dist/mcp/tools/_common.js

@@ -0,0 +1,49 @@
+import { URI } from 'vscode-uri';
+import * as z from 'zod/v3';
+import { ProjectsManager } from '../../workspace';
+import { logger } from '../utils';
+export const locationSchema = z.object({
+    path: z.string().describe('Path to the file'),
+    range: z.object({
+        start: z.object({
+            line: z.number(),
+            character: z.number(),
+        }),
+        end: z.object({
+            line: z.number(),
+            character: z.number(),
+        }),
+    }).describe('Range in the file'),
+}).nullable();
+export const projectIdSchema = z.string()
+    .refine((_v) => true)
+    .optional()
+    .default(ProjectsManager.DefaultProjectId)
+    .describe('Project id (optional, will use "default" if not specified)');
+export const includedInViewsSchema = z.array(z.object({
+    id: z.string().describe('View id'),
+    title: z.string().describe('View title'),
+    type: z.enum(['element', 'deployment', 'dynamic']).describe('View type'),
+}));
+export const includedInViews = (views) => {
+    return [...views].map(v => ({
+        id: v.id,
+        title: v.titleOrId,
+        type: v.$view._type,
+    }));
+};
+export const mkLocate = (languageServices, projectId) => (params) => {
+    try {
+        const loc = languageServices.locate({ projectId, ...params });
+        return loc
+            ? {
+                path: URI.parse(loc.uri).fsPath,
+                range: loc.range,
+            }
+            : null;
+    }
+    catch (e) {
+        logger.debug(`Failed to locate {params}`, { error: e, params });
+        return null;
+    }
+};

package/dist/mcp/tools/find-relationships.d.ts

@@ -1,13 +1,12 @@
-import z from 'zod';
+import * as z from 'zod/v3';
 export declare const findRelationships: (languageServices: import("../..").LikeC4LanguageServices) => [string, {
     inputSchema?: {
         element1: z.ZodString;
         element2: z.ZodString;
-        project: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodString, ProjectId, string>>>;
-    } | undefined;
+        project: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodString, import("@likec4/core").ProjectId, string>>>;
+    };
 }, (args: {
-    [x: string]: any;
-    element1?: unknown;
-    element2?: unknown;
-    project?: unknown;
-}, 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>];
+    project: string & import("type-fest/source/tagged").Tag<"ProjectID", never>;
+    element1: string;
+    element2: string;
+}, extra: import("@modelcontextprotocol/sdk/shared/protocol.js").RequestHandlerExtra<import("@modelcontextprotocol/sdk/types.js").ServerRequest, import("@modelcontextprotocol/sdk/types.js").ServerNotification>) => import("@modelcontextprotocol/sdk/types.js").CallToolResult | Promise<import("@modelcontextprotocol/sdk/types.js").CallToolResult>];

package/dist/mcp/tools/find-relationships.js

@@ -0,0 +1,150 @@
+import { modelConnection } from '@likec4/core/model';
+import { invariant, isSameHierarchy } from '@likec4/core/utils';
+import * as z from 'zod/v3';
+import { likec4Tool } from '../utils';
+import { includedInViews, includedInViewsSchema, locationSchema, mkLocate, projectIdSchema } from './_common';
+const endpointSchema = z.object({
+    id: z.string(),
+    title: z.string(),
+    kind: z.string(),
+});
+const searchResultSchema = z.object({
+    type: z.enum(['direct', 'indirect']).describe('Type of relationship, "direct" for direct relationships, "indirect" for relationships through nested elements'),
+    source: endpointSchema,
+    target: endpointSchema,
+    kind: z.string().nullable().describe('Relationship kind'),
+    title: z.string().nullable().describe('Relationship title'),
+    description: z.string().nullable().describe('Relationship description'),
+    technology: z.string().nullable().describe('Relationship technology'),
+    tags: z.array(z.string()).describe('Relationship tags'),
+    includedInViews: includedInViewsSchema.describe('Views that include this relationship'),
+    sourceLocation: locationSchema,
+});
+export const findRelationships = likec4Tool({
+    name: 'find-relationships',
+    annotations: {
+        readOnlyHint: true,
+        idempotentHint: true,
+        title: 'Find relationships between two elements',
+    },
+    description: `
+Find relationships between two LikeC4 elements within a project.
+
+What it does:
+- Finds both direct relationships (element1 ↔ element2) and indirect ones that arise via containment (e.g. via nested elements).
+- Returns rich metadata for each relationship and where it appears in views.
+
+Inputs:
+- element1: string — Element ID (FQN)
+- element2: string — Element ID (FQN)
+- project: string (optional, defaults to "default") — Project id
+
+Output:
+- found: Relationship[]
+
+Relationship (object) fields:
+- type: "direct" | "indirect" — direct is between the specified endpoints; indirect is via nested elements
+- source: Endpoint
+- target: Endpoint
+- kind: string|null — relationship kind from the model
+- title: string|null — relationship title if provided
+- description: string|null — relationship description text
+- technology: string|null — relationship technology
+- tags: string[] — relationship tags
+- includedInViews: View[] — views where this relationship appears
+- sourceLocation: { path: string, range: { start: { line: number, character: number }, end: { line: number, character: number } } } | null
+
+Endpoint (object) fields:
+- id: string — Element ID (FQN)
+- title: string — element title
+- kind: string — element kind
+
+View (object) fields:
+- id: string — view identifier
+- title: string — view title
+- type: "element" | "deployment" | "dynamic"
+
+Notes:
+- Read-only, idempotent; does not mutate the model. May trigger UI navigation in supporting clients.
+- The order of results is not guaranteed.
+
+Example:
+Request:
+{
+  "element1": "shop.frontend",
+  "element2": "shop.backend",
+  "project": "default"
+}
+
+Response:
+{
+  "found": [
+    {
+      "type": "direct",
+      "source": { "id": "shop.frontend", "title": "Frontend", "kind": "component" },
+      "target": { "id": "shop.backend", "title": "Backend", "kind": "component" },
+      "kind": "sync",
+      "title": "Calls",
+      "description": "Frontend calls Backend",
+      "technology": "HTTP",
+      "tags": ["public"],
+      "includedInViews": [
+        { "id": "system-overview", "title": "System Overview", "type": "element" }
+      ],
+      "sourceLocation": {
+        "path": "/abs/path/project/model.c4",
+        "range": { "start": { "line": 12, "character": 0 }, "end": { "line": 14, "character": 0 } }
+      }
+    }
+  ]
+}
+`,
+    inputSchema: {
+        element1: z.string().describe('Element ID (FQN)'),
+        element2: z.string().describe('Element ID (FQN)'),
+        project: projectIdSchema,
+    },
+    outputSchema: {
+        found: z.array(searchResultSchema),
+    },
+}, async (languageServices, args) => {
+    const projectId = languageServices.projectsManager.ensureProjectId(args.project);
+    if (isSameHierarchy(args.element1, args.element2)) {
+        throw new Error('No relationships possible between parent-child');
+    }
+    const found = [];
+    const model = await languageServices.computedModel(projectId);
+    const el1 = model.findElement(args.element1);
+    invariant(el1, `Element "${args.element1}" not found in project "${projectId}"`);
+    const el2 = model.findElement(args.element2);
+    invariant(el2, `Element "${args.element2}" not found in project "${projectId}"`);
+    const locate = mkLocate(languageServices, projectId);
+    const relationships = modelConnection.findConnection(el1, el2, 'both').flatMap(c => [...c.relations]);
+    for (const relationship of relationships) {
+        const isDirect = (relationship.source === el1 && relationship.target === el2)
+            || (relationship.source === el2 && relationship.target === el1);
+        found.push({
+            type: isDirect ? 'direct' : 'indirect',
+            source: {
+                id: relationship.source.id,
+                title: relationship.source.title,
+                kind: relationship.source.kind,
+            },
+            target: {
+                id: relationship.target.id,
+                title: relationship.target.title,
+                kind: relationship.target.kind,
+            },
+            kind: relationship.kind,
+            title: relationship.title,
+            description: relationship.description.text,
+            technology: relationship.technology,
+            tags: [...relationship.tags],
+            includedInViews: includedInViews(relationship.views()),
+            sourceLocation: locate({ relation: relationship.id }),
+        });
+    }
+    return {
+        found,
+    };
+});

package/dist/mcp/tools/list-projects.d.ts

@@ -1,6 +1,6 @@
-import z from 'zod';
+import * as z from 'zod/v3';
 export declare const listProjects: (languageServices: import("../..").LikeC4LanguageServices) => [string, {
-    inputSchema?: z.ZodRawShape | undefined;
+    inputSchema?: z.ZodRawShape;
 }, (args: {
     [x: string]: any;
-}, 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>];
+}, extra: import("@modelcontextprotocol/sdk/shared/protocol.js").RequestHandlerExtra<import("@modelcontextprotocol/sdk/types.js").ServerRequest, import("@modelcontextprotocol/sdk/types.js").ServerNotification>) => import("@modelcontextprotocol/sdk/types.js").CallToolResult | Promise<import("@modelcontextprotocol/sdk/types.js").CallToolResult>];

package/dist/mcp/tools/list-projects.js

@@ -0,0 +1,62 @@
+import * as z from 'zod/v3';
+import { likec4Tool } from '../utils';
+export const listProjects = likec4Tool({
+    name: 'list-projects',
+    description: `
+List LikeC4 projects discoverable in the current workspace.
+
+Request:
+- No input parameters.
+
+Response (JSON object):
+- projects: Project[]
+
+Project (object) fields:
+- id: string — stable project identifier
+- title: string — human-readable project title
+- folder: string — absolute path to the project root
+- sources: string[] — absolute file paths of related documents
+
+Notes:
+- Read-only, idempotent, no side effects.
+- Safe to call repeatedly.
+
+Example response:
+{
+  "projects": [
+    {
+      "id": "docs",
+      "title": "Documentation",
+      "folder": "/abs/path/to/workspace/docs",
+      "sources": [
+        "/abs/path/to/workspace/docs/model/contexts.likec4",
+        "/abs/path/to/workspace/docs/model/relations.likec4"
+      ]
+    }
+  ]
+}
+`,
+    annotations: {
+        readOnlyHint: true,
+        idempotentHint: true,
+        title: 'List projects',
+    },
+    outputSchema: {
+        projects: z.array(z.object({
+            id: z.string(),
+            title: z.string(),
+            folder: z.string(),
+            sources: z.array(z.string()),
+        })),
+    },
+}, async (languageServices) => {
+    const projects = languageServices.projects();
+    return {
+        projects: projects.map(p => ({
+            id: p.id,
+            title: p.title,
+            folder: p.folder.fsPath,
+            sources: p.documents.map(d => d.fsPath),
+        })),
+    };
+});

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

@@ -1,11 +1,10 @@
-import z from 'zod';
+import * as z from 'zod/v3';
 export declare const openView: (languageServices: import("../..").LikeC4LanguageServices) => [string, {
     inputSchema?: {
         viewId: z.ZodString;
-        project: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodString, ProjectId, string>>>;
-    } | undefined;
+        project: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodString, import("@likec4/core").ProjectId, string>>>;
+    };
 }, (args: {
-    [x: string]: any;
-    viewId?: unknown;
-    project?: unknown;
-}, 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>];
+    project: string & import("type-fest/source/tagged").Tag<"ProjectID", never>;
+    viewId: string;
+}, extra: import("@modelcontextprotocol/sdk/shared/protocol.js").RequestHandlerExtra<import("@modelcontextprotocol/sdk/types.js").ServerRequest, import("@modelcontextprotocol/sdk/types.js").ServerNotification>) => import("@modelcontextprotocol/sdk/types.js").CallToolResult | Promise<import("@modelcontextprotocol/sdk/types.js").CallToolResult>];

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

@@ -0,0 +1,52 @@
+import * as z from 'zod/v3';
+import { likec4Tool } from '../utils';
+import { locationSchema, mkLocate, projectIdSchema } from './_common';
+export const openView = likec4Tool({
+    name: 'open-view',
+    description: `
+Open a LikeC4 view in the editor's preview panel.
+
+Request:
+- viewId: string — view id (name)
+- project: string (optional) — project id. Defaults to "default" if omitted.
+
+Response (JSON object):
+- location: { path: string, range: { start: { line: number, character: number }, end: { line: number, character: number } } } | null — source location of the view if available
+
+Notes:
+- Read-only and idempotent with respect to the project model. Triggers a UI action in the editor.
+- Only one preview panel can be open at a time.
+
+Example response:
+{
+  "location": {
+    "path": "/abs/path/project/model.c4",
+    "range": { "start": { "line": 10, "character": 0 }, "end": { "line": 30, "character": 0 } }
+  }
+}
+`,
+    annotations: {
+        readOnlyHint: true,
+        idempotentHint: true,
+        title: 'Open view in preview panel',
+    },
+    inputSchema: {
+        viewId: z.string().describe('View id (name)'),
+        project: projectIdSchema,
+    },
+    outputSchema: {
+        location: locationSchema,
+    },
+}, async (languageServices, args) => {
+    const projectId = languageServices.projectsManager.ensureProjectId(args.project);
+    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 ${projectId}`);
+    }
+    await languageServices.views.openView(view.id, projectId);
+    const locate = mkLocate(languageServices, projectId);
+    return {
+        location: locate({ view: view.id }),
+    };
+});

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

@@ -1,11 +1,10 @@
-import z from 'zod';
+import * as z from 'zod/v3';
 export declare const readDeployment: (languageServices: import("../..").LikeC4LanguageServices) => [string, {
     inputSchema?: {
         id: z.ZodString;
-        project: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodString, ProjectId, string>>>;
-    } | undefined;
+        project: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodString, import("@likec4/core").ProjectId, string>>>;
+    };
 }, (args: {
-    [x: string]: any;
-    id?: unknown;
-    project?: unknown;
-}, 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>];
+    id: string;
+    project: string & import("type-fest/source/tagged").Tag<"ProjectID", never>;
+}, extra: import("@modelcontextprotocol/sdk/shared/protocol.js").RequestHandlerExtra<import("@modelcontextprotocol/sdk/types.js").ServerRequest, import("@modelcontextprotocol/sdk/types.js").ServerNotification>) => import("@modelcontextprotocol/sdk/types.js").CallToolResult | Promise<import("@modelcontextprotocol/sdk/types.js").CallToolResult>];

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

@@ -0,0 +1,132 @@
+import { invariant } from '@likec4/core';
+import * as z from 'zod/v3';
+import { likec4Tool } from '../utils';
+import { includedInViews, includedInViewsSchema, locationSchema, mkLocate, projectIdSchema } from './_common';
+export const readDeployment = likec4Tool({
+    name: 'read-deployment',
+    description: `
+Read details about a deployment node or a deployed instance in a LikeC4 project.
+
+What it does:
+- Returns metadata about a deployment entity (node or instance), including kind, tags, color/shape, children, which views include it, and its source location.
+
+Inputs:
+- id: string — Deployment id (FQN)
+- project: string (optional, defaults to "default") — Project id
+
+Output fields:
+- type: "deployment-node" | "deployed-instance"
+- id: string — Deployment id (FQN)
+- kind: string — Deployment node kind, or element kind for deployed instances
+- name: string — Name of the deployment entity
+- title: string — Title of the deployment entity
+- description: string|null — Description text
+- technology: string|null — Technology info, if any
+- tags: string[] — Tags assigned to this entity
+- project: string — Project id
+- metadata: Record<string, string>
+- shape: string — Rendered shape
+- color: string — Rendered color
+- children: string[] — Child deployment ids (empty for instances)
+- includedInViews: View[] — Views that include this entity
+- instanceof: { id: string, title: string, kind: string } | null — If type is "deployed-instance", the referenced element
+- sourceLocation: { path: string, range: { start: { line: number, character: number }, end: { line: number, character: number } } } | null
+
+View (object) fields:
+- id: string — view identifier
+- title: string — view title
+- type: "element" | "deployment" | "dynamic"
+
+Notes:
+- Read-only, idempotent; does not mutate the model.
+
+Example request:
+{ "id": "k8s.cluster.frontend", "project": "default" }
+
+Example response (deployed instance):
+{
+  "type": "deployed-instance",
+  "id": "k8s.cluster.frontend",
+  "kind": "k8s.pod",
+  "name": "frontend",
+  "title": "Frontend Pod",
+  "description": null,
+  "technology": "Kubernetes",
+  "tags": ["prod"],
+  "project": "default",
+  "metadata": {},
+  "shape": "rectangle",
+  "color": "#2F80ED",
+  "children": [],
+  "includedInViews": [
+    { "id": "runtime-overview", "title": "Runtime Overview", "type": "deployment" }
+  ],
+  "instanceof": { "id": "shop.frontend", "title": "Frontend", "kind": "component" },
+  "sourceLocation": {
+    "path": "/abs/path/project/model.c4",
+    "range": { "start": { "line": 10, "character": 0 }, "end": { "line": 25, "character": 0 } }
+  }
+}
+`,
+    annotations: {
+        readOnlyHint: true,
+        idempotentHint: true,
+        title: 'Read deployment entity',
+    },
+    inputSchema: {
+        id: z.string().describe('Deployment id (FQN)'),
+        project: projectIdSchema,
+    },
+    outputSchema: {
+        type: z.enum(['deployment-node', 'deployed-instance']),
+        id: z.string().describe('Deployment id (FQN)'),
+        kind: z.string().describe('Deployment node kind, or element kind for deployed instances'),
+        name: z.string(),
+        title: z.string(),
+        description: z.string().nullable(),
+        technology: z.string().nullable(),
+        tags: z.array(z.string()),
+        project: z.string(),
+        metadata: z.record(z.union([z.string(), z.array(z.string())])),
+        shape: z.string(),
+        color: z.string(),
+        children: z.array(z.string()).describe('Children of this deployment node (Array of Deployment ids)'),
+        includedInViews: includedInViewsSchema.describe('Views that include this deployment node'),
+        instanceof: z.object({
+            id: z.string().describe('Element ID (FQN)'),
+            title: z.string(),
+            kind: z.string(),
+        }).nullable().describe('If type is "deployed-instance", the referenced element'),
+        sourceLocation: locationSchema,
+    },
+}, async (languageServices, args) => {
+    const projectId = languageServices.projectsManager.ensureProjectId(args.project);
+    const model = await languageServices.computedModel(projectId);
+    const element = model.deployment.findElement(args.id);
+    invariant(element, `Deployment entity "${args.id}" not found in project "${projectId}"`);
+    const locate = mkLocate(languageServices, projectId);
+    return {
+        type: element.isInstance() ? 'deployed-instance' : 'deployment-node',
+        id: element.id,
+        name: element.name,
+        kind: element.kind,
+        title: element.title,
+        description: element.description.text,
+        technology: element.technology,
+        tags: [...element.tags],
+        project: projectId,
+        metadata: element.getMetadata(),
+        shape: element.shape,
+        color: element.color,
+        children: element.isInstance() ? [] : [...element.children()].map(c => c.id),
+        includedInViews: includedInViews(element.views()),
+        instanceof: element.isInstance()
+            ? {
+                id: element.element.id,
+                title: element.element.title,
+                kind: element.element.kind,
+            }
+            : null,
+        sourceLocation: locate({ deployment: element.id }),
+    };
+});

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

@@ -1,11 +1,10 @@
-import z from 'zod';
+import * as z from 'zod/v3';
 export declare const readElement: (languageServices: import("../..").LikeC4LanguageServices) => [string, {
     inputSchema?: {
         id: z.ZodString;
-        project: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodString, ProjectId, string>>>;
-    } | undefined;
+        project: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodString, import("@likec4/core").ProjectId, string>>>;
+    };
 }, (args: {
-    [x: string]: any;
-    id?: unknown;
-    project?: unknown;
-}, 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>];
+    id: string;
+    project: string & import("type-fest/source/tagged").Tag<"ProjectID", never>;
+}, extra: import("@modelcontextprotocol/sdk/shared/protocol.js").RequestHandlerExtra<import("@modelcontextprotocol/sdk/types.js").ServerRequest, import("@modelcontextprotocol/sdk/types.js").ServerNotification>) => import("@modelcontextprotocol/sdk/types.js").CallToolResult | Promise<import("@modelcontextprotocol/sdk/types.js").CallToolResult>];