@sayknow-cli/coding-agent 0.3.16 → 0.4.1

package/dist/types/internal-urls/skill-protocol.d.ts

@@ -1,13 +0,0 @@
-import type { InternalResource, InternalUrl, ProtocolHandler } from "./types";
-/**
- * Validate that a path is safe (no traversal, no absolute paths).
- */
-export declare function validateRelativePath(relativePath: string): void;
-/**
- * Handler for skill:// URLs.
- */
-export declare class SkillProtocolHandler implements ProtocolHandler {
-    readonly scheme = "skill";
-    readonly immutable = true;
-    resolve(url: InternalUrl): Promise<InternalResource>;
-}

package/dist/types/internal-urls/types.d.ts

@@ -1,109 +0,0 @@
-/**
- * Types for the internal URL routing system.
- *
- * Internal URLs (agent://, artifact://, memory://, rule://, skc://, local://) are resolved by tools like read,
- * providing access to agent outputs and server resources without exposing filesystem paths.
- */
-/**
- * Raw resource payload returned by protocol handlers. The `immutable` flag is
- * applied by the router from {@link ProtocolHandler.immutable}, so handlers do
- * not need to set it themselves.
- */
-export interface InternalResource {
-    /** Canonical URL that was resolved */
-    url: string;
-    /** Resolved text content */
-    content: string;
-    /** MIME type: text/markdown, application/json, or text/plain */
-    contentType: "text/markdown" | "application/json" | "text/plain";
-    /** Content size in bytes */
-    size?: number;
-    /** Underlying filesystem path (for debugging, not exposed to agent) */
-    sourcePath?: string;
-    /** Additional notes about resolution */
-    notes?: string[];
-    /**
-     * True when the resolved content cannot be edited by the agent (e.g. sealed
-     * artifacts, harness docs, machine-generated memory summaries). Hashline
-     * anchors and similar edit affordances are suppressed for immutable
-     * resources. Mutable resources (e.g. local://) behave like editable files.
-     */
-    immutable?: boolean;
-}
-/**
- * Parsed internal URL with preserved host casing.
- */
-export interface InternalUrl extends URL {
-    /**
-     * Raw host segment extracted from input, preserving case.
-     */
-    rawHost: string;
-    /**
-     * Raw pathname extracted from input, preserving traversal markers before URL normalization.
-     */
-    rawPathname?: string;
-}
-/**
- * Caller-supplied context that the router threads into protocol handlers.
- *
- * Read tool calls `InternalUrlRouter.resolve(url, { cwd, settings, signal })`
- * so handlers can resolve relative defaults (e.g. `issue://N` → which repo?)
- * against the actual session that initiated the read, not whichever session
- * happens to be registered first in the global `AgentRegistry`.
- */
-export interface ResolveContext {
-    /** Working directory of the calling session. */
-    cwd?: string;
-    /** Settings of the calling session (used by `issue://`/`pr://` for cache TTLs). */
-    settings?: unknown;
-    /** Artifacts directory of the calling session. */
-    getArtifactsDir?: () => string | null;
-    /** Additional artifacts directories explicitly authorized for this caller (for parent/child agent trees). */
-    getAuthorizedArtifactsDirs?: () => readonly string[];
-    /** Caller's abort signal. */
-    signal?: AbortSignal;
-}
-/**
- * Caller context for write operations dispatched to host-owned URI handlers.
- * Mirrors {@link ResolveContext} so handlers that share read/write state can
- * accept the same shape.
- */
-export interface WriteContext {
-    /** Working directory of the calling session. */
-    cwd?: string;
-    /** Caller's abort signal. */
-    signal?: AbortSignal;
-}
-/**
- * Handler for a specific internal URL scheme (e.g., agent://, memory://).
- */
-export interface ProtocolHandler {
-    /** The scheme this handler processes (without trailing ://) */
-    readonly scheme: string;
-    /**
-     * Whether resources produced by this handler are immutable (cannot be
-     * edited by the agent). When true, callers suppress hashline anchors and
-     * other edit affordances. When false, resources behave like editable files.
-     */
-    readonly immutable: boolean;
-    /**
-     * Resolve an internal URL to its content. The router stamps the
-     * {@link InternalResource.immutable} flag from {@link ProtocolHandler.immutable}.
-     *
-     * @param url Parsed URL object
-     * @param context Optional caller context. Handlers that depend on caller
-     *   identity (working directory, settings) **MUST** consume this in
-     *   preference to global state.
-     * @throws Error with user-friendly message if resolution fails
-     */
-    resolve(url: InternalUrl, context?: ResolveContext): Promise<InternalResource>;
-    /**
-     * Optional write hook. When present, the write tool dispatches
-     * `write(url, content)` to this handler instead of writing to a filesystem
-     * path. The handler is responsible for any persistence and validation.
-     *
-     * Handlers that omit this method are treated as read-only; the write tool
-     * surfaces a clear "not writable" error when invoked against them.
-     */
-    write?(url: InternalUrl, content: string, context?: WriteContext): Promise<void>;
-}

