@likec4/language-server 1.49.0 → 1.50.0

package/dist/_chunks/{index.d.mts → module.d.mts}

@@ -1,10 +1,9 @@
-import { ChangeView, DidRequestOpenViewNotification, Locate } from "../protocol.mjs";
-import { LikeC4Services, LikeC4SharedServices } from "../module.mjs";
+import { h as Locate, n as ChangeView, o as DidRequestOpenViewNotification } from "./protocol.mjs";
 import * as langium from "langium";
-import { AstNode, AstNodeDescription, AsyncDisposable, BuildOptions, Cancellation, CstNode, DefaultAstNodeDescriptionProvider, DefaultDocumentValidator, DefaultIndexManager, DefaultLangiumDocuments, DefaultNameProvider, DefaultScopeComputation, DefaultScopeProvider, DefaultValueConverter, DefaultWorkspaceManager, DiagnosticInfo, Disposable, FileSelector, FileSystemNode, FileSystemProvider, GrammarAST, JSDocDocumentationProvider, LangiumDocument, LangiumDocumentFactory, MaybePromise, PrecomputedScopes, Reference, ReferenceDescription, ReferenceInfo, Scope, SimpleCache, Stream, URI, ValidationOptions, ValueType, WorkspaceCache } from "langium";
+import { AstNode, AstNodeDescription, AsyncDisposable, BuildOptions, Cancellation, CstNode, DefaultAstNodeDescriptionProvider, DefaultDocumentValidator, DefaultIndexManager, DefaultLangiumDocuments, DefaultNameProvider, DefaultScopeComputation, DefaultScopeProvider, DefaultValueConverter, DefaultWorkspaceManager, DiagnosticInfo, Disposable, FileSelector, FileSystemNode, FileSystemProvider, GrammarAST, JSDocDocumentationProvider, LangiumDocument, LangiumDocumentFactory, MaybePromise, Module, PrecomputedScopes, Reference, ReferenceDescription, ReferenceInfo, Scope, SimpleCache, Stream, URI, ValidationOptions, ValueType, WorkspaceCache } from "langium";
 import { DefaultWeakMap, MultiMap as MultiMap$1 } from "@likec4/core/utils";
 import { CompletionItemKind, Diagnostic, DocumentSymbol, FormattingOptions, Hover, Location, Range, SemanticTokens, SemanticTokensDelta, SymbolKind, TextEdit } from "vscode-languageserver-types";
-import { AbstractFormatter, AbstractSemanticTokenProvider, AstNodeHoverProvider, CodeActionProvider, CodeLensProvider, CompletionAcceptor, CompletionContext, DefaultCompletionProvider, DefaultDocumentHighlightProvider, DefaultWorkspaceSymbolProvider, DocumentLinkProvider, DocumentSymbolProvider, FormattingRegion, LangiumSharedServices, NextFeature, NodeKindProvider, SemanticTokenAcceptor } from "langium/lsp";
+import { AbstractFormatter, AbstractSemanticTokenProvider, AstNodeHoverProvider, CodeActionProvider, CodeLensProvider, CompletionAcceptor, CompletionContext, DefaultCompletionProvider, DefaultDocumentHighlightProvider, DefaultSharedModuleContext, DefaultWorkspaceSymbolProvider, DocumentLinkProvider, DocumentSymbolProvider, FormattingRegion, LangiumServices, LangiumSharedServices, NextFeature, NodeKindProvider, PartialLangiumServices, SemanticTokenAcceptor } from "langium/lsp";
 import { GraphvizLayouter, QueueGraphvizLayoter } from "@likec4/layouts";
 import * as c4 from "@likec4/core";
 import { ComputedView, DiagramView, LayoutType, LayoutedView, NonEmptyArray, NonEmptyReadonlyArray, ProjectId, Tag, UnknownComputed, UnknownLayouted, UnknownParsed, ViewChange, ViewId } from "@likec4/core";
@@ -13,7 +12,7 @@ import { ElementModel, LikeC4Model } from "@likec4/core/model";
 import { IncludeConfig, LikeC4ProjectConfig, LikeC4ProjectConfigInput } from "@likec4/config";
 import { URI as URI$2 } from "vscode-uri";
 import { LikeC4Styles } from "@likec4/core/styles";
