swarm-code 0.1.14 → 0.1.15

package/dist/interactive-swarm.js

@@ -19,7 +19,7 @@
 import "./env.js";
 import * as fs from "node:fs";
 import * as path from "node:path";
-import * as readline from "node:readline";
+import { readTextInput } from "./ui/text-input.js";
 // Dynamic imports — ensures env.js has set process.env BEFORE pi-ai loads
 await import("@mariozechner/pi-ai");
 const { PythonRepl } = await import("./core/repl.js");
@@ -538,9 +538,13 @@ function cmdStatus(threadManager, sessionStartTime, taskCount) {
     out.write("\n");
 }
 // ── Configure command ───────────────────────────────────────────────────────
-async function cmdConfigure(config, resolved, rl) {
+async function cmdConfigure(config, resolved) {
     const out = process.stderr;
-    const ask = (q) => new Promise((res) => rl.question(q, (a) => res(a.trim())));
+    const ask = async (q) => {
+        const { readTextInput: readInput } = await import("./ui/text-input.js");
+        const result = await readInput(q);
+        return result.text;
+    };
     out.write("\n");
     out.write(`  ${bold(cyan("Configuration"))}\n`);
     out.write(`  ${dim(symbols.horizontal.repeat(40))}\n\n`);
@@ -835,56 +839,20 @@ export async function runInteractiveSwarm(rawArgs) {
     let taskCount = 0;
     // Start Python REPL
     await repl.start(sessionAc.signal);
-    // Create readline interface
-    const rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stderr,
-        prompt: isTTY ? `  ${coral("swarm")}${dim(">")} ` : "swarm> ",
-        terminal: isTTY,
-    });
-    // SIGINT handling — first press cancels current task, second exits
     let currentTaskAc = null;
-    let sigintCount = 0;
     let cleanupCalled = false;
-    // Forward declarations for mutual references
-    function handleSigint() {
-        sigintCount++;
-        if (sigintCount === 1 && currentTaskAc) {
-            // Cancel current task
-            process.stderr.write(`\n  ${yellow("Cancelling current task...")} ${dim("(press Ctrl+C again to exit)")}\n`);
-            currentTaskAc.abort();
-            currentTaskAc = null;
-        }
-        else if (sigintCount >= 2) {
-            // Force exit
-            process.stderr.write(`\n  ${yellow("Exiting...")}\n`);
-            cleanup();
-        }
-        else {
-            // No task running, treat as exit warning
-            process.stderr.write(`\n  ${dim("Press Ctrl+C again to exit, or type /quit")}\n`);
-            sigintCount = 1;
-            // Reset after 2 seconds
-            setTimeout(() => {
-                sigintCount = 0;
-            }, 2000);
-        }
-    }
     async function cleanup() {
         if (cleanupCalled)
             return;
         cleanupCalled = true;
-        rl.close();
         spinner.stop();
         dashboard.clear();
-        process.removeListener("SIGINT", handleSigint);
         sessionAc.abort();
         repl.shutdown();
         await threadManager.cleanup();
         await opencodeMod.disableServerMode();
         process.exit(0);
     }
-    process.on("SIGINT", handleSigint);
     // Thread handler (reused across tasks)
     const threadHandler = async (task, threadContext, agentBackend, model, files) => {
         let resolvedAgent = agentBackend || config.default_agent;
@@ -969,7 +937,6 @@ export async function runInteractiveSwarm(rawArgs) {
     // Run a task through the RLM loop
     const runTask = async (query) => {
         taskCount++;
-        sigintCount = 0;
         currentTaskAc = new AbortController();
         // Link task abort to session abort
         const onSessionAbort = () => currentTaskAc?.abort();
@@ -1039,7 +1006,6 @@ export async function runInteractiveSwarm(rawArgs) {
         finally {
             sessionAc.signal.removeEventListener("abort", onSessionAbort);
             currentTaskAc = null;
-            sigintCount = 0;
         }
     };
     // Process a line of input
@@ -1087,7 +1053,7 @@ export async function runInteractiveSwarm(rawArgs) {
                 case "/configure":
                 case "/config":
                 case "/c":
-                    await cmdConfigure(config, resolved, rl);
+                    await cmdConfigure(config, resolved);
                     break;
                 case "/quit":
                 case "/exit":
@@ -1103,13 +1069,19 @@ export async function runInteractiveSwarm(rawArgs) {
         await runTask(trimmed);
         return false;
     };
-    // REPL loop
-    rl.prompt();
-    rl.on("line", async (line) => {
-        // Pause readline during processing so prompt doesn't re-appear
-        rl.pause();
+    // REPL loop — multi-line text input
+    const promptStr = `${coral("swarm")}${dim(">")} `;
+    while (!cleanupCalled) {
+        const result = await readTextInput(promptStr);
+        if (result.action === "escape") {
+            await cleanup();
+            return;
+        }
+        const text = result.text;
+        if (!text)
+            continue;
         try {
-            const shouldExit = await processLine(line);
+            const shouldExit = await processLine(text);
             if (shouldExit) {
                 await cleanup();
                 return;
@@ -1119,13 +1091,6 @@ export async function runInteractiveSwarm(rawArgs) {
             const msg = err instanceof Error ? err.message : String(err);
             logError(`Unexpected error: ${msg}`);
         }
-        // Resume and show prompt again
-        rl.resume();
-        rl.prompt();
-    });
-    rl.on("close", async () => {
-        process.stderr.write("\n");
-        await cleanup();
-    });
+    }
 }
 //# sourceMappingURL=interactive-swarm.js.map

package/dist/ui/text-input.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Text input for the interactive REPL with multi-line paste support.
+ *
+ * Uses raw stdin to detect paste vs keypress:
+ *   - Pasted text arrives as a single data chunk containing newlines → preserved as multi-line
+ *   - Typed Enter alone → submits the input
+ *   - Escape → signals exit
+ *   - Ctrl+D → submits current input
+ *   - Ctrl+C → signals exit
+ *   - Standard editing: backspace, left/right arrows, home/end
+ */
+export interface TextInputResult {
+    text: string;
+    action: "submit" | "escape";
+}
+/**
+ * Read user input with multi-line paste support and escape-to-exit.
+ *
+ * Behavior:
+ *   - Single Enter: submits current line(s)
+ *   - Pasted text with newlines: captured as multi-line, then Enter submits all
+ *   - Escape: returns action "escape" to signal exit
+ *   - Ctrl+D: submits whatever is in the buffer
+ */
+export declare function readTextInput(prompt: string): Promise<TextInputResult>;

package/dist/ui/text-input.js

@@ -0,0 +1,198 @@
+/**
+ * Text input for the interactive REPL with multi-line paste support.
+ *
+ * Uses raw stdin to detect paste vs keypress:
+ *   - Pasted text arrives as a single data chunk containing newlines → preserved as multi-line
+ *   - Typed Enter alone → submits the input
+ *   - Escape → signals exit
+ *   - Ctrl+D → submits current input
+ *   - Ctrl+C → signals exit
+ *   - Standard editing: backspace, left/right arrows, home/end
+ */
+import { dim, isTTY, stripAnsi } from "./theme.js";
+/**
+ * Read user input with multi-line paste support and escape-to-exit.
+ *
+ * Behavior:
+ *   - Single Enter: submits current line(s)
+ *   - Pasted text with newlines: captured as multi-line, then Enter submits all
+ *   - Escape: returns action "escape" to signal exit
+ *   - Ctrl+D: submits whatever is in the buffer
+ */
+export function readTextInput(prompt) {
+    if (!isTTY) {
+        return new Promise((resolve) => {
+            let data = "";
+            process.stdin.setEncoding("utf-8");
+            const onData = (chunk) => {
+                data += chunk;
+                if (data.includes("\n")) {
+                    process.stdin.removeListener("data", onData);
+                    resolve({ text: data.trim(), action: "submit" });
+                }
+            };
+            process.stdin.on("data", onData);
+            process.stdin.resume();
+        });
+    }
+    return new Promise((resolve) => {
+        const linesBuf = [""];
+        let cursorPos = 0; // position within current (last) line
+        const origRawMode = process.stdin.isRaw;
+        process.stdin.setRawMode(true);
+        process.stdin.resume();
+        process.stdin.setEncoding("utf-8");
+        const promptVisible = stripAnsi(prompt);
+        function redrawCurrentLine() {
+            const currentLine = linesBuf[linesBuf.length - 1];
+            process.stderr.write("\x1b[2K\x1b[0G"); // clear line
+            if (linesBuf.length === 1) {
+                // First line — show prompt
+                process.stderr.write(`  ${prompt}${currentLine}`);
+                const col = 3 + promptVisible.length + cursorPos;
+                process.stderr.write(`\x1b[${col}G`);
+            }
+            else {
+                // Continuation line — indent to match
+                const pad = " ".repeat(promptVisible.length);
+                process.stderr.write(`  ${dim(".")} ${pad.slice(2)}${currentLine}`);
+                const col = 3 + promptVisible.length + cursorPos;
+                process.stderr.write(`\x1b[${col}G`);
+            }
+        }
+        // Show initial prompt
+        process.stderr.write(`  ${prompt}`);
+        const onData = (data) => {
+            // Check if this looks like a paste (multiple chars with newlines)
+            const hasNewlines = data.includes("\n") || data.includes("\r");
+            const isMultiChar = data.length > 1;
+            const isPaste = hasNewlines && isMultiChar;
+            if (isPaste) {
+                // Paste mode — split on newlines, add all to buffer
+                const pastedLines = data.split(/\r\n|\r|\n/);
+                // Append first fragment to current line at cursor
+                const currentLine = linesBuf[linesBuf.length - 1];
+                linesBuf[linesBuf.length - 1] = currentLine.slice(0, cursorPos) + pastedLines[0] + currentLine.slice(cursorPos);
+                // Redraw current line with pasted content
+                cursorPos = (currentLine.slice(0, cursorPos) + pastedLines[0]).length;
+                redrawCurrentLine();
+                // Add remaining lines
+                for (let i = 1; i < pastedLines.length; i++) {
+                    const line = pastedLines[i];
+                    if (i === pastedLines.length - 1 && line === "") {
+                        // Trailing newline — don't add empty line
+                        break;
+                    }
+                    process.stderr.write("\n");
+                    linesBuf.push(line);
+                    cursorPos = line.length;
+                    redrawCurrentLine();
+                }
+                return;
+            }
+            // Character-by-character processing
+            for (let i = 0; i < data.length; i++) {
+                const ch = data[i];
+                // Escape sequences
+                if (ch === "\x1b") {
+                    if (data[i + 1] === "[") {
+                        const code = data[i + 2];
+                        if (code === "C") {
+                            // Right arrow
+                            if (cursorPos < linesBuf[linesBuf.length - 1].length) {
+                                cursorPos++;
+                                redrawCurrentLine();
+                            }
+                            i += 2;
+                            continue;
+                        }
+                        if (code === "D") {
+                            // Left arrow
+                            if (cursorPos > 0) {
+                                cursorPos--;
+                                redrawCurrentLine();
+                            }
+                            i += 2;
+                            continue;
+                        }
+                        if (code === "H") {
+                            // Home
+                            cursorPos = 0;
+                            redrawCurrentLine();
+                            i += 2;
+                            continue;
+                        }
+                        if (code === "F") {
+                            // End
+                            cursorPos = linesBuf[linesBuf.length - 1].length;
+                            redrawCurrentLine();
+                            i += 2;
+                            continue;
+                        }
+                        // Skip other escape sequences
+                        i += 2;
+                        continue;
+                    }
+                    // Bare Escape key — exit
+                    finish();
+                    resolve({ text: "", action: "escape" });
+                    return;
+                }
+                // Ctrl+D — submit
+                if (ch === "\x04") {
+                    const text = linesBuf.join("\n").trim();
+                    finish();
+                    resolve({ text, action: "submit" });
+                    return;
+                }
+                // Ctrl+C — exit
+                if (ch === "\x03") {
+                    finish();
+                    resolve({ text: "", action: "escape" });
+                    return;
+                }
+                // Enter — submit
+                if (ch === "\r" || ch === "\n") {
+                    const text = linesBuf.join("\n").trim();
+                    finish();
+                    resolve({ text, action: "submit" });
+                    return;
+                }
+                // Backspace
+                if (ch === "\x7f" || ch === "\b") {
+                    if (cursorPos > 0) {
+                        const line = linesBuf[linesBuf.length - 1];
+                        linesBuf[linesBuf.length - 1] = line.slice(0, cursorPos - 1) + line.slice(cursorPos);
+                        cursorPos--;
+                        redrawCurrentLine();
+                    }
+                    continue;
+                }
+                // Tab — insert spaces
+                if (ch === "\t") {
+                    const line = linesBuf[linesBuf.length - 1];
+                    linesBuf[linesBuf.length - 1] = line.slice(0, cursorPos) + "  " + line.slice(cursorPos);
+                    cursorPos += 2;
+                    redrawCurrentLine();
+                    continue;
+                }
+                // Regular printable character
+                if (ch >= " ") {
+                    const line = linesBuf[linesBuf.length - 1];
+                    linesBuf[linesBuf.length - 1] = line.slice(0, cursorPos) + ch + line.slice(cursorPos);
+                    cursorPos++;
+                    redrawCurrentLine();
+                }
+            }
+        };
+        function finish() {
+            process.stdin.removeListener("data", onData);
+            if (origRawMode !== undefined) {
+                process.stdin.setRawMode(origRawMode);
+            }
+            process.stderr.write("\n");
+        }
+        process.stdin.on("data", onData);
+    });
+}
+//# sourceMappingURL=text-input.js.map

package/dist/ui/theme.d.ts

@@ -41,13 +41,13 @@ export declare const symbols: {
     readonly info: "●" | "[*]";
     readonly arrow: "▶" | ">";
     readonly dot: "." | "·";
-    readonly dash: "-" | "─";
+    readonly dash: "─" | "-";
     readonly vertLine: "│" | "|";
     readonly topLeft: "╭" | "+";
     readonly topRight: "+" | "╮";
     readonly bottomLeft: "+" | "╰";
     readonly bottomRight: "+" | "╯";
-    readonly horizontal: "-" | "─";
+    readonly horizontal: "─" | "-";
     readonly spinner: string[];
 };
 /** Get terminal width, with a sensible fallback. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "swarm-code",
-  "version": "0.1.14",
+  "version": "0.1.15",
   "description": "Open-source swarm-native coding agent orchestrator — spawns parallel coding agents in isolated git worktrees, built on RLM (arXiv:2512.24601)",
   "type": "module",
   "bin": {