package/dist/types/lsp/client.d.ts

@@ -1,66 +0,0 @@
-import type { LspClient, ServerConfig } from "./types";
-/**
- * Configure the idle timeout for LSP clients.
- * @param ms - Timeout in milliseconds, or null/undefined to disable
- */
-export declare function setIdleTimeout(ms: number | null | undefined): void;
-export declare function isIdleCheckerActiveForTests(): boolean;
-/** Timeout for warmup initialize requests (5 seconds) */
-export declare const WARMUP_TIMEOUT_MS = 5000;
-/**
- * Get or create an LSP client for the given server configuration and working directory.
- * @param config - Server configuration
- * @param cwd - Working directory
- * @param initTimeoutMs - Optional timeout for the initialize request (defaults to 30s)
- */
-export declare function getOrCreateClient(config: ServerConfig, cwd: string, initTimeoutMs?: number): Promise<LspClient>;
-/**
- * Ensure a file is opened in the LSP client.
- * Sends didOpen notification if the file is not already tracked.
- */
-export declare function ensureFileOpen(client: LspClient, filePath: string, signal?: AbortSignal): Promise<void>;
-/**
- * Wait for the server's initial project loading to complete.
- * Races the server's $/progress tracking against the abort signal.
- * Returns immediately if loading already completed or timed out.
- */
-export declare function waitForProjectLoaded(client: LspClient, signal?: AbortSignal): Promise<void>;
-/**
- * Sync in-memory content to the LSP client without reading from disk.
- * Use this to provide instant feedback during edits before the file is saved.
- */
-export declare function syncContent(client: LspClient, filePath: string, content: string, signal?: AbortSignal): Promise<void>;
-/**
- * Notify LSP that a file was saved.
- * Assumes content was already synced via syncContent - just sends didSave.
- */
-export declare function notifySaved(client: LspClient, filePath: string, signal?: AbortSignal): Promise<void>;
-/**
- * Refresh a file in the LSP client.
- * Increments version, sends didChange and didSave notifications.
- */
-export declare function refreshFile(client: LspClient, filePath: string, signal?: AbortSignal): Promise<void>;
-export declare function shutdownClient(key: string): Promise<void>;
-/**
- * Send an LSP request and wait for response.
- */
-export declare function sendRequest(client: LspClient, method: string, params: unknown, signal?: AbortSignal, timeoutMs?: number): Promise<unknown>;
-/**
- * Send an LSP notification (no response expected).
- */
-export declare function sendNotification(client: LspClient, method: string, params: unknown): Promise<void>;
-/**
- * Shutdown all LSP clients.
- */
-export declare function shutdownAll(): Promise<void>;
-/** Status of an LSP server */
-export interface LspServerStatus {
-    name: string;
-    status: "connecting" | "ready" | "error";
-    fileTypes: string[];
-    error?: string;
-}
-/**
- * Get status of all active LSP clients.
- */
-export declare function getActiveClients(): LspServerStatus[];

package/dist/types/lsp/clients/biome-client.d.ts

@@ -1,16 +0,0 @@
-import type { Diagnostic, LinterClient, ServerConfig } from "../../lsp/types";
-/**
- * Biome CLI-based linter client.
- * Parses Biome's --reporter=json output into LSP Diagnostic format.
- */
-export declare class BiomeClient implements LinterClient {
-    #private;
-    private readonly config;
-    private readonly cwd;
-    /** Factory method for creating BiomeClient instances */
-    static create(config: ServerConfig, cwd: string): LinterClient;
-    constructor(config: ServerConfig, cwd: string);
-    format(filePath: string, content: string): Promise<string>;
-    lint(filePath: string): Promise<Diagnostic[]>;
-    dispose(): void;
-}

