wave-code 1.0.0 → 1.0.2

package/dist/stdio/protocol.d.ts

@@ -34,8 +34,8 @@ export declare const INVALID_REQUEST = -32600;
 export declare const METHOD_NOT_FOUND = -32601;
 export declare const INVALID_PARAMS = -32602;
 export declare const INTERNAL_ERROR = -32603;
-export type RequestMethod = "initialize" | "destroy" | "restoreSession" | "listSessions" | "getSessionInfo" | "sendMessage" | "bang" | "abortMessage" | "clearMessages" | "rewindToMessage" | "listRewindCheckpoints" | "deleteQueuedMessage" | "updateQueuedMessage" | "deleteQueuedMessageById" | "getMessages" | "getFullMessageThread" | "setPermissionMode" | "getPermissionMode" | "getMcpServers" | "connectMcpServer" | "disconnectMcpServer" | "getSlashCommands" | "searchFiles" | "getPromptHistory" | "searchPromptHistory" | "updateConfig" | "getAuthStatus" | "login" | "logout" | "listPlugins" | "installPlugin" | "uninstallPlugin" | "enablePlugin" | "disablePlugin" | "updatePlugin" | "listMarketplaces" | "addMarketplace" | "removeMarketplace" | "updateMarketplace" | "compact" | "getBackgroundTaskOutput" | "stopBackgroundTask" | "getWorkflowRuns" | "stopWorkflowRun" | "listGitBranches" | "createWorktree" | "removeWorktree";
+export type RequestMethod = "initialize" | "destroy" | "restoreSession" | "listSessions" | "getSessionInfo" | "sendMessage" | "bang" | "askBtw" | "abortMessage" | "clearMessages" | "rewindToMessage" | "listRewindCheckpoints" | "deleteQueuedMessage" | "updateQueuedMessage" | "deleteQueuedMessageById" | "getMessages" | "getFullMessageThread" | "setPermissionMode" | "getPermissionMode" | "getMcpServers" | "connectMcpServer" | "disconnectMcpServer" | "getSlashCommands" | "searchFiles" | "getPromptHistory" | "searchPromptHistory" | "updateConfig" | "listPendingPermissions" | "getAuthStatus" | "login" | "logout" | "listPlugins" | "installPlugin" | "uninstallPlugin" | "enablePlugin" | "disablePlugin" | "updatePlugin" | "listMarketplaces" | "addMarketplace" | "removeMarketplace" | "updateMarketplace" | "compact" | "getBackgroundTaskOutput" | "stopBackgroundTask" | "getWorkflowRuns" | "stopWorkflowRun" | "listGitBranches" | "createWorktree" | "removeWorktree";
 export type ClientNotificationMethod = "permissionResponse";
-export type ServerNotificationMethod = "messagesChange" | "userMessageAdded" | "assistantMessageAdded" | "assistantContentUpdated" | "assistantReasoningUpdated" | "toolBlockUpdated" | "errorBlockAdded" | "loadingChange" | "commandRunningChange" | "queuedMessagesChange" | "tasksChange" | "sessionIdChange" | "permissionModeChange" | "mcpServersChange" | "workdirChange" | "bangMessageAdded" | "bangMessageUpdated" | "bangMessageCompleted" | "notificationMessageAdded" | "permissionRequest" | "authUrl" | "compactBlockAdded" | "compactionStateChange" | "backgroundTasksChange";
+export type ServerNotificationMethod = "userMessageAdded" | "assistantMessageAdded" | "assistantContentUpdated" | "assistantReasoningUpdated" | "toolBlockUpdated" | "errorBlockAdded" | "loadingChange" | "commandRunningChange" | "queuedMessagesChange" | "tasksChange" | "sessionIdChange" | "permissionModeChange" | "mcpServersChange" | "workdirChange" | "bangMessageAdded" | "bangMessageUpdated" | "bangMessageCompleted" | "notificationMessageAdded" | "permissionRequest" | "authUrl" | "compactBlockAdded" | "compactionStateChange" | "backgroundTasksChange" | "btwContent";
 export declare function isRequest(msg: unknown): msg is JsonRpcRequest;
 export declare function isNotification(msg: unknown): msg is JsonRpcNotification;

package/dist/stdio/stdioServer.d.ts

