@selesai/code 0.13.13 → 0.13.14

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/modes/rpc/rpc-client.d.ts

@@ -0,0 +1,246 @@
+/**
+ * RPC Client for programmatic access to the coding agent.
+ *
+ * Spawns the agent in RPC mode and provides a typed API for all operations.
+ */
+import type { AgentMessage, ThinkingLevel } from "@earendil-works/pi-agent-core";
+import type { ImageContent } from "@earendil-works/pi-ai";
+import type { AgentSessionEvent, SessionStats } from "../../core/agent-session.ts";
+import type { BashResult } from "../../core/bash-executor.ts";
+import type { CompactionResult } from "../../core/compaction/index.ts";
+import type { SessionEntry, SessionTreeNode } from "../../core/session-manager.ts";
+import type { RpcSessionState, RpcSlashCommand } from "./rpc-types.ts";
+export interface RpcClientOptions {
+    /** Path to the CLI entry point (default: searches for dist/cli.js) */
+    cliPath?: string;
+    /** Working directory for the agent */
+    cwd?: string;
+    /** Environment variables */
+    env?: Record<string, string>;
+    /** Provider to use */
+    provider?: string;
+    /** Model ID to use */
+    model?: string;
+    /** Additional CLI arguments */
+    args?: string[];
+}
+export interface ModelInfo {
+    provider: string;
+    id: string;
+    contextWindow: number;
+    reasoning: boolean;
+}
+export type RpcEventListener = (event: AgentSessionEvent) => void;
+export declare class RpcClient {
+    private process;
+    private stopReadingStdout;
+    private eventListeners;
+    private pendingRequests;
+    private requestId;
+    private stderr;
+    private exitError;
+    private options;
+    constructor(options?: RpcClientOptions);
+    /**
+     * Start the RPC agent process.
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the RPC agent process.
+     */
+    stop(): Promise<void>;
+    /**
+     * Subscribe to agent events.
+     */
+    onEvent(listener: RpcEventListener): () => void;
+    /**
+     * Get collected stderr output (useful for debugging).
+     */
+    getStderr(): string;
+    /**
+     * Send a prompt to the agent.
+     * Returns immediately after sending; use onEvent() to receive streaming events.
+     * Use waitForIdle() to wait for completion.
+     */
+    prompt(message: string, images?: ImageContent[]): Promise<void>;
+    /**
+     * Queue a steering message to interrupt the agent mid-run.
+     */
+    steer(message: string, images?: ImageContent[]): Promise<void>;
+    /**
+     * Queue a follow-up message to be processed after the agent finishes.
+     */
+    followUp(message: string, images?: ImageContent[]): Promise<void>;
+    /**
+     * Abort current operation.
+     */
+    abort(): Promise<void>;
+    /**
+     * Start a new session, optionally with parent tracking.
+     * @param parentSession - Optional parent session path for lineage tracking
+     * @returns Object with `cancelled: true` if an extension cancelled the new session
+     */
+    newSession(parentSession?: string): Promise<{
+        cancelled: boolean;
+    }>;
+    /**
+     * Get current session state.
+     */
+    getState(): Promise<RpcSessionState>;
+    /**
+     * Set model by provider and ID.
+     */
+    setModel(provider: string, modelId: string): Promise<{
+        provider: string;
+        id: string;
+    }>;
+    /**
+     * Cycle to next model.
+     */
+    cycleModel(): Promise<{
+        model: {
+            provider: string;
+            id: string;
+        };
+        thinkingLevel: ThinkingLevel;
+        isScoped: boolean;
+    } | null>;
+    /**
+     * Get list of available models.
+     */
+    getAvailableModels(): Promise<ModelInfo[]>;
+    /**
+     * Set thinking level.
+     */
+    setThinkingLevel(level: ThinkingLevel): Promise<void>;
+    /**
+     * Cycle thinking level.
+     */
+    cycleThinkingLevel(): Promise<{
+        level: ThinkingLevel;
+    } | null>;
+    /**
+     * Get list of available thinking levels for the current model.
+     */
+    getAvailableThinkingLevels(): Promise<ThinkingLevel[]>;
+    /**
+     * Set steering mode.
+     */
+    setSteeringMode(mode: "all" | "one-at-a-time"): Promise<void>;
+    /**
+     * Set follow-up mode.
+     */
+    setFollowUpMode(mode: "all" | "one-at-a-time"): Promise<void>;
+    /**
+     * Compact session context.
+     */
+    compact(customInstructions?: string): Promise<CompactionResult>;
+    /**
+     * Set auto-compaction enabled/disabled.
+     */
+    setAutoCompaction(enabled: boolean): Promise<void>;
+    /**
+     * Set auto-retry enabled/disabled.
+     */
+    setAutoRetry(enabled: boolean): Promise<void>;
+    /**
+     * Abort in-progress retry.
+     */
+    abortRetry(): Promise<void>;
+    /**
+     * Execute a bash command.
+     */
+    bash(command: string): Promise<BashResult>;
+    /**
+     * Abort running bash command.
+     */
+    abortBash(): Promise<void>;
+    /**
+     * Get session statistics.
+     */
+    getSessionStats(): Promise<SessionStats>;
+    /**
+     * Export session to HTML.
+     */
+    exportHtml(outputPath?: string): Promise<{
+        path: string;
+    }>;
+    /**
+     * Switch to a different session file.
+     * @returns Object with `cancelled: true` if an extension cancelled the switch
+     */
+    switchSession(sessionPath: string): Promise<{
+        cancelled: boolean;
+    }>;
+    /**
+     * Fork from a specific message.
+     * @returns Object with `text` (the message text) and `cancelled` (if extension cancelled)
+     */
+    fork(entryId: string): Promise<{
+        text: string;
+        cancelled: boolean;
+    }>;
+    /**
+     * Clone the current active branch into a new session.
+     * @returns Object with `cancelled: true` if an extension cancelled the clone
+     */
+    clone(): Promise<{
+        cancelled: boolean;
+    }>;
+    /**
+     * Get messages available for forking.
+     */
+    getForkMessages(): Promise<Array<{
+        entryId: string;
+        text: string;
+    }>>;
+    /**
+     * Get session entries in append order, optionally only those after the `since` entry id.
+     */
+    getEntries(since?: string): Promise<{
+        entries: SessionEntry[];
+        leafId: string | null;
+    }>;
+    /**
+     * Get the session entry tree.
+     */
+    getTree(): Promise<{
+        tree: SessionTreeNode[];
+        leafId: string | null;
+    }>;
+    /**
+     * Get text of last assistant message.
+     */
+    getLastAssistantText(): Promise<string | null>;
+    /**
+     * Set the session display name.
+     */
+    setSessionName(name: string): Promise<void>;
+    /**
+     * Get all messages in the session.
+     */
+    getMessages(): Promise<AgentMessage[]>;
+    /**
+     * Get available commands (extension commands, prompt templates, skills).
+     */
+    getCommands(): Promise<RpcSlashCommand[]>;
+    /**
+     * Wait for agent to become idle (no streaming).
+     * Resolves when agent_settled event is received.
+     */
+    waitForIdle(timeout?: number): Promise<void>;
+    /**
+     * Collect events until agent becomes idle.
+     */
+    collectEvents(timeout?: number): Promise<AgentSessionEvent[]>;
+    /**
+     * Send prompt and wait for completion, returning all events.
+     */
+    promptAndWait(message: string, images?: ImageContent[], timeout?: number): Promise<AgentSessionEvent[]>;
+    private handleLine;
+    private createProcessExitError;
+    private rejectPendingRequests;
+    private send;
+    private getData;
+}
+//# sourceMappingURL=rpc-client.d.ts.map

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/modes/rpc/rpc-mode.d.ts