package/dist/types/lsp/clients/index.d.ts

@@ -1,19 +0,0 @@
-import type { LinterClient, ServerConfig } from "../../lsp/types";
-/**
- * Linter client implementations.
- *
- * The LinterClient interface provides a common API for formatters and linters.
- * Different implementations can use LSP protocol, CLI tools, or other mechanisms.
- */
-export { BiomeClient } from "./biome-client";
-export { LspLinterClient } from "./lsp-linter-client";
-export { SwiftLintClient } from "./swiftlint-client";
-/**
- * Get or create a linter client for a server configuration.
- * Uses the server's custom factory if provided, otherwise falls back to LSP.
- */
-export declare function getLinterClient(serverName: string, config: ServerConfig, cwd: string): LinterClient;
-/**
- * Clear all cached linter clients.
- */
-export declare function clearLinterClientCache(): void;

package/dist/types/lsp/clients/lsp-linter-client.d.ts

@@ -1,16 +0,0 @@
-import type { Diagnostic, LinterClient, ServerConfig } from "../../lsp/types";
-/**
- * LSP-based linter client implementation.
- * Wraps the existing LSP client infrastructure.
- */
-export declare class LspLinterClient implements LinterClient {
-    #private;
-    private readonly config;
-    private readonly cwd;
-    /** Factory method for creating LspLinterClient instances */
-    static create(config: ServerConfig, cwd: string): LinterClient;
-    constructor(config: ServerConfig, cwd: string);
-    format(filePath: string, content: string): Promise<string>;
-    lint(filePath: string): Promise<Diagnostic[]>;
-    dispose(): void;
-}

package/dist/types/lsp/clients/swiftlint-client.d.ts

@@ -1,20 +0,0 @@
-/**
- * SwiftLint CLI-based linter client.
- * Parses SwiftLint's JSON reporter output into LSP Diagnostic format.
- */
-import type { Diagnostic, LinterClient, ServerConfig } from "../../lsp/types";
-/**
- * SwiftLint CLI-based linter client.
- * Runs `swiftlint lint --reporter json` and converts violations to LSP diagnostics.
- */
-export declare class SwiftLintClient implements LinterClient {
-    #private;
-    private readonly config;
-    private readonly cwd;
-    /** Factory method for creating SwiftLintClient instances */
-    static create(config: ServerConfig, cwd: string): LinterClient;
-    constructor(config: ServerConfig, cwd: string);
-    format(_filePath: string, content: string): Promise<string>;
-    lint(filePath: string): Promise<Diagnostic[]>;
-    dispose(): void;
-}

package/dist/types/lsp/config.d.ts

@@ -1,65 +0,0 @@
-import type { ServerConfig } from "./types";
-export interface LspConfig {
-    servers: Record<string, ServerConfig>;
-    /** Idle timeout in milliseconds. If set, LSP clients will be shutdown after this period of inactivity. Disabled by default. */
-    idleTimeoutMs?: number;
-}
-/**
- * Check if any root marker file exists in the directory
- */
-export declare function hasRootMarkers(cwd: string, markers: string[]): boolean;
-/**
- * Resolve a command to an executable path.
- * Checks project-local bin directories first, then falls back to $PATH.
- *
- * @param command - The command name (e.g., "typescript-language-server")
- * @param cwd - Working directory to search from
- * @returns Absolute path to the executable, or null if not found
- */
-export declare function resolveCommand(command: string, cwd: string): string | null;
-/**
- * Load LSP configuration.
- *
- * Priority (highest to lowest):
- * 1. Project root: lsp.json/.lsp.json/lsp.yml/.lsp.yml/lsp.yaml/.lsp.yaml
- * 2. Project config dirs: .skc/lsp.*, .gemini/lsp.* (+ hidden variants)
- * 3. User config dirs: ~/.skc/agent/lsp.*, ~/.gemini/lsp.* (+ hidden variants)
- * 4. User home root: ~/lsp.*, ~/.lsp.*
- * 5. Auto-detect from project markers + available binaries
- *
- * Config files are merged from lowest to highest priority; later files override earlier settings.
- *
- * Config file format (JSON or YAML):
- * ```json
- * {
- *   "servers": {
- *     "typescript-language-server": {
- *       "command": "typescript-language-server",
- *       "args": ["--stdio", "--log-level", "4"],
- *       "disabled": false
- *     },
- *     "my-custom-server": {
- *       "command": "/path/to/server",
- *       "args": ["--stdio"],
- *       "fileTypes": [".xyz"],
- *       "rootMarkers": [".xyz-project"]
- *     }
- *   }
- * }
- * ```
- */
-export declare function loadConfig(cwd: string): LspConfig;
-/**
- * Find all servers that can handle a file based on extension.
- * Returns servers sorted with primary (non-linter) servers first.
- */
-export declare function getServersForFile(config: LspConfig, filePath: string): Array<[string, ServerConfig]>;
-/**
- * Find the primary server for a file (prefers type-checkers over linters).
- * Used for operations like definition, hover, references that need type intelligence.
- */
-export declare function getServerForFile(config: LspConfig, filePath: string): [string, ServerConfig] | null;
-/**
- * Check if a server has a specific capability
- */
-export declare function hasCapability(config: ServerConfig, capability: keyof NonNullable<ServerConfig["capabilities"]>): boolean;