@@ -3,6 +3,7 @@
  * and writes responses / notifications to stdout.
  *
  * One JSON object per line. stderr is reserved for logger output.
+ * Line handling lives in JsonRpcConnection (shared with DaemonServer).
  */
 import type { Readable, Writable } from "stream";
 import { AgentBridge, type AgentBridgeOptions } from "./agentBridge.js";
@@ -12,22 +13,16 @@ export interface StdioServerOptions {
     bridgeOptions?: AgentBridgeOptions;
 }
 export declare class StdioServer {
-    private rl;
     private bridge;
-    private input;
-    private output;
-    private started;
+    private conn;
     constructor(options?: StdioServerOptions);
     get agentBridge(): AgentBridge;
     start(): void;
     stop(): void;
     handleLine(line: string): Promise<void>;
-    private handleRequest;
-    private handleNotification;
     sendResponse(id: number | string | null, result?: unknown, error?: {
         code: number;
         message: string;
     }): void;
     sendNotification(method: string, params?: unknown, sessionId?: string): void;
-    private write;
 }

package/dist/stdio/stdioServer.js

@@ -3,125 +3,34 @@
  * and writes responses / notifications to stdout.
  *
  * One JSON object per line. stderr is reserved for logger output.
+ * Line handling lives in JsonRpcConnection (shared with DaemonServer).
  */
-import readline from "readline";
 import { AgentBridge } from "./agentBridge.js";
