agent-repl 0.1.2 → 0.1.5

package/CHANGELOG.md

@@ -4,6 +4,30 @@ All notable changes to `agent-repl` are documented here.
 
 ## [Unreleased]
 
+## [0.1.5] — 2026-10-19
+
+### Changed
+- Generated from pi-repl 0.8.6.
+
+### Fixed
+- The 0.1.3 done-marker footer no longer waits without limit for its Node helper. In Julia and R, a Node startup hook (`NODE_OPTIONS`) that kept Node running held the cell's completion indefinitely. In Clojure, an interrupt while the footer waited left the tmux query running.
+
+## [0.1.4] — 2026-10-19
+
+### Changed
+- Generated from pi-repl 0.8.5.
+
+### Fixed
+- Julia no longer leaves copies of a wrapped submission line in the output, as it did in panes narrower than the `include(...)` line, such as a detached session's default 80 columns.
+
+## [0.1.3] — 2026-10-19
+
+### Changed
+- Generated from pi-repl 0.8.4.
+
+### Fixed
+- In the Summary and Full displays, output that doesn't end its line no longer runs into the done marker in Python, IPython, Julia, R and Clojure. The marker then stayed in the clean output, as in `c── done · id: … ──`.
+
 ## [0.1.2] — 2026-10-19
 
 ### Changed

package/dist/pi-repl.js

@@ -1,4 +1,4 @@
-// GENERATED by scripts/sync-from-pi-repl.mjs from pi-repl 0.8.3 (45b5042). Do not edit by hand:
+// GENERATED by scripts/sync-from-pi-repl.mjs from pi-repl 0.8.6 (7dd015b). Do not edit by hand:
 // change pi-repl and re-sync. Identical to pi-repl's index.ts except that its Pi
 // imports come from ./pi-compat/index.js.
 import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize, truncateHead, truncateTail, } from "./pi-compat/index.js";
@@ -887,9 +887,36 @@ function buildClojureDisplayStatements(display, indent = "") {
         return [];
     return display.prefixLines.map((line) => `${indent}(clojure.core/println ${JSON.stringify(line)})`);
 }