package/dist/types/lsp/edits.d.ts

@@ -1,23 +0,0 @@
-import type { Range, TextEdit, WorkspaceEdit } from "./types";
-/**
- * Apply text edits to a string in-memory.
- * Edits are applied in reverse order (bottom-to-top) to preserve line/character indices.
- */
-export declare function applyTextEditsToString(content: string, edits: TextEdit[]): string;
-/** True when two ranges overlap (share any position other than a touching boundary). */
-export declare function rangesOverlap(a: Range, b: Range): boolean;
-/**
- * Flatten a WorkspaceEdit's text edits into a Map<uri, TextEdit[]>.
- * Resource operations (create/rename/delete) are ignored — callers handle them separately.
- */
-export declare function flattenWorkspaceTextEdits(edit: WorkspaceEdit): Map<string, TextEdit[]>;
-/**
- * Apply text edits to a file.
- * Edits are applied in reverse order (bottom-to-top) to preserve line/character indices.
- */
-export declare function applyTextEdits(filePath: string, edits: TextEdit[]): Promise<void>;
-/**
- * Apply a workspace edit (collection of file changes).
- * Returns array of applied change descriptions.
- */
-export declare function applyWorkspaceEdit(edit: WorkspaceEdit, cwd: string): Promise<string[]>;

package/dist/types/lsp/index.d.ts