@@ -0,0 +1,20 @@
+/**
+ * RPC mode: Headless operation with JSON stdin/stdout protocol.
+ *
+ * Used for embedding the agent in other applications.
+ * Receives commands as JSON on stdin, outputs events and responses as JSON on stdout.
+ *
+ * Protocol:
+ * - Commands: JSON objects with `type` field, optional `id` for correlation
+ * - Responses: JSON objects with `type: "response"`, `command`, `success`, and optional `data`/`error`
+ * - Events: AgentSessionEvent objects streamed as they occur
+ * - Extension UI: Extension UI requests are emitted, client responds with extension_ui_response
+ */
+import type { AgentSessionRuntime } from "../../core/agent-session-runtime.ts";
+export type { RpcCommand, RpcExtensionUIRequest, RpcExtensionUIResponse, RpcResponse, RpcSessionState, } from "./rpc-types.ts";
+/**
+ * Run in RPC mode.
+ * Listens for JSON commands on stdin, outputs events and responses on stdout.
+ */
+export declare function runRpcMode(runtimeHost: AgentSessionRuntime): Promise<never>;
+//# sourceMappingURL=rpc-mode.d.ts.map

package/dist/extensions/pi-subagents/test/fixtures/pi-coding-agent-shim/dist/modes/rpc/rpc-types.d.ts

