@prometheus-ai/agent 0.5.0

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

@@ -0,0 +1,68 @@
+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;
+/** 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>;
+/**
+ * Shutdown a specific client by key.
+ */
+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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,20 @@
+/**
+ * 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

@@ -0,0 +1,65 @@
+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: .prometheus/lsp.*, .claude/lsp.*, .codex/lsp.*, .gemini/lsp.* (+ hidden variants)
+ * 3. User config dirs: ~/.prometheus/agent/lsp.*, ~/.claude/lsp.*, ~/.codex/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/diagnostics-ledger.d.ts

@@ -0,0 +1,10 @@
+import type { FileDiagnosticsResult } from "./index";
+export declare function diagnosticIdentity(message: string): string;
+export declare class DiagnosticsLedger {
+    #private;
+    reduce(absPath: string, result: FileDiagnosticsResult): FileDiagnosticsResult;
+}
+export interface DiagnosticsLedgerOwner {
+    diagnosticsLedger?: DiagnosticsLedger;
+}
+export declare function getDiagnosticsLedger(owner: DiagnosticsLedgerOwner): DiagnosticsLedger;

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

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,140 @@
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback, ToolApprovalDecision } from "@prometheus-ai/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";
+/**
+ * LSP actions that do not mutate the workspace or language-server state.
+ * Anything not in this set (rename, code_actions with apply, rename_file,
+ * reload, raw request, etc.) is classified as write-tier.
+ */
+export declare const LSP_READONLY_ACTIONS: ReadonlySet<string>;
+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;
+    /** Transform diagnostics before surfacing them after a successful fetch. */
+    transformDiagnostics?: (absPath: string, result: FileDiagnosticsResult) => FileDiagnosticsResult;
+}
+/** 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 approval: (args: unknown) => ToolApprovalDecision;
+    readonly formatApprovalDetails: (args: unknown) => string[];
+    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/v4").ZodObject<{
+        action: import("zod/v4").ZodEnum<{
+            capabilities: "capabilities";
+            code_actions: "code_actions";
+            definition: "definition";
+            diagnostics: "diagnostics";
+            hover: "hover";
+            implementation: "implementation";
+            references: "references";
+            reload: "reload";
+            rename: "rename";
+            rename_file: "rename_file";
+            request: "request";
+            status: "status";
+            symbols: "symbols";
+            type_definition: "type_definition";
+        }>;
+        file: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+        line: import("zod/v4").ZodOptional<import("zod/v4").ZodNumber>;
+        symbol: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+        query: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+        new_name: import("zod/v4").ZodOptional<import("zod/v4").ZodString>;
+        apply: import("zod/v4").ZodOptional<import("zod/v4").ZodBoolean>;
+        timeout: import("zod/v4").ZodOptional<import("zod/v4").ZodNumber>;
+        payload: import("zod/v4").ZodOptional<import("zod/v4").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

@@ -0,0 +1,58 @@
+/**
+ * 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 PROMETHEUS_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

@@ -0,0 +1,32 @@
+/**
+ * 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 "@prometheus-ai/agent-core";
+import { type Component, Text } from "@prometheus-ai/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

@@ -0,0 +1,11 @@
+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;
+};