@@ -1,130 +0,0 @@
-import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@sayknow-cli/agent-core";
-import type { BunFile } from "bun";
-import { type Theme } from "../modes/theme/theme";
-import type { ToolSession } from "../tools";
-import { type LspServerStatus } from "./client";
-import { renderCall, renderResult } from "./render";
-import { type LspParams, type LspToolDetails, lspSchema } from "./types";
-export type { LspServerStatus } from "./client";
-export type { LspToolDetails } from "./types";
-export interface LspStartupServerInfo {
-    name: string;
-    status: "connecting" | "ready" | "error";
-    fileTypes: string[];
-    error?: string;
-}
-/** Result from warming up LSP servers */
-export interface LspWarmupResult {
-    servers: Array<LspStartupServerInfo & {
-        status: "ready" | "error";
-    }>;
-}
-/** Options for warming up LSP servers */
-export interface LspWarmupOptions {
-    /** Called when starting to connect to servers */
-    onConnecting?: (serverNames: string[]) => void;
-}
-export declare function discoverStartupLspServers(cwd: string): LspStartupServerInfo[];
-/**
- * Warm up LSP servers for a directory by connecting to all detected servers.
- * This should be called at startup to avoid cold-start delays.
- *
- * @param cwd - Working directory to detect and start servers for
- * @param options - Optional callbacks for progress reporting
- * @returns Status of each server that was started
- */
-export declare function warmupLspServers(cwd: string, options?: LspWarmupOptions): Promise<LspWarmupResult>;
-/**
- * Get status of currently active LSP servers.
- */
-export declare function getLspStatus(): LspServerStatus[];
-/** Result from getDiagnosticsForFile */
-export interface FileDiagnosticsResult {
-    /** Name of the LSP server used (if available) */
-    server?: string;
-    /** Formatted diagnostic messages */
-    messages: string[];
-    /** Summary string (e.g., "2 error(s), 1 warning(s)") */
-    summary: string;
-    /** Whether there are any errors (severity 1) */
-    errored: boolean;
-    /** Whether the file was formatted */
-    formatter?: FileFormatResult;
-}
-export declare enum FileFormatResult {
-    UNCHANGED = "unchanged",
-    FORMATTED = "formatted"
-}
-/** Options for creating the LSP writethrough callback */
-export interface WritethroughOptions {
-    /** Whether to format the file using LSP after writing */
-    enableFormat?: boolean;
-    /** Whether to get LSP diagnostics after writing */
-    enableDiagnostics?: boolean;
-    /** Called when diagnostics arrive after the main timeout. */
-    onDeferredDiagnostics?: (diagnostics: FileDiagnosticsResult) => void;
-    /** Signal to cancel a pending deferred diagnostics fetch. */
-    deferredSignal?: AbortSignal;
-}
-/** Per-file deferred LSP diagnostics wiring for {@link WritethroughCallback}. */
-export type WritethroughDeferredHandle = {
-    onDeferredDiagnostics: (diagnostics: FileDiagnosticsResult) => void;
-    signal: AbortSignal;
-    finalize: (diagnostics: FileDiagnosticsResult | undefined) => void;
-};
-/** Callback type for the LSP writethrough */
-export type WritethroughCallback = (dst: string, content: string, signal?: AbortSignal, file?: BunFile, batch?: LspWritethroughBatchRequest, getDeferred?: (dst: string) => WritethroughDeferredHandle | undefined) => Promise<FileDiagnosticsResult | undefined>;
-/** No-op writethrough callback */
-export declare function writethroughNoop(dst: string, content: string, _signal?: AbortSignal, file?: BunFile, _batch?: LspWritethroughBatchRequest, _getDeferred?: (dst: string) => WritethroughDeferredHandle | undefined): Promise<FileDiagnosticsResult | undefined>;
-interface LspWritethroughBatchRequest {
-    id: string;
-    flush: boolean;
-}
-export declare function flushLspWritethroughBatch(id: string, cwd: string, signal?: AbortSignal): Promise<FileDiagnosticsResult | undefined>;
-/** Create a writethrough callback for LSP aware write operations */
-export declare function createLspWritethrough(cwd: string, options?: WritethroughOptions): WritethroughCallback;
-/**
- * LSP tool for language server protocol operations.
- */
-export declare class LspTool implements AgentTool<typeof lspSchema, LspToolDetails, Theme> {
-    private readonly session;
-    readonly name = "lsp";
-    readonly label = "LSP";
-    readonly loadMode = "discoverable";
-    readonly summary = "Query LSP (language server) for diagnostics, hover info, and references";
-    readonly description: string;
-    readonly parameters: import("zod").ZodObject<{
-        action: import("zod").ZodEnum<{
-            status: "status";
-            diagnostics: "diagnostics";
-            definition: "definition";
-            references: "references";
-            hover: "hover";
-            symbols: "symbols";
-            rename: "rename";
-            rename_file: "rename_file";
-            code_actions: "code_actions";
-            type_definition: "type_definition";
-            implementation: "implementation";
-            reload: "reload";
-            capabilities: "capabilities";
-            request: "request";
-        }>;
-        file: import("zod").ZodOptional<import("zod").ZodString>;
-        line: import("zod").ZodOptional<import("zod").ZodNumber>;
-        symbol: import("zod").ZodOptional<import("zod").ZodString>;
-        query: import("zod").ZodOptional<import("zod").ZodString>;
-        new_name: import("zod").ZodOptional<import("zod").ZodString>;
-        apply: import("zod").ZodOptional<import("zod").ZodBoolean>;
-        timeout: import("zod").ZodOptional<import("zod").ZodNumber>;
-        payload: import("zod").ZodOptional<import("zod").ZodString>;
-    }, import("zod/v4/core").$strip>;
-    readonly renderCall: typeof renderCall;
-    readonly renderResult: typeof renderResult;
-    readonly mergeCallAndResult = true;
-    readonly inline = true;
-    readonly strict = true;
-    constructor(session: ToolSession);
-    static createIf(session: ToolSession): LspTool | null;
-    execute(_toolCallId: string, params: LspParams, signal?: AbortSignal, _onUpdate?: AgentToolUpdateCallback<LspToolDetails>, _context?: AgentToolContext): Promise<AgentToolResult<LspToolDetails>>;
-}