-import { PARSE_ERROR, INVALID_REQUEST, INTERNAL_ERROR, isRequest, isNotification, } from "./protocol.js";
+import { JsonRpcConnection } from "./jsonRpcConnection.js";
 export class StdioServer {
     constructor(options = {}) {
-        this.started = false;
-        this.input = options.input ?? process.stdin;
-        this.output = options.output ?? process.stdout;
         this.bridge = new AgentBridge({
             ...options.bridgeOptions,
             emit: (method, params, sessionId) => this.sendNotification(method, params, sessionId),
         });
+        this.conn = new JsonRpcConnection(options.input ?? process.stdin, options.output ?? process.stdout, this.bridge);
     }
     get agentBridge() {
         return this.bridge;
     }
     start() {
-        if (this.started)
-            return;
-        this.started = true;
-        this.rl = readline.createInterface({
-            input: this.input,
-            crlfDelay: Infinity,
-        });
-        this.rl.on("line", (line) => {
-            this.handleLine(line).catch((err) => {
-                // Should never reach here — handleLine catches internally
-                this.sendResponse(null, undefined, {
-                    code: INTERNAL_ERROR,
-                    message: `Unhandled error: ${err.message}`,
-                });
-            });
-        });
-        this.rl.on("close", () => {
-            this.started = false;
-        });
+        this.conn.start();
     }
     stop() {
-        this.rl?.close();
-        this.rl = undefined;
-        this.started = false;
+        this.conn.stop();
     }
-    async handleLine(line) {
-        const trimmed = line.trim();
-        if (!trimmed)
-            return;
-        let msg;
-        try {
-            msg = JSON.parse(trimmed);
-        }
-        catch {
-            this.sendResponse(null, undefined, {
-                code: PARSE_ERROR,
-                message: "Parse error: invalid JSON",
-            });
-            return;
-        }
-        if (isRequest(msg)) {
-            await this.handleRequest(msg);
-        }
-        else if (isNotification(msg)) {
-            this.handleNotification(msg);
-        }
-        else {
-            // Echo back the id if the message has one, otherwise null
-            const id = typeof msg === "object" &&
-                msg !== null &&
-                "id" in msg &&
-                (typeof msg.id === "number" ||
-                    typeof msg.id === "string")
-                ? msg.id
-                : null;
-            this.sendResponse(id, undefined, {
-                code: INVALID_REQUEST,
-                message: "Invalid request: must have 'method' field",
-            });
-        }
+    handleLine(line) {
+        return this.conn.handleLine(line);
     }
-    async handleRequest(msg) {
-        try {
-            const result = await this.bridge.handleRequest(msg.method, msg.params, msg.sessionId);
-            this.sendResponse(msg.id, result);
-        }
-        catch (err) {
-            const code = err && typeof err === "object" && "code" in err
-                ? err.code
-                : INTERNAL_ERROR;
-            const message = err instanceof Error ? err.message : String(err);
-            this.sendResponse(msg.id, undefined, { code, message });
-        }
-    }
-    handleNotification(msg) {
-        try {
-            this.bridge.handleNotification(msg.method, msg.params);
-        }
-        catch (err) {
-            // Notifications don't get responses, but we log to stderr
-            process.stderr.write(`Error handling notification ${msg.method}: ${err.message}\n`);
-        }
-    }
-    // ── Output helpers ────────────────────────────────────────────
     sendResponse(id, result, error) {
-        const response = { id };
-        if (error) {
-            response.error = error;
-        }
-        else {
-            response.result = result ?? null;
-        }
-        this.write(response);
+        this.conn.sendResponse(id, result, error);
     }
     sendNotification(method, params, sessionId) {
-        const notification = { method, params };
-        if (sessionId)
-            notification.sessionId = sessionId;
-        this.write(notification);
-    }
-    write(obj) {
-        this.output.write(JSON.stringify(obj) + "\n");
+        this.conn.sendNotification(method, params, sessionId);
     }
 }

package/dist/utils/bracketedPaste.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Bracketed paste (DECSET 2004) detector.
+ *
+ * When bracketed paste is enabled, terminals wrap pasted text in
+ * `\x1b[200~` (start) and `\x1b[201~` (end) markers, which lets the input
+ * pipeline distinguish "text was pasted" from "user typed keys" — most
+ * importantly, a pasted trailing `\r` must NOT be treated as an Enter key.
+ *
+ * ink delivers each stdin chunk through useInput after stripping ONE leading
+ * ESC from the parsed sequence (see use-input.js), so markers may arrive in
+ * either the raw form (`\x1b[200~`) or the stripped form (`[200~`), and may
+ * be split across chunks. The detector normalizes both forms and buffers
+ * partial markers until they complete (deferral is safe: a deferred partial
+ * is flushed unchanged if the next chunk does not complete a marker).
+ */
+export type PasteProcessResult = {
+    kind: "input";
+    input: string;
+} | {
+    kind: "paste";
+    text: string;
+    leadingInput?: string;
+} | {
+    kind: "consume";
+};
+export interface BracketedPasteDetector {
+    /**
+     * Feed one input chunk (as delivered by ink's useInput callback).
+     * - `input`: regular keystrokes, pass through to normal handling.
+     * - `paste`: completed bracketed paste; insert `text` without submitting.
+     *   `leadingInput` (rare) is content that preceded the start marker in the
+     *   same chunk and should be handled as regular input first.
+     * - `consume`: content of an in-flight paste (or an empty paste); do
+     *   nothing with this chunk.
+     */
+    process(chunk: string): PasteProcessResult;
+    reset(): void;
+}
+export declare function createBracketedPasteDetector(): BracketedPasteDetector;

package/dist/utils/bracketedPaste.js

@@ -0,0 +1,122 @@
+const ESC = "\u001b";
+const START_STRIPPED = "[200~";
+const START_RAW = `${ESC}[200~`;
+const END_STRIPPED = "[201~";
+const END_RAW = `${ESC}[201~`;
+const START_FORMS = [START_RAW, START_STRIPPED];
+const END_FORMS = [END_RAW, END_STRIPPED];
+/**
+ * Suffixes that may be the beginning of a marker split across chunks.
+ * Longest-first so the longest matching suffix is deferred (e.g. `[200`
+ * rather than `[20` for `...x[200`). Deferral is flush-equivalent: if the
+ * next chunk does not complete a marker, the deferred suffix is delivered
+ * as regular input unchanged.
+ */
+const PARTIAL_SUFFIXES = [
+    `${ESC}[201`,
+    `${ESC}[200`,
+    `${ESC}[20`,
+    `${ESC}[2`,
+    "[201",
+    "[200",
+    "[20",
+    "[2",
+].sort((a, b) => b.length - a.length);
+export function createBracketedPasteDetector() {
+    let inPaste = false;
+    let buffer = ""; // paste content collected since the start marker
+    let pending = ""; // deferred partial marker suffix from a previous chunk
+    const findFirst = (text, forms) => {
+        let best = null;
+        for (const form of forms) {
+            const index = text.indexOf(form);
+            if (index !== -1 && (best === null || index < best.index)) {
+                best = { index, length: form.length };
+            }
+        }
+        return best;
+    };
+    const endsWithPartial = (text) => {
+        for (const prefix of PARTIAL_SUFFIXES) {
+            if (text.endsWith(prefix)) {
+                return prefix;
+            }
+        }
+        return null;
+    };
+    const process = (chunk) => {
+        let remaining = pending + chunk;
+        pending = "";
+        let leadingInput = "";
+        let pasteText = null;
+        while (remaining.length > 0) {
+            if (!inPaste) {
+                const start = findFirst(remaining, START_FORMS);
+                if (start) {
+                    leadingInput += remaining.slice(0, start.index);
+                    remaining = remaining.slice(start.index + start.length);
+                    inPaste = true;
+                    continue;
+                }
+                // Orphan end marker (start was missed, e.g. consumed by another
+                // input handler): treat the preceding text as paste so a trailing
+                // `\r` cannot trigger the coalesced-Enter submit heuristic.
+                const end = findFirst(remaining, END_FORMS);
+                if (end) {
+                    pasteText =
+                        (pasteText ?? "") + leadingInput + remaining.slice(0, end.index);
+                    leadingInput = "";
+                    remaining = remaining.slice(end.index + end.length);
+                    continue;
+                }
+                const partial = endsWithPartial(remaining);
+                if (partial) {
+                    pending = remaining.slice(remaining.length - partial.length);
+                    remaining = remaining.slice(0, remaining.length - partial.length);
+                }
+                if (remaining.length > 0) {
+                    leadingInput += remaining;
+                    remaining = "";
+                }
+                break;
+            }
+            const end = findFirst(remaining, END_FORMS);
+            if (end) {
+                pasteText = (pasteText ?? "") + buffer + remaining.slice(0, end.index);
+                buffer = "";
+                inPaste = false;
+                remaining = remaining.slice(end.index + end.length);
+                continue;
+            }
+            const partial = endsWithPartial(remaining);
+            if (partial) {
+                pending = remaining.slice(remaining.length - partial.length);
+                remaining = remaining.slice(0, remaining.length - partial.length);
+            }
+            buffer += remaining;
+            remaining = "";
+            break;
+        }
+        if (inPaste) {
+            // Paste still in flight: hold the content, deliver nothing yet.
+            return { kind: "consume" };
+        }
+        if (pasteText !== null) {
+            const result = {
+                kind: "paste",
+                text: pasteText,
+            };
+            if (leadingInput !== "") {
+                result.leadingInput = leadingInput;
+            }
+            return result;
+        }
+        return { kind: "input", input: leadingInput };
+    };
+    const reset = () => {
+        inPaste = false;
+        buffer = "";
+        pending = "";
+    };
+    return { process, reset };
+}

package/dist/utils/markdownTable.d.ts

@@ -0,0 +1,34 @@
+import type { Token, Tokens } from "marked";
+export type CellAlign = "left" | "center" | "right" | null;
+/**
+ * Wrap text to fit within a given width, returning array of lines.
+ * ANSI-aware: preserves styling across line breaks.
+ *
+ * @param hard - If true, break words that exceed width (needed when columns
+ *               are narrower than the longest word). Default false.
+ */
+export declare function wrapText(text: string, width: number, options?: {
+    hard?: boolean;
+}): string[];
+/**
+ * Pad `content` to `targetWidth` according to alignment. `displayWidth` is the
+ * visible width of `content` (caller computes this, e.g. via stringWidth on
+ * ANSI-stripped text, so ANSI codes in `content` don't affect padding).
+ */
+export declare function padAligned(content: string, displayWidth: number, targetWidth: number, align: CellAlign | undefined): string;
+/**
+ * Render a markdown table to a box-drawing ANSI string for the terminal.
+ * Handles terminal width by:
+ * 1. Calculating minimum column widths based on longest word
+ * 2. Distributing available space proportionally
+ * 3. Wrapping text within cells (no truncation)
+ * 4. Falling back to a vertical key-value format when rows would be too
+ *    tall or the table still overflows the terminal width
+ *
+ * @param token - marked table token
+ * @param columns - terminal width
+ * @param formatInline - formats inline tokens to an ANSI string (the caller
+ *                       binds its marked parser so this module stays
+ *                       parser-agnostic and directly testable)
+ */
+export declare function renderMarkdownTable(token: Tokens.Table, columns: number, formatInline: (tokens: Token[]) => string): string;