-import { CancellationToken, CodeLens, CodeLensParams, DocumentHighlight, DocumentLink, DocumentLinkParams, DocumentSymbolParams, WorkspaceFolder } from "vscode-languageserver";
+import { CancellationToken, CodeLens, CodeLensParams, Connection, DocumentHighlight, DocumentLink, DocumentLinkParams, DocumentSymbolParams, WorkspaceFolder } from "vscode-languageserver";
 import { CancellationToken as CancellationToken$1, CodeAction, CodeActionParams, Command, SemanticTokensDeltaParams, SemanticTokensParams, SemanticTokensRangeParams } from "vscode-languageserver-protocol";
 import { Fqn as Fqn$1, GuardedBy, LayoutedView as LayoutedView$1, ProjectId as ProjectId$1, ViewId as ViewId$1 } from "@likec4/core/types";
 import { CancellationToken as CancellationToken$2 } from "vscode-jsonrpc";
@@ -23,10 +22,23 @@ import { ConditionalPick, MergeExclusive, Simplify, Tagged, ValueOf, Writable }
 import { ServerOptions } from "@modelcontextprotocol/sdk/server/index.js";
 
 //#region src/documentation/documentation-provider.d.ts
+/**
+ * Provides documentation for LikeC4 AST nodes, extending JSDoc parsing
+ * with specialized formatting for deployment nodes, deployed instances, and elements.
+ */
 declare class LikeC4DocumentationProvider extends JSDocDocumentationProvider {
   private parser;
   private locator;
+  /**
+   * Creates a new documentation provider.
+   * @param services - The LikeC4 language services.
+   */
   constructor(services: LikeC4Services);
+  /**
+   * Returns documentation for the given AST node (deployment nodes, deployed instances, elements, or JSDoc fallback).
+   * @param node - The AST node to document.
+   * @returns Formatted documentation string, or undefined if none.
+   */
   getDocumentation(node: AstNode): string | undefined;
 }
 //#endregion