package/dist/types/lsp/lspmux.d.ts

@@ -1,58 +0,0 @@
-/**
- * lspmux integration for LSP server multiplexing.
- *
- * When lspmux is available and running, this module wraps supported LSP server
- * commands to use lspmux client mode, enabling server instance sharing across
- * multiple editor windows.
- *
- * Integration is transparent: if lspmux is unavailable, falls back to direct spawning.
- */
-interface LspmuxConfig {
-    instance_timeout?: number;
-    gc_interval?: number;
-    listen?: [string, number] | string;
-    connect?: [string, number] | string;
-    log_filters?: string;
-    pass_environment?: string[];
-}
-interface LspmuxState {
-    available: boolean;
-    running: boolean;
-    binaryPath: string | null;
-    config: LspmuxConfig | null;
-}
-/**
- * Detect lspmux availability and state.
- * Results are cached for STATE_CACHE_TTL_MS.
- *
- * Set PI_DISABLE_LSPMUX=1 to disable.
- */
-export declare function detectLspmux(): Promise<LspmuxState>;
-/**
- * Check if a server command is supported by lspmux.
- */
-export declare function isLspmuxSupported(command: string): boolean;
-export interface LspmuxWrappedCommand {
-    command: string;
-    args: string[];
-    env?: Record<string, string>;
-}
-/**
- * Wrap a server command to use lspmux client mode.
- *
- * @param originalCommand - The original LSP server command (e.g., "rust-analyzer")
- * @param originalArgs - Original command arguments
- * @param state - lspmux state from detectLspmux()
- * @returns Wrapped command, args, and env vars; or original if lspmux unavailable
- */
-export declare function wrapWithLspmux(originalCommand: string, originalArgs: string[] | undefined, state: LspmuxState): LspmuxWrappedCommand;
-/**
- * Get lspmux-wrapped command if available, otherwise return original.
- * This is the main entry point for config.ts integration.
- *
- * @param command - Original LSP server command
- * @param args - Original command arguments
- * @returns Command and args to use (possibly wrapped with lspmux)
- */
-export declare function getLspmuxCommand(command: string, args?: string[]): Promise<LspmuxWrappedCommand>;
-export {};

package/dist/types/lsp/render.d.ts

@@ -1,32 +0,0 @@
-/**
- * LSP Tool TUI Rendering
- *
- * Renders LSP tool calls and results in the TUI with:
- * - Syntax-highlighted hover information
- * - Color-coded diagnostics by severity
- * - Grouped references and symbols
- * - Collapsible/expandable views
- */
-import type { RenderResultOptions } from "@sayknow-cli/agent-core";
-import { type Component, Text } from "@sayknow-cli/tui";
-import { type Theme } from "../modes/theme/theme";
-import type { LspParams, LspToolDetails } from "./types";
-export declare function renderCall(args: LspParams, _options: RenderResultOptions, theme: Theme): Text;
-/**
- * Render LSP tool result with intelligent formatting based on result type.
- * Detects hover, diagnostics, references, symbols, etc. and formats accordingly.
- */
-export declare function renderResult(result: {
-    content: Array<{
-        type: string;
-        text?: string;
-    }>;
-    details?: LspToolDetails;
-    isError?: boolean;
-}, options: RenderResultOptions, theme: Theme, args?: LspParams): Component;
-export declare const lspToolRenderer: {
-    renderCall: typeof renderCall;
-    renderResult: typeof renderResult;
-    mergeCallAndResult: boolean;
-    inline: boolean;
-};

package/dist/types/lsp/startup-events.d.ts

@@ -1,12 +0,0 @@
-import type { LspStartupServerInfo } from "./index";
-export declare const LSP_STARTUP_EVENT_CHANNEL = "lsp:startup";
-export type LspStartupEvent = {
-    type: "completed";
-    servers: Array<LspStartupServerInfo & {
-        status: "ready" | "error";
-    }>;
-} | {
-    type: "failed";
-    error: string;
-};
-export declare function getLspStartupWarningMessage(event: LspStartupEvent): string | null;