@@ -0,0 +1,457 @@
+/**
+ * RPC protocol types for headless operation.
+ *
+ * Commands are sent as JSON lines on stdin.
+ * Responses and events are emitted as JSON lines on stdout.
+ */
+import type { AgentMessage, ThinkingLevel } from "@earendil-works/pi-agent-core";
+import type { ImageContent, Model } from "@earendil-works/pi-ai";
+import type { SessionStats } from "../../core/agent-session.ts";
+import type { BashResult } from "../../core/bash-executor.ts";
+import type { CompactionResult } from "../../core/compaction/index.ts";
+import type { SessionEntry, SessionTreeNode } from "../../core/session-manager.ts";
+import type { SourceInfo } from "../../core/source-info.ts";
+export type RpcCommand = {
+    id?: string;
+    type: "prompt";
+    message: string;
+    images?: ImageContent[];
+    streamingBehavior?: "steer" | "followUp";
+} | {
+    id?: string;
+    type: "steer";
+    message: string;
+    images?: ImageContent[];
+} | {
+    id?: string;
+    type: "follow_up";
+    message: string;
+    images?: ImageContent[];
+} | {
+    id?: string;
+    type: "abort";
+} | {
+    id?: string;
+    type: "new_session";
+    parentSession?: string;
+} | {
+    id?: string;
+    type: "get_state";
+} | {
+    id?: string;
+    type: "set_model";
+    provider: string;
+    modelId: string;
+} | {
+    id?: string;
+    type: "cycle_model";
+} | {
+    id?: string;
+    type: "get_available_models";
+} | {
+    id?: string;
+    type: "set_thinking_level";
+    level: ThinkingLevel;
+} | {
+    id?: string;
+    type: "cycle_thinking_level";
+} | {
+    id?: string;
+    type: "get_available_thinking_levels";
+} | {
+    id?: string;
+    type: "set_steering_mode";
+    mode: "all" | "one-at-a-time";
+} | {
+    id?: string;
+    type: "set_follow_up_mode";
+    mode: "all" | "one-at-a-time";
+} | {
+    id?: string;
+    type: "compact";
+    customInstructions?: string;
+} | {
+    id?: string;
+    type: "set_auto_compaction";
+    enabled: boolean;
+} | {
+    id?: string;
+    type: "set_auto_retry";
+    enabled: boolean;
+} | {
+    id?: string;
+    type: "abort_retry";
+} | {
+    id?: string;
+    type: "bash";
+    command: string;
+    excludeFromContext?: boolean;
+} | {
+    id?: string;
+    type: "abort_bash";
+} | {
+    id?: string;
+    type: "get_session_stats";
+} | {
+    id?: string;
+    type: "export_html";
+    outputPath?: string;
+} | {
+    id?: string;
+    type: "switch_session";
+    sessionPath: string;
+} | {
+    id?: string;
+    type: "fork";
+    entryId: string;
+} | {
+    id?: string;
+    type: "clone";
+} | {
+    id?: string;
+    type: "get_fork_messages";
+} | {
+    id?: string;
+    type: "get_entries";
+    since?: string;
+} | {
+    id?: string;
+    type: "get_tree";
+} | {
+    id?: string;
+    type: "get_last_assistant_text";
+} | {
+    id?: string;
+    type: "set_session_name";
+    name: string;
+} | {
+    id?: string;
+    type: "get_messages";
+} | {
+    id?: string;
+    type: "get_commands";
+};
+/** A command available for invocation via prompt */
+export interface RpcSlashCommand {
+    /** Command name (without leading slash) */
+    name: string;
+    /** Human-readable description */
+    description?: string;
+    /** What kind of command this is */
+    source: "extension" | "prompt" | "skill";
+    /** Source metadata for the owning resource */
+    sourceInfo: SourceInfo;
+}
+export interface RpcSessionState {
+    model?: Model<any>;
+    thinkingLevel: ThinkingLevel;
+    isStreaming: boolean;
+    isCompacting: boolean;
+    steeringMode: "all" | "one-at-a-time";
+    followUpMode: "all" | "one-at-a-time";
+    sessionFile?: string;
+    sessionId: string;
+    sessionName?: string;
+    autoCompactionEnabled: boolean;
+    messageCount: number;
+    pendingMessageCount: number;
+}
+export type RpcResponse = {
+    id?: string;
+    type: "response";
+    command: "prompt";
+    success: true;
+} | {
+    id?: string;
+    type: "response";
+    command: "steer";
+    success: true;
+} | {
+    id?: string;
+    type: "response";
+    command: "follow_up";
+    success: true;
+} | {
+    id?: string;
+    type: "response";
+    command: "abort";
+    success: true;
+} | {
+    id?: string;
+    type: "response";
+    command: "new_session";
+    success: true;
+    data: {
+        cancelled: boolean;
+    };
+} | {
+    id?: string;
+    type: "response";
+    command: "get_state";
+    success: true;
+    data: RpcSessionState;
+} | {
+    id?: string;
+    type: "response";
+    command: "set_model";
+    success: true;
+    data: Model<any>;
+} | {
+    id?: string;
+    type: "response";
+    command: "cycle_model";
+    success: true;
+    data: {
+        model: Model<any>;
+        thinkingLevel: ThinkingLevel;
+        isScoped: boolean;
+    } | null;
+} | {
+    id?: string;
+    type: "response";
+    command: "get_available_models";
+    success: true;
+    data: {
+        models: Model<any>[];
+    };
+} | {
+    id?: string;
+    type: "response";
+    command: "set_thinking_level";
+    success: true;
+} | {
+    id?: string;
+    type: "response";
+    command: "cycle_thinking_level";
+    success: true;
+    data: {
+        level: ThinkingLevel;
+    } | null;
+} | {
+    id?: string;
+    type: "response";
+    command: "get_available_thinking_levels";
+    success: true;
+    data: {
+        levels: ThinkingLevel[];
+    };
+} | {
+    id?: string;
+    type: "response";
+    command: "set_steering_mode";
+    success: true;
+} | {
+    id?: string;
+    type: "response";
+    command: "set_follow_up_mode";
+    success: true;
+} | {
+    id?: string;
+    type: "response";
+    command: "compact";
+    success: true;
+    data: CompactionResult;
+} | {
+    id?: string;
+    type: "response";
+    command: "set_auto_compaction";
+    success: true;
+} | {
+    id?: string;
+    type: "response";
+    command: "set_auto_retry";
+    success: true;
+} | {
+    id?: string;
+    type: "response";
+    command: "abort_retry";
+    success: true;
+} | {
+    id?: string;
+    type: "response";
+    command: "bash";
+    success: true;
+    data: BashResult;
+} | {
+    id?: string;
+    type: "response";
+    command: "abort_bash";
+    success: true;
+} | {
+    id?: string;
+    type: "response";
+    command: "get_session_stats";
+    success: true;
+    data: SessionStats;
+} | {
+    id?: string;
+    type: "response";
+    command: "export_html";
+    success: true;
+    data: {
+        path: string;
+    };
+} | {
+    id?: string;
+    type: "response";
+    command: "switch_session";
+    success: true;
+    data: {
+        cancelled: boolean;
+    };
+} | {
+    id?: string;
+    type: "response";
+    command: "fork";
+    success: true;
+    data: {
+        text: string;
+        cancelled: boolean;
+    };
+} | {
+    id?: string;
+    type: "response";
+    command: "clone";
+    success: true;
+    data: {
+        cancelled: boolean;
+    };
+} | {
+    id?: string;
+    type: "response";
+    command: "get_fork_messages";
+    success: true;
+    data: {
+        messages: Array<{
+            entryId: string;
+            text: string;
+        }>;
+    };
+} | {
+    id?: string;
+    type: "response";
+    command: "get_entries";
+    success: true;
+    data: {
+        entries: SessionEntry[];
+        leafId: string | null;
+    };
+} | {
+    id?: string;
+    type: "response";
+    command: "get_tree";
+    success: true;
+    data: {
+        tree: SessionTreeNode[];
+        leafId: string | null;
+    };
+} | {
+    id?: string;
+    type: "response";
+    command: "get_last_assistant_text";
+    success: true;
+    data: {
+        text: string | null;
+    };
+} | {
+    id?: string;
+    type: "response";
+    command: "set_session_name";
+    success: true;
+} | {
+    id?: string;
+    type: "response";
+    command: "get_messages";
+    success: true;
+    data: {
+        messages: AgentMessage[];
+    };
+} | {
+    id?: string;
+    type: "response";
+    command: "get_commands";
+    success: true;
+    data: {
+        commands: RpcSlashCommand[];
+    };
+} | {
+    id?: string;
+    type: "response";
+    command: string;
+    success: false;
+    error: string;
+};
+/** Emitted when an extension needs user input */
+export type RpcExtensionUIRequest = {
+    type: "extension_ui_request";
+    id: string;
+    method: "select";
+    title: string;
+    options: string[];
+    timeout?: number;
+} | {
+    type: "extension_ui_request";
+    id: string;
+    method: "confirm";
+    title: string;
+    message: string;
+    timeout?: number;
+} | {
+    type: "extension_ui_request";
+    id: string;
+    method: "input";
+    title: string;
+    placeholder?: string;
+    timeout?: number;
+} | {
+    type: "extension_ui_request";
+    id: string;
+    method: "editor";
+    title: string;
+    prefill?: string;
+} | {
+    type: "extension_ui_request";
+    id: string;
+    method: "notify";
+    message: string;
+    notifyType?: "info" | "warning" | "error";
+} | {
+    type: "extension_ui_request";
+    id: string;
+    method: "setStatus";
+    statusKey: string;
+    statusText: string | undefined;
+} | {
+    type: "extension_ui_request";
+    id: string;
+    method: "setWidget";
+    widgetKey: string;
+    widgetLines: string[] | undefined;
+    widgetPlacement?: "aboveEditor" | "belowEditor";
+} | {
+    type: "extension_ui_request";
+    id: string;
+    method: "setTitle";
+    title: string;
+} | {
+    type: "extension_ui_request";
+    id: string;
+    method: "set_editor_text";
+    text: string;
+};
+/** Response to an extension UI request */
+export type RpcExtensionUIResponse = {
+    type: "extension_ui_response";
+    id: string;
+    value: string;
+} | {
+    type: "extension_ui_response";
+    id: string;
+    confirmed: boolean;
+} | {
+    type: "extension_ui_response";
+    id: string;
+    cancelled: true;
+};
+export type RpcCommandType = RpcCommand["type"];
+//# sourceMappingURL=rpc-types.d.ts.map