@@ -1971,7 +1983,10 @@ declare class MergedSpecification {
   readonly globals: c4.ModelGlobals;
   readonly imports: MultiMap$1<c4.ProjectId, c4.Fqn, Set<c4.Fqn>>;
   readonly projectId: c4.ProjectId | undefined;
-  constructor(docs: ReadonlyArray<ParsedLikeC4LangiumDocument>);
+  readonly inferTechFromIcon: boolean;
+  constructor(docs: ReadonlyArray<ParsedLikeC4LangiumDocument>, opts?: {
+    inferTechFromIcon?: boolean;
+  });
   /**
    * Converts a parsed model into a C4 model element.
    */
@@ -2025,10 +2040,35 @@ declare class MergedSpecification {
 declare class LastSeenArtifacts {
   #private;
   constructor(services: LikeC4Services);
+  /**
+   * Cache the last successful merged specification for its project.
+   * @param specification - MergedSpecification to store (by projectId).
+   * @returns The same specification (stores in internal map when projectId is set).
+   */
   rememberSpecification(specification: MergedSpecification): MergedSpecification;
+  /**
+   * Cache the last successful computed model and its styles for the project.
+   * @param model - LikeC4Model.Computed to store (by projectId).
+   * @returns The same model (stores model and styles in internal maps).
+   */
   rememberModel<M extends LikeC4Model.Computed>(model: M): M;
+  /**
+   * Returns the last seen merged specification for the given project, if available.
+   * @param projectId - Project id to look up.
+   * @returns MergedSpecification or undefined.
+   */
   specification(projectId: c4.ProjectId): MergedSpecification | undefined;
+  /**
+   * Returns the last seen styles for the given project, if available.
+   * @param projectId - Project id to look up.
+   * @returns LikeC4Styles or undefined.
+   */
   styles(projectId: c4.ProjectId): LikeC4Styles | undefined;
+  /**
+   * Returns the last seen computed model for the given project, if available.
+   * @param projectId - Project id to look up.
+   * @returns LikeC4Model.Computed or undefined.
+   */
   model(projectId: c4.ProjectId): LikeC4Model.Computed | undefined;
 }
 //#endregion
@@ -2043,11 +2083,16 @@ interface LikeC4ModelBuilder extends Disposable {
 }
 //#endregion
 //#region src/model/model-locator.d.ts
+/** Result of locating a view: document, view AST, and view block node. */
 type ViewLocateResult = {
   doc: ParsedLikeC4LangiumDocument;
   view: ParsedAstView;
   viewAst: LikeC4View;
 };
+/**
+ * Locates elements, views, and documents in the LikeC4 model by FQN or AST node.
+ * Used by LSP features (hover, go-to-definition, document tags, etc.).
+ */
 declare class LikeC4ModelLocator {
   private services;
   private fqnIndex;
@@ -2060,16 +2105,33 @@ declare class LikeC4ModelLocator {
    * Returns the parsed documents
    */
   private documents;
+  /**
+   * Get parsed element by AST node or by FQN (and optional projectId).
+   * @param args - Either [element AST], [fqn], or [fqn, projectId]
+   * @returns { projectId, element, document } or null if not found
+   */
   getParsedElement(...args: [Element] | [c4.Fqn] | [c4.Fqn, c4.ProjectId]): null | {
     projectId: c4.ProjectId;
     element: ParsedAstElement;
     document: LangiumDocument;
   };
   private findParsedElementByFqnIn;
+  /**
+   * Get LSP Location for an element by FQN (and optional projectId).
+   * @param fqn - Fully qualified name (may include project prefix)
+   * @param projectId - Optional project scope
+   * @returns Location or null
+   */
   locateElement(fqn: c4.Fqn, projectId?: c4.ProjectId | undefined): Location | null;
   locateDeploymentElement(deploymentFqn: c4.DeploymentFqn, projectId?: c4.ProjectId | undefined): Location | null;
   locateRelation(relationId: c4.RelationId, projectId?: c4.ProjectId): Location | null;
   locateViewAst(viewId: c4.ViewId, projectId?: c4.ProjectId | undefined): null | ViewLocateResult;
+  /**
+   * Get LSP Location for a view by id (and optional projectId).
+   * @param viewId - View id
+   * @param projectId - Optional project scope
+   * @returns Location or null
+   */
   locateView(viewId: c4.ViewId, projectId?: c4.ProjectId): Location | null;
   /**
    * Returns an array of tags with their name, color, range and whether they are defined in the specification or not.
@@ -2169,6 +2231,39 @@ interface LikeC4Views {
   adhocView(predicates: AdhocViewPredicate[], projectId?: ProjectId | undefined): Promise<LayoutedView>;
 }
 //#endregion
+//#region src/index.d.ts
+type StartLanguageServerOptions = {
+  /**
+   * The Language Server Protocol connection to use.
+   */
+  connection?: Connection;
+  /**
+   * Whether to enable the file system watcher.
+   * @default true
+   */
+  enableWatcher?: boolean;
+  /**
+   * @default true
+   */
+  enableTelemetry?: boolean;
+  /**
+   * Whether to enable the MCP server.
+   * @default 'sse'
+   */
+  enableMCP?: false | 'stdio' | 'sse' | {
+    port: number;
+  };
+  /**
+   * Whether to enable manual layouts, stored in json5 files.
+   * @default true
+   */
+  enableManualLayouts?: boolean;
+};
+declare function startLanguageServer$1(options?: StartLanguageServerOptions): {
+  shared: LikeC4SharedServices;
+  likec4: LikeC4Services;
+};
+//#endregion
 //#region src/model/parser/Base.d.ts
 type ParserLevel = 'base' | 'model' | 'deployment' | 'fqnref' | 'relation' | 'views' | 'globals' | 'imports' | 'specification';
 declare class BaseParser {
@@ -3039,15 +3134,41 @@ declare class LikeC4DocumentSymbolProvider implements DocumentSymbolProvider {
 }
 //#endregion
 //#region src/lsp/HoverProvider.d.ts
+/**
+ * Provides hover content for LikeC4 AST nodes (elements, tags, relations, etc.)
+ * in the language server. Resolves model references and formats markdown hover text.
+ */
 declare class LikeC4HoverProvider extends AstNodeHoverProvider {
   protected services: LikeC4Services;
   private parser;
   private locator;
+  /** @param services - LikeC4 language services (parser, locator, etc.) */
   constructor(services: LikeC4Services);
   protected getAstNodeHoverContent(node: AstNode): MaybePromise<Hover | undefined>;
+  /**
+   * Builds hover content for an element node (title, summary, model details and view links).
+   * @param node - The element AST node to generate hover content for.
+   * @returns Hover information with markdown content, or undefined if element not found.
+   */
   protected getElementHover(node: Element): MaybePromise<Hover | undefined>;
+  /**
+   * Builds markdown hover content for an element model (relationship counts and links to views).
+   * @param model - The element model containing relationship and view information.
+   * @param projectId - The project identifier for constructing view links.
+   * @returns Markdown string with model details, or undefined if no details available.
+   */
   protected getElementModelHover(model: ElementModel, projectId: ProjectId): string | undefined;
+  /**
+   * Builds hover content for a deployment node (id, title, kind, summary).
+   * @param node - The deployment node AST node to generate hover content for.
+   * @returns Hover information with markdown content.
+   */
   protected getDeploymentNodeHover(node: DeploymentNode): MaybePromise<Hover | undefined>;
+  /**
+   * Builds hover content for a deployed instance (instance id, element ref, title and kind).
+   * @param node - The deployed instance AST node to generate hover content for.
+   * @returns Hover information with markdown content showing instance details.
+   */
   protected getDeployedInstanceHover(node: DeployedInstance): MaybePromise<Hover | undefined>;
 }
 //#endregion
@@ -3104,4 +3225,123 @@ declare class NodeKindProvider$1 implements NodeKindProvider {
 //#region src/shared/WorkspaceSymbolProvider.d.ts
 declare class WorkspaceSymbolProvider extends DefaultWorkspaceSymbolProvider {}
 //#endregion
-export { ProjectsManager as $, LikeC4ScopeComputation as A, NoFileSystem as B, LastSeenArtifacts as C, LikeC4WorkspaceManager as D, LikeC4ScopeProvider as E, LikeC4MCPServerModuleContext as F, FileSystemProvider$1 as G, NoLikeC4ManualLayouts as H, LikeC4Formatter as I, LikeC4ManualLayouts as J, FileSystemWatcher as K, WithLikeC4ManualLayouts as L, LikeC4DocumentValidator as M, LikeC4MCPServer as N, LangiumDocuments as O, LikeC4MCPServerFactory as P, ProjectData as Q, WithChokidarWatcher as R, LikeC4ModelBuilder as S, FqnIndex as T, FileNode as U, NoFileSystemWatcher as V, FileSystemModuleContext as W, ManualLayoutsSnapshot as X, LikeC4ManualLayoutsModuleContext as Y, Project as Z, LikeC4Views as _, LikeC4CodeActionProvider as a, LikeC4ModelLocator as b, LikeC4DocumentLinkProvider as c, LikeC4CodeLensProvider as d, LikeC4DocumentationProvider as et, LikeC4LanguageServices as f, LikeC4ModelParser as g, DocumentParser as h, LikeC4SemanticTokenProvider as i, LikeC4NameProvider as j, IndexManager as k, LikeC4DocumentHighlightProvider as l, LikeC4ValueConverter as m, NodeKindProvider$1 as n, LikeC4HoverProvider as o, LikeC4ModelChanges as p, FileSystemWatcherModuleContext as q, Rpc as r, LikeC4DocumentSymbolProvider as s, WorkspaceSymbolProvider as t, LikeC4CompletionProvider as u, WithMCPServer as v, DeploymentsIndex as w, ViewLocateResult as x, NoMCPServer as y, WithFileSystem as z };
+//#region src/module.d.ts
+type LanguageServicesContext = Omit<DefaultSharedModuleContext, 'fileSystemProvider'> & FileSystemModuleContext & LikeC4MCPServerModuleContext & LikeC4ManualLayoutsModuleContext;
+interface LikeC4AddedSharedServices {
+  lsp: {
+    NodeKindProvider: NodeKindProvider$1;
+    WorkspaceSymbolProvider: WorkspaceSymbolProvider;
+  };
+  workspace: {
+    Cache: WorkspaceCache<string, any>;
+    ProjectsManager: ProjectsManager;
+    IndexManager: IndexManager;
+    LangiumDocuments: LangiumDocuments;
+    WorkspaceManager: LikeC4WorkspaceManager;
+    FileSystemProvider: FileSystemProvider$1;
+    FileSystemWatcher: FileSystemWatcher;
+    ManualLayouts: LikeC4ManualLayouts;
+  };
+}
+type LikeC4SharedServices = LangiumSharedServices & LikeC4AddedSharedServices;
+/**
+ * Declaration of custom services - add your own service classes here.
+ */
+interface LikeC4AddedServices {
+  documentation: {
+    DocumentationProvider: LikeC4DocumentationProvider;
+  };
+  validation: {
+    DocumentValidator: LikeC4DocumentValidator;
+  };
+  Rpc: Rpc;
+  mcp: {
+    Server: LikeC4MCPServer;
+    ServerFactory: LikeC4MCPServerFactory;
+  };
+  likec4: {
+    LanguageServices: LikeC4LanguageServices;
+    Views: LikeC4Views;
+    Layouter: QueueGraphvizLayoter;
+    DeploymentsIndex: DeploymentsIndex;
+    FqnIndex: FqnIndex;
+    ModelParser: LikeC4ModelParser;
+    ModelBuilder: LikeC4ModelBuilder;
+    ModelLocator: LikeC4ModelLocator;
+    ModelChanges: LikeC4ModelChanges;
+    LastSeen: LastSeenArtifacts;
+  };
+  lsp: {
+    CompletionProvider: LikeC4CompletionProvider;
+    DocumentHighlightProvider: LikeC4DocumentHighlightProvider;
+    DocumentSymbolProvider: LikeC4DocumentSymbolProvider;
+    SemanticTokenProvider: LikeC4SemanticTokenProvider;
+    HoverProvider: LikeC4HoverProvider;
+    CodeLensProvider: LikeC4CodeLensProvider;
+    DocumentLinkProvider: LikeC4DocumentLinkProvider;
+    Formatter: LikeC4Formatter;
+    CodeActionProvider: LikeC4CodeActionProvider;
+  };
+  references: {
+    NameProvider: LikeC4NameProvider;
+    ScopeComputation: LikeC4ScopeComputation;
+    ScopeProvider: LikeC4ScopeProvider;
+  };
+  shared?: LikeC4SharedServices;
+  parser: {
+    ValueConverter: LikeC4ValueConverter;
+  };
+}
+type LikeC4Services = LangiumServices & LikeC4AddedServices;
+/**
+ * Most probably you don't need to use this function directly.
+ * Use {@link createLanguageServices} instead.
+ * @internal
+ */
+declare function createLikeC4Module(context: LikeC4MCPServerModuleContext): Module<LikeC4Services, PartialLangiumServices & LikeC4AddedServices>;
+/**
+ * Create and initialize likec4 language services with the given context
+ * @example
+ * ```ts
+ * const { shared, likec4 } = createLanguageServices({
+ *   ...WithFileSystem(enableWatcher = true),
+ *   ...WithLikeC4ManualLayouts(),
+ *   ...NoMcpServer(),
+ * });
+ * ```
+ *
+ * It is possible to extend/override the context with additional modules
+ * See Langium documentation for more details (or at the CliContext in packages/likec4/src/language/module.ts).
+ */
+declare function createLanguageServices(): {
+  shared: LikeC4SharedServices;
+  likec4: LikeC4Services;
+};
+declare function createLanguageServices(context: Partial<LanguageServicesContext>): {
+  shared: LikeC4SharedServices;
+  likec4: LikeC4Services;
+};
+declare function createLanguageServices(context: Partial<LanguageServicesContext>): {
+  shared: LikeC4SharedServices;
+  likec4: LikeC4Services;
+};
+declare function createLanguageServices<I1, I extends I1 & LikeC4Services>(context: Partial<LanguageServicesContext>, module: Module<I, I1> | undefined): {
+  shared: LikeC4SharedServices;
+  likec4: I;
+};
+declare function createLanguageServices<I1, I2, I extends I1 & I2 & LikeC4Services>(context: Partial<LanguageServicesContext>, module: Module<I, I1>, module2: Module<I, I2>): {
+  shared: LikeC4SharedServices;
+  likec4: I;
+};
+declare function createLanguageServices<I1, I2, I3, I extends I1 & I2 & I3 & LikeC4Services>(context: Partial<LanguageServicesContext>, module: Module<I, I1>, module2: Module<I, I2>, module3: Module<I, I3>): {
+  shared: LikeC4SharedServices;
+  likec4: I;
+};
+/**
+ * Most probably you don't need to use this function directly.
+ * Use {@link createLanguageServices} instead.
+ * @internal
+ */
+declare function createSharedServices(context?: Partial<LanguageServicesContext>): LikeC4SharedServices;
+//#endregion
+export { FileNode as A, ProjectsManager as B, LikeC4MCPServerModuleContext as C, NoFileSystem as D, WithFileSystem as E, LikeC4ManualLayouts as F, LikeC4ManualLayoutsModuleContext as I, ManualLayoutsSnapshot as L, FileSystemProvider$1 as M, FileSystemWatcher as N, NoFileSystemWatcher as O, FileSystemWatcherModuleContext as P, Project as R, LikeC4MCPServerFactory as S, WithChokidarWatcher as T, LikeC4ModelBuilder as _, createLanguageServices as a, LangiumDocuments as b, LikeC4LanguageServices as c, startLanguageServer$1 as d, LikeC4Views as f, ViewLocateResult as g, LikeC4ModelLocator as h, LikeC4SharedServices as i, FileSystemModuleContext as j, NoLikeC4ManualLayouts as k, DocumentParser as l, NoMCPServer as m, LikeC4AddedServices as n, createLikeC4Module as o, WithMCPServer as p, LikeC4Services as r, createSharedServices as s, LanguageServicesContext as t, LikeC4ModelParser as u, FqnIndex as v, WithLikeC4ManualLayouts as w, LikeC4MCPServer as x, LikeC4WorkspaceManager as y, ProjectData as z };