@oh-my-pi/pi-coding-agent 15.1.1 → 15.1.3

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

@@ -0,0 +1,130 @@
+import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-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/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 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

@@ -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 "@oh-my-pi/pi-agent-core";
+import { type Component, Text } from "@oh-my-pi/pi-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;
+};

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

@@ -0,0 +1,302 @@
+import type { ptree } from "@oh-my-pi/pi-utils";
+import * as z from "zod/v4";
+export declare const lspSchema: z.ZodObject<{
+    action: z.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: z.ZodOptional<z.ZodString>;
+    line: z.ZodOptional<z.ZodNumber>;
+    symbol: z.ZodOptional<z.ZodString>;
+    query: z.ZodOptional<z.ZodString>;
+    new_name: z.ZodOptional<z.ZodString>;
+    apply: z.ZodOptional<z.ZodBoolean>;
+    timeout: z.ZodOptional<z.ZodNumber>;
+    payload: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type LspParams = z.infer<typeof lspSchema>;
+export interface LspToolDetails {
+    serverName?: string;
+    action: string;
+    success: boolean;
+    request?: LspParams;
+}
+export interface Position {
+    line: number;
+    character: number;
+}
+export interface Range {
+    start: Position;
+    end: Position;
+}
+export interface Location {
+    uri: string;
+    range: Range;
+}
+export interface LocationLink {
+    originSelectionRange?: Range;
+    targetUri: string;
+    targetRange: Range;
+    targetSelectionRange: Range;
+}
+export type DiagnosticSeverity = 1 | 2 | 3 | 4;
+export interface DiagnosticRelatedInformation {
+    location: Location;
+    message: string;
+}
+export interface Diagnostic {
+    range: Range;
+    severity?: DiagnosticSeverity;
+    code?: string | number;
+    codeDescription?: {
+        href: string;
+    };
+    source?: string;
+    message: string;
+    tags?: number[];
+    relatedInformation?: DiagnosticRelatedInformation[];
+    data?: unknown;
+}
+export interface PublishedDiagnostics {
+    diagnostics: Diagnostic[];
+    version: number | null;
+}
+export interface PublishDiagnosticsParams {
+    uri: string;
+    diagnostics: Diagnostic[];
+    version?: number | null;
+}
+export interface TextEdit {
+    range: Range;
+    newText: string;
+}
+export interface AnnotatedTextEdit extends TextEdit {
+    annotationId?: string;
+}
+export interface TextDocumentIdentifier {
+    uri: string;
+}
+export interface VersionedTextDocumentIdentifier extends TextDocumentIdentifier {
+    version: number | null;
+}
+export interface OptionalVersionedTextDocumentIdentifier extends TextDocumentIdentifier {
+    version?: number | null;
+}
+export interface TextDocumentEdit {
+    textDocument: OptionalVersionedTextDocumentIdentifier;
+    edits: (TextEdit | AnnotatedTextEdit)[];
+}
+export interface CreateFileOptions {
+    overwrite?: boolean;
+    ignoreIfExists?: boolean;
+}
+export interface CreateFile {
+    kind: "create";
+    uri: string;
+    options?: CreateFileOptions;
+}
+export interface RenameFileOptions {
+    overwrite?: boolean;
+    ignoreIfExists?: boolean;
+}
+export interface RenameFile {
+    kind: "rename";
+    oldUri: string;
+    newUri: string;
+    options?: RenameFileOptions;
+}
+export interface DeleteFileOptions {
+    recursive?: boolean;
+    ignoreIfNotExists?: boolean;
+}
+export interface DeleteFile {
+    kind: "delete";
+    uri: string;
+    options?: DeleteFileOptions;
+}
+export type DocumentChange = TextDocumentEdit | CreateFile | RenameFile | DeleteFile;
+export interface WorkspaceEdit {
+    changes?: Record<string, TextEdit[]>;
+    documentChanges?: DocumentChange[];
+    changeAnnotations?: Record<string, {
+        label: string;
+        needsConfirmation?: boolean;
+        description?: string;
+    }>;
+}
+export type CodeActionKind = "quickfix" | "refactor" | "refactor.extract" | "refactor.inline" | "refactor.rewrite" | "source" | "source.organizeImports" | "source.fixAll" | string;
+export interface Command {
+    title: string;
+    command: string;
+    arguments?: unknown[];
+}
+export interface CodeAction {
+    title: string;
+    kind?: CodeActionKind;
+    diagnostics?: Diagnostic[];
+    isPreferred?: boolean;
+    disabled?: {
+        reason: string;
+    };
+    edit?: WorkspaceEdit;
+    command?: Command;
+    data?: unknown;
+}
+export interface CodeActionContext {
+    diagnostics: Diagnostic[];
+    only?: CodeActionKind[];
+    triggerKind?: 1 | 2;
+}
+export type SymbolKind = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26;
+export declare const SYMBOL_KIND_NAMES: Record<SymbolKind, string>;
+export interface DocumentSymbol {
+    name: string;
+    detail?: string;
+    kind: SymbolKind;
+    tags?: number[];
+    deprecated?: boolean;
+    range: Range;
+    selectionRange: Range;
+    children?: DocumentSymbol[];
+}
+export interface SymbolInformation {
+    name: string;
+    kind: SymbolKind;
+    tags?: number[];
+    deprecated?: boolean;
+    location: Location;
+    containerName?: string;
+}
+export interface MarkupContent {
+    kind: "plaintext" | "markdown";
+    value: string;
+}
+export type MarkedString = string | {
+    language: string;
+    value: string;
+};
+export interface Hover {
+    contents: MarkupContent | MarkedString | MarkedString[];
+    range?: Range;
+}
+/**
+ * Interface for linter/formatter clients.
+ * Can be implemented using LSP protocol or CLI tools.
+ */
+export interface LinterClient {
+    /** Format file content. Returns formatted content. */
+    format(filePath: string, content: string): Promise<string>;
+    /** Get diagnostics for a file. Content should already be written to disk. */
+    lint(filePath: string): Promise<Diagnostic[]>;
+    /** Dispose of any resources (e.g., LSP connection) */
+    dispose?(): void;
+}
+/** Factory function to create a LinterClient */
+export type LinterClientFactory = (config: ServerConfig, cwd: string) => LinterClient;
+export interface ServerCapabilities {
+    flycheck?: boolean;
+    ssr?: boolean;
+    expandMacro?: boolean;
+    runnables?: boolean;
+    relatedTests?: boolean;
+}
+export interface ServerConfig {
+    command: string;
+    args?: string[];
+    fileTypes: string[];
+    rootMarkers: string[];
+    initOptions?: Record<string, unknown>;
+    settings?: Record<string, unknown>;
+    disabled?: boolean;
+    /** Per-server warmup timeout in milliseconds. Overrides the global WARMUP_TIMEOUT_MS for this server during startup. */
+    warmupTimeoutMs?: number;
+    capabilities?: ServerCapabilities;
+    /** If true, this is a linter/formatter server (e.g., Biome) - used only for diagnostics/actions, not type intelligence */
+    isLinter?: boolean;
+    /** Resolved absolute path to the command binary (set during config loading) */
+    resolvedCommand?: string;
+    /**
+     * Custom linter client factory. If provided, creates a custom client instead of using LSP.
+     * The client handles format/lint operations. Useful for tools with buggy LSP implementations.
+     */
+    createClient?: LinterClientFactory;
+}
+export interface OpenFile {
+    version: number;
+    languageId: string;
+}
+export interface PendingRequest {
+    resolve: (result: unknown) => void;
+    reject: (error: Error) => void;
+    method: string;
+}
+export interface LspServerCapabilities {
+    renameProvider?: boolean | {
+        prepareProvider?: boolean;
+    };
+    codeActionProvider?: boolean | {
+        resolveProvider?: boolean;
+    };
+    hoverProvider?: boolean;
+    definitionProvider?: boolean;
+    referencesProvider?: boolean;
+    documentSymbolProvider?: boolean;
+    workspaceSymbolProvider?: boolean;
+    [key: string]: unknown;
+}
+export interface LspClient {
+    name: string;
+    cwd: string;
+    config: ServerConfig;
+    proc: ptree.ChildProcess<"pipe">;
+    requestId: number;
+    diagnostics: Map<string, PublishedDiagnostics>;
+    diagnosticsVersion: number;
+    openFiles: Map<string, OpenFile>;
+    pendingRequests: Map<number, PendingRequest>;
+    messageBuffer: Uint8Array;
+    isReading: boolean;
+    serverCapabilities?: LspServerCapabilities;
+    lastActivity: number;
+    /** Serializes outbound JSON-RPC writes to the server process. */
+    writeQueue: Promise<void>;
+    /** Tracks active work-done progress tokens from the server */
+    activeProgressTokens: Set<string | number>;
+    /** Resolves when the server's initial project loading completes (or after timeout) */
+    projectLoaded: Promise<void>;
+    /** Call to signal that project loading has completed */
+    resolveProjectLoaded: () => void;
+}
+export interface LspJsonRpcRequest {
+    jsonrpc: "2.0";
+    id: number;
+    method: string;
+    params: unknown;
+}
+export interface LspJsonRpcResponse {
+    jsonrpc: "2.0";
+    id?: number;
+    result?: unknown;
+    error?: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+}
+export interface LspJsonRpcNotification {
+    jsonrpc: "2.0";
+    method: string;
+    params?: unknown;
+}

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

@@ -0,0 +1,108 @@
+export { truncate } from "@oh-my-pi/pi-utils";
+import type { CodeAction, Command, Diagnostic, DiagnosticSeverity, DocumentSymbol, Location, SymbolInformation, SymbolKind, TextEdit, WorkspaceEdit } from "./types";
+export { detectLanguageId } from "../utils/lang-from-path";
+/**
+ * Convert a file path to a file:// URI.
+ * Handles Windows drive letters correctly.
+ */
+export declare function fileToUri(filePath: string): string;
+/**
+ * Convert a file:// URI to a file path.
+ * Handles Windows drive letters correctly.
+ */
+export declare function uriToFile(uri: string): string;
+/**
+ * Convert diagnostic severity number to string name.
+ */
+export declare function severityToString(severity?: DiagnosticSeverity): string;
+/**
+ * Sort diagnostics by severity, then by location and message.
+ */
+export declare function sortDiagnostics(diagnostics: Diagnostic[]): Diagnostic[];
+/**
+ * Get icon for diagnostic severity.
+ */
+export declare function severityToIcon(severity?: DiagnosticSeverity): string;
+/**
+ * Format a diagnostic as a human-readable string.
+ */
+export declare function formatDiagnostic(diagnostic: Diagnostic, filePath: string): string;
+/**
+ * Reformat pre-formatted diagnostic messages into grep-style directory/file groups.
+ * Input:  ["path:line:col [sev] msg", ...]
+ * Output: "# dir/\n## file.ts\n  line:col [sev] msg"
+ *
+ * Messages that don't match the expected format are appended ungrouped at the end.
+ */
+export declare function formatGroupedDiagnosticMessages(messages: string[]): string;
+/**
+ * Format diagnostics grouped by severity.
+ */
+export declare function formatDiagnosticsSummary(diagnostics: Diagnostic[]): string;
+/**
+ * Format a location as file:line:col relative to cwd.
+ */
+export declare function formatLocation(location: Location, cwd: string): string;
+/**
+ * Format a position as line:col.
+ */
+export declare function formatPosition(line: number, col: number): string;
+/**
+ * Format a workspace edit as a summary of changes.
+ */
+export declare function formatWorkspaceEdit(edit: WorkspaceEdit, cwd: string): string[];
+/**
+ * Format a text edit as a preview.
+ */
+export declare function formatTextEdit(edit: TextEdit, maxLength?: number): string;
+/**
+ * Get icon for symbol kind.
+ */
+export declare function symbolKindToIcon(kind: SymbolKind): string;
+/**
+ * Get name for symbol kind.
+ */
+export declare function symbolKindToName(kind: SymbolKind): string;
+/**
+ * Format a document symbol with optional hierarchy.
+ */
+export declare function formatDocumentSymbol(symbol: DocumentSymbol, indent?: number): string[];
+/**
+ * Format a symbol information (flat format).
+ */
+export declare function formatSymbolInformation(symbol: SymbolInformation, cwd: string): string;
+export declare function filterWorkspaceSymbols(symbols: SymbolInformation[], query: string): SymbolInformation[];
+export declare function dedupeWorkspaceSymbols(symbols: SymbolInformation[]): SymbolInformation[];
+export declare function formatCodeAction(action: CodeAction | Command, index: number): string;
+export interface CodeActionApplyDependencies {
+    resolveCodeAction?: (action: CodeAction) => Promise<CodeAction>;
+    applyWorkspaceEdit: (edit: WorkspaceEdit) => Promise<string[]>;
+    executeCommand: (command: Command) => Promise<void>;
+}
+export interface AppliedCodeActionResult {
+    title: string;
+    edits: string[];
+    executedCommands: string[];
+}
+export declare function applyCodeAction(action: CodeAction | Command, dependencies: CodeActionApplyDependencies): Promise<AppliedCodeActionResult | null>;
+export declare function hasGlobPattern(value: string): boolean;
+export declare function collectGlobMatches(pattern: string, cwd: string, maxMatches: number): Promise<{
+    matches: string[];
+    truncated: boolean;
+}>;
+export declare function resolveDiagnosticTargets(file: string, cwd: string, maxMatches: number): Promise<{
+    matches: string[];
+    truncated: boolean;
+}>;
+/**
+ * Extract plain text from hover contents.
+ */
+export declare function extractHoverText(contents: string | {
+    kind: string;
+    value: string;
+} | {
+    language: string;
+    value: string;
+} | unknown[]): string;
+export declare function resolveSymbolColumn(filePath: string, line: number, symbolSpec?: string): Promise<number>;
+export declare function readLocationContext(filePath: string, line: number, contextLines?: number): Promise<string[]>;

package/dist/types/main.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Main entry point for the coding agent CLI.
+ *
+ * This file handles CLI argument parsing and translates them into
+ * createAgentSession() options. The SDK does the heavy lifting.
+ */
+import type { Args } from "./cli/args";
+import { InteractiveMode } from "./modes";
+import type { SubmittedUserInput } from "./modes/types";
+import type { AgentSession } from "./session/agent-session";
+export interface InteractiveModeNotify {
+    kind: "warn" | "error" | "info";
+    message: string;
+}
+export declare function submitInteractiveInput(mode: Pick<InteractiveMode, "markPendingSubmissionStarted" | "finishPendingSubmission" | "showError" | "checkShutdownRequested">, session: Pick<AgentSession, "prompt" | "promptCustomMessage">, input: SubmittedUserInput): Promise<void>;
+export declare function runRootCommand(parsed: Args, rawArgs: string[]): Promise<void>;
+export declare function main(args: string[]): Promise<void>;