+// Prints the pane's cursor column, or exits non-zero; tmux gets 500 ms. A
+// wrapper runs it with Node and ends a line before its footer unless it
+// prints 0. Only the wrapper reads its output, so it never reaches the pane.
+// process.exit ends Node even if a startup hook in NODE_OPTIONS would keep it
+// running, and each wrapper also limits the whole helper to 5 s.
+const CURSOR_COLUMN_QUERY = 'let code = 1; try { require("node:fs").writeSync(1, require("node:child_process").execFileSync("tmux", ["-N", "display-message", "-p", "-t", process.env.TMUX_PANE, "#{cursor_x}"], { encoding: "utf8", timeout: 500, killSignal: "SIGKILL", maxBuffer: 128, stdio: ["ignore", "pipe", "ignore"] }).trim()); code = 0; } catch {} process.exit(code);';
+function buildPythonFooter(display) {
+    if (!display.enabled)
+        return [];
+    return [
+        "    import subprocess as __pi_repl_subprocess",
+        "    import sys as __pi_repl_sys",
+        "    __pi_repl_column = ''",
+        "    try:",
+        "        __pi_repl_sys.stdout.flush()",
+        "        __pi_repl_sys.stderr.flush()",
+        `        __pi_repl_query = __pi_repl_subprocess.run([${JSON.stringify(process.execPath)}, '-e', ${JSON.stringify(CURSOR_COLUMN_QUERY)}], stdin=__pi_repl_subprocess.DEVNULL, stdout=__pi_repl_subprocess.PIPE, stderr=__pi_repl_subprocess.DEVNULL, timeout=5)`,
+        "        if __pi_repl_query.returncode == 0:",
+        "            __pi_repl_column = __pi_repl_query.stdout.decode('utf-8', 'replace').strip()",
+        // run() kills the query on any exception. Ctrl-C here must not skip the done file.
+        "    except BaseException:",
+        "        pass",
+        "    if __pi_repl_column != '0':",
+        "        __pi_repl_builtins.print()",
+        ...display.suffixLines.map((line) => `    __pi_repl_builtins.print(${JSON.stringify(line)})`),
+    ];
+}
 function buildPythonControlSource(runtime, code, doneFile, display) {
     const prefix = buildPythonDisplayStatements(display);
-    const completion = display.suffixLines.map((line) => `    __pi_repl_builtins.print(${JSON.stringify(line)})`);
+    const completion = buildPythonFooter(display);
     if (runtime === "ipython") {
         return [
             "from pathlib import Path as __pi_repl_path",
@@ -923,8 +950,45 @@ function buildPythonControlSource(runtime, code, doneFile, display) {
         `    __pi_repl_path(${JSON.stringify(doneFile)}).write_text('done\\n', encoding='utf-8')`,
     ].join("\n");
 }
+function buildJuliaFooter(display) {
+    if (!display.enabled)
+        return [];
+    const query = `Cmd([${juliaStringLiteral(process.execPath)}, "-e", ${juliaStringLiteral(CURSOR_COLUMN_QUERY)}])`;
+    return [
+        '    local __pi_repl_column = ""',
+        "    local __pi_repl_query = nothing",
+        // The wait, not the read, is bounded: a child the helper started could
+        // keep the pipe open after the helper exits. An interrupt does not end
+        // the wait, since killing Node early would leave its tmux child
+        // running. After 5 s a helper still running is killed, and the pipe
+        // is closed so that the reader ends too.
+        "    try",
+        "        flush(stdout)",
+        "        flush(stderr)",
+        `        __pi_repl_query = open(pipeline(${query}, stdin=devnull, stderr=devnull), "r")`,
+        "        local __pi_repl_reader = @async read(__pi_repl_query, String)",
+        "        local __pi_repl_deadline = time_ns() + 5_000_000_000",
+        "        local __pi_repl_finished = false",
+        "        while !__pi_repl_finished && time_ns() < __pi_repl_deadline",
+        "            try",
+        "                __pi_repl_finished = timedwait(() -> istaskdone(__pi_repl_reader) && process_exited(__pi_repl_query), max(0.01, (signed(__pi_repl_deadline) - signed(time_ns())) / 1e9); pollint=0.01) === :ok",
+        "            catch",
+        "            end",
+        "        end",
+        "        __pi_repl_finished && success(__pi_repl_query) && (__pi_repl_column = strip(fetch(__pi_repl_reader)))",
+        "    catch",
+        "    finally",
+        "        if !isnothing(__pi_repl_query)",
+        "            process_exited(__pi_repl_query) || kill(__pi_repl_query, Base.SIGKILL)",
+        "            try close(__pi_repl_query.out) catch end",
+        "        end",
+        "    end",
+        '    __pi_repl_column == "0" || Base.println()',
+        ...display.suffixLines.map((line) => `    Base.println(${juliaStringLiteral(line)})`),
+    ];
+}
 function buildJuliaControlSource(code, doneFile, display) {
-    const completion = display.suffixLines.map((line) => `    Base.println(${juliaStringLiteral(line)})`);
+    const completion = buildJuliaFooter(display);
     return [
         ...buildJuliaDisplayStatements(display),
         "try",
@@ -940,8 +1004,21 @@ function buildJuliaControlSource(code, doneFile, display) {
         "end",
     ].join("\n");
 }
+function buildRFooter(display) {
+    if (!display.enabled)
+        return [];
+    return [
+        "    try({ flush(stdout()); flush(stderr()) }, silent = TRUE)",
+        // system2 quotes the command but not its arguments, and kills it after
+        // 5 s. A failed query sets a status; an error or Ctrl-C here gives
+        // NULL, not a lost done file.
+        `    .__pi_repl_column <- tryCatch(suppressWarnings(system2(${JSON.stringify(process.execPath)}, c("-e", ${JSON.stringify(shellQuote(CURSOR_COLUMN_QUERY))}), stdout = TRUE, stderr = FALSE, timeout = 5)), error = function(e) NULL, interrupt = function(e) NULL)`,
+        '    if (!is.null(attr(.__pi_repl_column, "status")) || !identical(trimws(paste(.__pi_repl_column, collapse = "")), "0")) base::cat("\\n")',
+        ...display.suffixLines.map((line) => `    base::cat(${JSON.stringify(`${line}\n`)})`),
+    ];
+}
 function buildRControlSource(code, doneFile, display) {
-    const completion = display.suffixLines.map((line) => `    base::cat(${JSON.stringify(`${line}\n`)})`);
+    const completion = buildRFooter(display);
     return [
         "local({",
         ...buildRDisplayStatements(display, "  "),
@@ -1065,8 +1142,44 @@ function buildJavaControlSource(code, doneFile, display) {
     // stays in the outer driver, outside this source file's parser state.
     return [...prefix, code.replace(/\r/g, "").trimEnd(), ""].join("\n");
 }
+function buildClojureFooter(display) {
+    if (!display.enabled)
+        return [];
+    const builder = `(java.lang.ProcessBuilder. ^java.util.List [${JSON.stringify(process.execPath)} "-e" ${JSON.stringify(CURSOR_COLUMN_QUERY)}])`;
+    return [
+        "      (try (.flush *out*) (.flush *err*) (catch Throwable _))",
+        // An interrupt left pending by the code would end the wait at once, so
+        // it is cleared for the query and restored afterwards. One that arrives
+        // during the wait is noted and the wait goes on: killing Node early
+        // would leave its tmux child running. The query is killed after 5 s.
+        "      (let [pi-repl-interrupted (volatile! (Thread/interrupted))",
+        `            pi-repl-query (try (.start (.redirectError ${builder} java.lang.ProcessBuilder$Redirect/DISCARD)) (catch Throwable _ nil))`,
+        "            pi-repl-deadline (+ (System/nanoTime) 5000000000)",
+        "            pi-repl-column (when pi-repl-query",
+        "                             (try",
+        "                               (.close (.getOutputStream pi-repl-query))",
+        "                               (when (and (loop []",
+        "                                            (let [left (- pi-repl-deadline (System/nanoTime))",
+        "                                                  exited (when (pos? left)",
+        "                                                           (try (.waitFor pi-repl-query left java.util.concurrent.TimeUnit/NANOSECONDS)",
+        "                                                             (catch InterruptedException _ (vreset! pi-repl-interrupted true) :interrupted)))]",
+        "                                              (if (= exited :interrupted) (recur) exited)))",
+        "                                          (zero? (.exitValue pi-repl-query)))",
+        // Only what is waiting: a child of Node could hold the pipe open.
+        "                                 (let [in (.getInputStream pi-repl-query)",
+        "                                       bytes (byte-array (min 32 (.available in)))",
+        "                                       n (.read in bytes)]",
+        '                                   (.trim (String. bytes 0 (int (max 0 n)) "UTF-8"))))',
+        "                               (catch Throwable _ nil)",
+        "                               (finally (.destroyForcibly pi-repl-query))))]",
+        "        (when @pi-repl-interrupted (.interrupt (Thread/currentThread)))",
+        '        (when-not (= pi-repl-column "0") (clojure.core/println))',
+        ...display.suffixLines.map((line) => `        (clojure.core/println ${JSON.stringify(line)})`),
+        "        nil)",
+    ];
+}
 function buildClojureControlSource(code, doneFile, display) {
-    const completion = display.suffixLines.map((line) => `      (clojure.core/println ${JSON.stringify(line)})`);
+    const completion = buildClojureFooter(display);
     return [
         "(let [code " + JSON.stringify(code) + "]",
         ...buildClojureDisplayStatements(display, "  "),
@@ -1283,7 +1396,7 @@ function prepareReplControlFiles(runtime, code, details) {
         throw error;
     }
 }
-async function pasteTextToTmuxPane(pi, sessionTarget, cwd, text, onPasted) {
+async function pasteTextToTmuxPane(pi, sessionTarget, cwd, text, onPasted, bracketed = false) {
     const bufferName = `pi-repl-${randomUUID()}`;
     const target = await getPaneTarget(pi, sessionTarget, cwd);
     const controlPaths = createPrivateReplControlFiles({ ...REPL_CONTROL_OPTIONS, extension: "txt", buildSource: () => text });
@@ -1295,7 +1408,10 @@ async function pasteTextToTmuxPane(pi, sessionTarget, cwd, text, onPasted) {
             const reason = loadResult.stderr.trim() || loadResult.stdout.trim() || `exit code ${loadResult.code}`;
             throw new Error(`Failed to load tmux buffer: ${reason}`);
         }
-        const pasteResult = await execTmux(pi, ["paste-buffer", "-d", "-b", bufferName, "-t", target], cwd, 5_000);
+        // -p brackets the paste only if the REPL asked for bracketed pastes.
+        // Julia then draws a line that wraps in the pane once, not once per
+        // character, which left copies of its first row in the output.
+        const pasteResult = await execTmux(pi, ["paste-buffer", ...(bracketed ? ["-p"] : []), "-d", "-b", bufferName, "-t", target], cwd, 5_000);
         if (pasteResult.code !== 0) {
             const reason = pasteResult.stderr.trim() || pasteResult.stdout.trim() || `exit code ${pasteResult.code}`;
             throw new Error(`Failed to paste tmux buffer: ${reason}`);
@@ -1595,7 +1711,7 @@ async function runReplCode(pi, params, ctx, signal, options = {}) {
         await pasteTextToTmuxPane(pi, paneTarget, ctx.cwd, prepared.submissionText, () => {
             submissionStarted = true;
             options.onSubmissionStarted?.(submissionState);
-        });
+        }, runtime === "julia");
         await waitForReplDoneFile(pi, sessionName, sessionTarget, paneTarget, ctx.cwd, prepared.controlPaths.doneFile, timeoutMs, signal, { beforeCapture, prepared, state: submissionState });
         submissionState.completionObserved = true;
         const afterCapture = await capturePaneOutput(pi, paneTarget, ctx.cwd);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "agent-repl",
-	"version": "0.1.2",
+	"version": "0.1.5",
 	"description": "pi-repl's shared tmux REPLs (Python, Julia, R and more) for Claude Code, Codex, OpenCode and other agents, over MCP and a CLI.",
 	"keywords": [
 		"repl",