@iowarp/clio-coder 0.4.0 → 0.4.1

package/dist/chunk-U2WB7TZS.js

@@ -0,0 +1,271 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  gitCommitAttributionEnabled,
+  reportCommitAttributionDiagnostic,
+  withManagedGitCommitAttributionEnvironment
+} from "./chunk-JIEGK6UF.js";
+import {
+  clampTimerDelayMs
+} from "./chunk-EBY63B7G.js";
+import {
+  AI_AGENT_NAME
+} from "./chunk-6EJMN2Y3.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/core/bash-exec.ts
+init_esm_shims();
+import { spawn } from "node:child_process";
+import { StringDecoder } from "node:string_decoder";
+var BASH_HARD_CAP_BYTES = 16 * 1024 * 1024;
+var CLIO_CONTROL_ENV_KEYS = ["CLIO_CODER_INTERACTIVE", "CLIO_CODER_RESUME_SESSION_ID"];
+var BASH_UPDATE_THROTTLE_MS = 100;
+function buildToolEnv() {
+  const env = { ...process.env };
+  env.AI_AGENT = AI_AGENT_NAME;
+  for (const key of CLIO_CONTROL_ENV_KEYS) {
+    Reflect.deleteProperty(env, key);
+  }
+  return env;
+}
+var LOGIN_ENV_CAPTURE_TIMEOUT_MS = 1e4;
+var loginEnvCapture = null;
+function parseNullDelimitedEnv(raw) {
+  const env = {};
+  for (const entry of raw.split("\0")) {
+    if (entry.length === 0) continue;
+    const eq = entry.indexOf("=");
+    if (eq <= 0) continue;
+    env[entry.slice(0, eq)] = entry.slice(eq + 1);
+  }
+  return typeof env.PATH === "string" && env.PATH.length > 0 ? env : null;
+}
+function captureLoginEnv() {
+  return new Promise((resolve) => {
+    let stdout = "";
+    let settled = false;
+    const finish = (value) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(value);
+    };
+    const child = spawn("/bin/bash", ["-lc", "env -0"], {
+      env: buildToolEnv(),
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    const timer = setTimeout(() => {
+      child.kill("SIGKILL");
+      finish(null);
+    }, LOGIN_ENV_CAPTURE_TIMEOUT_MS);
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString("utf8");
+    });
+    child.on("error", () => finish(null));
+    child.on("close", (code) => finish(code === 0 ? parseNullDelimitedEnv(stdout) : null));
+  });
+}
+async function bashSpawnPlan() {
+  loginEnvCapture ??= captureLoginEnv();
+  const captured = await loginEnvCapture;
+  if (captured === null) return { mode: "-lc", env: buildToolEnv() };
+  const env = { ...process.env, ...captured };
+  env.AI_AGENT = AI_AGENT_NAME;
+  for (const key of CLIO_CONTROL_ENV_KEYS) {
+    Reflect.deleteProperty(env, key);
+  }
+  return { mode: "-c", env };
+}
+function combineBashOutput(result) {
+  const { stdout, stderr } = result;
+  return stderr.length > 0 ? `${stdout}${stdout.endsWith("\n") || stdout.length === 0 ? "" : "\n"}${stderr}` : stdout;
+}
+async function runBashCommand(command, options = {}) {
+  const plan = await bashSpawnPlan();
+  const attribution = withManagedGitCommitAttributionEnvironment(plan.env, {
+    cwd: options.cwd ?? process.cwd(),
+    enabled: gitCommitAttributionEnabled(process.env)
+  });
+  reportCommitAttributionDiagnostic(attribution.diagnostic);
+  return new Promise((resolve) => {
+    const timeout = clampTimerDelayMs(options.timeoutMs ?? 3e5);
+    let aborted = false;
+    let timedOut = false;
+    let settled = false;
+    let timeoutId = null;
+    let killGraceTimer = null;
+    let killSent = false;
+    let stdout = "";
+    let stderr = "";
+    const stdoutDecoder = new StringDecoder("utf8");
+    const stderrDecoder = new StringDecoder("utf8");
+    let decodersFinished = false;
+    let outputBytes = 0;
+    let outputCapped = false;
+    let updateTimer = null;
+    let updateDirty = false;
+    let lastUpdateAt = 0;
+    const child = spawn("/bin/bash", [plan.mode, command], {
+      ...options.cwd === void 0 ? {} : { cwd: options.cwd },
+      env: attribution.env,
+      detached: process.platform !== "win32",
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const finishDecoders = () => {
+      if (decodersFinished) return;
+      decodersFinished = true;
+      if (outputCapped) return;
+      stdout += stdoutDecoder.end();
+      stderr += stderrDecoder.end();
+    };
+    const emitUpdate = () => {
+      if (options.onUpdate === void 0 || !updateDirty) return;
+      updateDirty = false;
+      lastUpdateAt = Date.now();
+      try {
+        options.onUpdate({ stdout, stderr, outputBytes: Math.min(outputBytes, BASH_HARD_CAP_BYTES) });
+      } catch {
+      }
+    };
+    const clearUpdateTimer = () => {
+      if (updateTimer === null) return;
+      clearTimeout(updateTimer);
+      updateTimer = null;
+    };
+    const scheduleUpdate = () => {
+      if (options.onUpdate === void 0) return;
+      updateDirty = true;
+      const delay = BASH_UPDATE_THROTTLE_MS - (Date.now() - lastUpdateAt);
+      if (delay <= 0) {
+        clearUpdateTimer();
+        emitUpdate();
+        return;
+      }
+      updateTimer ??= setTimeout(() => {
+        updateTimer = null;
+        emitUpdate();
+      }, delay);
+    };
+    const finishUpdates = () => {
+      clearUpdateTimer();
+      emitUpdate();
+    };
+    if (options.onUpdate !== void 0) {
+      updateDirty = true;
+      emitUpdate();
+    }
+    const clearKillGraceTimer = () => {
+      if (!killGraceTimer) return;
+      clearTimeout(killGraceTimer);
+      killGraceTimer = null;
+    };
+    const sendSignal = (signalName) => {
+      const pid = child.pid;
+      if (pid && process.platform !== "win32") {
+        try {
+          process.kill(-pid, signalName);
+          return;
+        } catch {
+        }
+      }
+      child.kill(signalName);
+    };
+    const killChild = () => {
+      if (killSent) return;
+      killSent = true;
+      sendSignal("SIGTERM");
+      killGraceTimer = setTimeout(() => {
+        sendSignal("SIGKILL");
+      }, 5e3);
+    };
+    function onAbort() {
+      aborted = true;
+      killChild();
+    }
+    if (timeout > 0) {
+      timeoutId = setTimeout(() => {
+        timedOut = true;
+        killChild();
+      }, timeout);
+    }
+    if (options.signal?.aborted) {
+      onAbort();
+    } else {
+      options.signal?.addEventListener("abort", onAbort, { once: true });
+    }
+    const appendChunk = (target, chunk) => {
+      if (outputCapped) return;
+      const remaining = BASH_HARD_CAP_BYTES - outputBytes;
+      const accepted = chunk.byteLength <= remaining ? chunk : chunk.subarray(0, Math.max(0, remaining));
+      outputBytes += accepted.byteLength;
+      if (accepted.byteLength > 0) {
+        const decoded = target === "stdout" ? stdoutDecoder.write(accepted) : stderrDecoder.write(accepted);
+        if (target === "stdout") stdout += decoded;
+        else stderr += decoded;
+      }
+      if (accepted.byteLength < chunk.byteLength) {
+        outputCapped = true;
+        scheduleUpdate();
+        killChild();
+        return;
+      }
+      scheduleUpdate();
+    };
+    child.stdout?.on("data", (chunk) => appendChunk("stdout", chunk));
+    child.stderr?.on("data", (chunk) => appendChunk("stderr", chunk));
+    child.on("error", (error) => {
+      if (settled) return;
+      settled = true;
+      if (timeoutId) clearTimeout(timeoutId);
+      clearKillGraceTimer();
+      finishDecoders();
+      finishUpdates();
+      options.signal?.removeEventListener("abort", onAbort);
+      resolve({
+        error,
+        stdout,
+        stderr,
+        exitCode: null,
+        signal: null,
+        aborted,
+        timedOut,
+        outputCapped,
+        outputBytes
+      });
+    });
+    child.on("close", (code, signalName) => {
+      if (settled) return;
+      settled = true;
+      if (timeoutId) clearTimeout(timeoutId);
+      clearKillGraceTimer();
+      finishDecoders();
+      finishUpdates();
+      options.signal?.removeEventListener("abort", onAbort);
+      const error = code === 0 && signalName === null ? null : {
+        name: "Error",
+        message: signalName ? `command terminated by ${signalName}` : `command exited with code ${code ?? "?"}`,
+        code: code ?? void 0,
+        signal: signalName ?? void 0
+      };
+      resolve({
+        error,
+        stdout,
+        stderr,
+        exitCode: code,
+        signal: signalName,
+        aborted,
+        timedOut,
+        outputCapped,
+        outputBytes
+      });
+    });
+  });
+}
+
+export {
+  BASH_HARD_CAP_BYTES,
+  combineBashOutput,
+  runBashCommand
+};
+//# sourceMappingURL=chunk-U2WB7TZS.js.map

package/dist/{chunk-KFZI4NIL.js → chunk-UAPGZHYC.js}

@@ -1,4 +1,7 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  combineBashOutput
+} from "./chunk-U2WB7TZS.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -566,6 +569,48 @@ function clioTheme() {
 // src/interactive/clio-editor.ts
 init_esm_shims();
 
+// src/interactive/editor-bash.ts
+init_esm_shims();
+var PASTED_EDITOR_OPERATOR_GUARD = "\u2063";
+function guardPastedEditorOperator(text) {
+  return `${PASTED_EDITOR_OPERATOR_GUARD}${text}`;
+}
+function unguardPastedEditorOperator(text) {
+  return text.startsWith(PASTED_EDITOR_OPERATOR_GUARD) ? text.slice(PASTED_EDITOR_OPERATOR_GUARD.length) : text;
+}
+function parseEditorBashCommand(text) {
+  if (text.startsWith(PASTED_EDITOR_OPERATOR_GUARD) || text.includes("\n") || text.includes("\r")) return null;
+  if (!text.startsWith("!")) return null;
+  const excludeFromContext = text.startsWith("!!");
+  const command = (excludeFromContext ? text.slice(2) : text.slice(1)).trim();
+  if (command.length === 0) return null;
+  return { command, excludeFromContext };
+}
+function appendStatusNotes(output, result, timeoutMs) {
+  const notes = [];
+  if (result.aborted) notes.push("command aborted");
+  if (result.timedOut) notes.push(`command timed out after ${timeoutMs}ms`);
+  if (result.outputCapped) notes.push("command output exceeded the inline output limit");
+  if (result.error && output.trim().length === 0) notes.push(result.error.message);
+  if (notes.length === 0) return output;
+  const suffix = notes.map((note) => `[${note}]`).join("\n");
+  return output.length > 0 ? `${output.replace(/\s+$/g, "")}
+${suffix}` : suffix;
+}
+function bashExecutionEntryInput(args) {
+  const output = appendStatusNotes(combineBashOutput(args.result), args.result, args.timeoutMs);
+  return {
+    kind: "bashExecution",
+    parentTurnId: args.parentTurnId,
+    command: args.command,
+    output,
+    exitCode: args.result.exitCode,
+    cancelled: args.result.aborted,
+    truncated: args.result.outputCapped,
+    excludeFromContext: args.excludeFromContext
+  };
+}
+
 // src/interactive/overlay-frame.ts
 init_esm_shims();
 
@@ -772,12 +817,6 @@ function formatRuntimeResolutionDiagnostic(diagnostic) {
 function diagnosticSeverityToken(severity) {
   return severity === "error" ? "error" : severity === "warning" ? "warning" : "muted";
 }
-function runtimeResolutionDiagnosticLine(diagnostic, width) {
-  return clioTheme().fg(diagnosticSeverityToken(diagnostic.severity), fitDiagnosticLine(diagnostic, width));
-}
-function fitDiagnosticLine(diagnostic, width) {
-  return padAnsi(formatRuntimeResolutionDiagnostic(diagnostic), Math.max(1, width));
-}
 function frameAlignForAnchor(anchor) {
   if (anchor === void 0) return "center";
   if (anchor === "left-center" || anchor.endsWith("-left")) return "left";
@@ -1012,12 +1051,45 @@ function findBottomRail(lines, width) {
   }
   return -1;
 }
+function cursorEndsDirectoryPath(editor) {
+  const cursor = editor.getCursor();
+  const line = editor.getLines()[cursor.line] ?? "";
+  return line.slice(0, cursor.col).endsWith("/");
+}
+function remapPastedBangOffsets(before, after, offsets, markInsertedAsPasted) {
+  let prefix = 0;
+  while (prefix < before.length && prefix < after.length && before[prefix] === after[prefix]) prefix += 1;
+  let beforeEnd = before.length;
+  let afterEnd = after.length;
+  while (beforeEnd > prefix && afterEnd > prefix && before[beforeEnd - 1] === after[afterEnd - 1]) {
+    beforeEnd -= 1;
+    afterEnd -= 1;
+  }
+  const next = /* @__PURE__ */ new Set();
+  const shift = afterEnd - prefix - (beforeEnd - prefix);
+  for (const offset of offsets) {
+    if (offset < prefix) next.add(offset);
+    else if (offset >= beforeEnd) next.add(offset + shift);
+  }
+  if (markInsertedAsPasted) {
+    for (let offset = prefix; offset < afterEnd; offset += 1) {
+      if (after[offset] === "!") next.add(offset);
+    }
+  }
+  return next;
+}
+function startsWithPastedOperator(text, pastedBangOffsets) {
+  const first = text.search(/\S/u);
+  return first >= 0 && text[first] === "!" && pastedBangOffsets.has(first);
+}
 var ClioEditor = class extends Editor {
   constructor(tui, chrome) {
     super(tui, editorTheme(clioTheme()));
     this.chrome = chrome;
   }
   chrome;
+  pastedBangOffsets = /* @__PURE__ */ new Set();
+  bracketedPasteActive = false;
   render(width) {
     const lines = super.render(width);
     if (lines.length === 0) return lines;
@@ -1059,6 +1131,14 @@ var ClioEditor = class extends Editor {
     }
     return lines;
   }
+  /**
+   * Preserve paste provenance for every immediate-send binding, including the
+   * alternate paths that invoke the submit controller without an Editor Enter.
+   */
+  getTextForSubmit() {
+    const text = this.getExpandedText();
+    return startsWithPastedOperator(this.getText(), this.pastedBangOffsets) ? guardPastedEditorOperator(text) : text;
+  }
   /**
    * pi-tui's bracketed-paste handling inserts pasted text (including a
    * trailing newline the paste carried) without submitting: a pasted
@@ -1068,8 +1148,34 @@ var ClioEditor = class extends Editor {
    * through the same handler the typed-Enter path uses.
    */
   handleInput(data) {
+    const openedPaste = data.includes("\x1B[200~");
     const closedPaste = data.includes("\x1B[201~");
+    const pasteMutation = this.bracketedPasteActive || openedPaste;
+    const textBeforeInput = this.getText();
+    const keybindings = getKeybindings();
+    if (startsWithPastedOperator(textBeforeInput, this.pastedBangOffsets) && keybindings.matches(data, "tui.input.submit")) {
+      const pastedText = this.getTextForSubmit();
+      this.pastedBangOffsets.clear();
+      this.bracketedPasteActive = false;
+      super.setText(pastedText);
+      super.handleInput(data);
+      return;
+    }
+    const completingDirectory = this.isShowingAutocomplete() && (keybindings.matches(data, "tui.input.tab") || keybindings.matches(data, "tui.select.confirm"));
+    const textBeforeCompletion = completingDirectory ? this.getText() : "";
     super.handleInput(data);
+    if (completingDirectory && this.getText() !== textBeforeCompletion && cursorEndsDirectoryPath(this)) {
+      super.handleInput("	");
+    }
+    const textAfterInput = this.getText();
+    this.pastedBangOffsets = remapPastedBangOffsets(
+      textBeforeInput,
+      textAfterInput,
+      this.pastedBangOffsets,
+      pasteMutation
+    );
+    if (openedPaste) this.bracketedPasteActive = true;
+    if (closedPaste) this.bracketedPasteActive = false;
     if (!closedPaste) return;
     const text = this.getText();
     if (!text.endsWith("\n")) return;
@@ -1078,6 +1184,11 @@ var ClioEditor = class extends Editor {
     this.setText("");
     this.onSubmit?.(command);
   }
+  setText(text) {
+    this.pastedBangOffsets.clear();
+    this.bracketedPasteActive = false;
+    super.setText(text);
+  }
 };
 
 // src/interactive/interactive-shell.ts
@@ -1850,37 +1961,37 @@ init_esm_shims();
 // src/domains/config/keybindings.ts
 init_esm_shims();
 var CLIO_APP_KEYBINDINGS = {
-  "clio.thinking.cycle": {
+  "clio-coder.thinking.cycle": {
     defaultKeys: "shift+tab",
     description: "Cycle orchestrator thinking level"
   },
-  "clio.exit": {
+  "clio-coder.exit": {
     defaultKeys: "ctrl+d",
     description: "Exit when the editor is empty"
   },
-  "clio.status.toggle": {
+  "clio-coder.status.toggle": {
     defaultKeys: "alt+u",
     description: "Toggle the footer dashboard (compact / expanded)"
   },
-  "clio.session.tree": {
+  "clio-coder.session.tree": {
     defaultKeys: "alt+t",
     description: "Open the /tree navigator"
   },
-  "clio.dispatchBoard.toggle": {
+  "clio-coder.dispatchBoard.toggle": {
     defaultKeys: "alt+w",
     description: "Toggle the dispatch (workers) board overlay"
   },
-  "clio.tasks.open": {
+  "clio-coder.tasks.open": {
     // Approved application-boundary override of pi-tui editor word-back.
     defaultKeys: "alt+b",
     description: "Open the composite session and operator task board"
   },
-  "clio.decisions.open": {
+  "clio-coder.decisions.open": {
     // Approved application-boundary override of pi-tui editor word-delete.
     defaultKeys: "alt+d",
     description: "Open the settled interview decision board"
   },
-  "clio.dispatch.background": {
+  "clio-coder.dispatch.background": {
     // Ctrl+B alone is pi-tui's editor cursor-left, so the Claude Code chord
     // cannot be the primary here. Alt+S ("send to background") keeps the app
     // scheme and earns the Ctrl+G leader fallback, which only alt+<letter>
@@ -1888,66 +1999,66 @@ var CLIO_APP_KEYBINDINGS = {
     defaultKeys: ["alt+s", "ctrl+alt+b"],
     description: "Send the running attached dispatch to the background as a detached batch"
   },
-  "clio.model.select": {
+  "clio-coder.model.select": {
     defaultKeys: "alt+l",
     description: "Open the model + targets selector"
   },
-  "clio.model.cycleForward": {
+  "clio-coder.model.cycleForward": {
     defaultKeys: "alt+j",
     description: "Cycle to next scoped model"
   },
-  "clio.model.cycleBackward": {
+  "clio-coder.model.cycleBackward": {
     defaultKeys: "alt+k",
     description: "Cycle to previous scoped model"
   },
-  "clio.tool.expand": {
+  "clio-coder.tool.expand": {
     defaultKeys: "alt+o",
     description: "Fold or unfold the newest tool call or worker block between its one-line summary and full details, overriding the /output level for that block"
   },
-  "clio.tool.expandAll": {
+  "clio-coder.tool.expandAll": {
     // Alt+Shift+letter is commonly consumed by OS keyboard-layout switching.
     // Keep it discoverable, but pair it with the legacy-safe Ctrl+Alt form.
     defaultKeys: ["ctrl+alt+o", "alt+shift+o"],
     description: "Fold or unfold every tool call and worker block at once, overriding the /output level; changing /output clears the overrides"
   },
-  "clio.tool.liveOutput": {
+  "clio-coder.tool.liveOutput": {
     defaultKeys: "alt+p",
     description: "Toggle streaming partial tool output in expanded tool bodies"
   },
-  "clio.thinking.expand": {
+  "clio-coder.thinking.expand": {
     defaultKeys: "alt+r",
     description: "Toggle the latest thinking block between hidden marker and full body (no effect while /output verbose pins it open)"
   },
-  "clio.thinking.expandAll": {
+  "clio-coder.thinking.expandAll": {
     // Ctrl+Alt+R is the fallback for terminals/OSes that do not forward
     // Alt+Shift+R as a distinct key event.
     defaultKeys: ["ctrl+alt+r", "alt+shift+r"],
     description: "Toggle all thinking blocks between hidden markers and full bodies, overriding the /output level; changing /output clears the overrides"
   },
-  "clio.editor.external": {
+  "clio-coder.editor.external": {
     defaultKeys: "alt+g",
     description: "Open the current input in an external editor"
   },
-  "clio.message.followUp": {
+  "clio-coder.message.followUp": {
     defaultKeys: "alt+enter",
     description: "End of turn: queue the current input for delivery when the active run settles (Enter delivers it at the next slot, between tool batches)"
   },
-  "clio.message.interrupt": {
+  "clio-coder.message.interrupt": {
     // Alt+I keeps the app scheme and earns the Ctrl+G leader fallback. A
     // Ctrl+Enter chord was rejected because legacy terminals send it as a
     // plain Enter, which would turn every send into a cancel.
     defaultKeys: "alt+i",
     description: "Interrupt: cancel the active run and deliver the current input now (refused while an attached dispatch runs or a permission ask is parked; the input then queues for the next slot)"
   },
-  "clio.message.dequeue": {
+  "clio-coder.message.dequeue": {
     defaultKeys: "alt+up",
     description: "Restore queued steering and follow-up messages to the editor"
   },
-  "clio.notifications.dismiss": {
+  "clio-coder.notifications.dismiss": {
     defaultKeys: "alt+x",
     description: "Dismiss footer notifications"
   },
-  "clio.leader": {
+  "clio-coder.leader": {
     defaultKeys: "ctrl+g",
     description: "Start portable leader-key fallback for Alt shortcuts"
   }
@@ -2300,7 +2411,7 @@ function buildManager(inner, invalid, platformWarnings) {
   };
 }
 function createKeybindingManager(settings, env = process.env) {
-  const { valid, invalid } = validateKeybindings(settings.keybindings ?? {});
+  const { valid, invalid } = validateKeybindings(settings.interface.keybindings ?? {});
   const inner = new KeybindingsManager(CLIO_KEYBINDINGS, valid);
   setKeybindings(inner);
   return buildManager(inner, invalid, detectPlatformKeybindingWarnings(valid, detectTerminalKeySupport(env)));
@@ -2325,6 +2436,9 @@ export {
   VStack,
   visibleWidth,
   wrapTextWithAnsi,
+  unguardPastedEditorOperator,
+  parseEditorBashCommand,
+  bashExecutionEntryInput,
   SGR_RESET,
   SGR_DIM,
   fgSequence,
@@ -2361,7 +2475,7 @@ export {
   buildHint,
   buildResponsiveHint,
   formatRuntimeResolutionDiagnostic,
-  runtimeResolutionDiagnosticLine,
+  diagnosticSeverityToken,
   showClioOverlayFrame,
   MUTATION_PREVIEW_KEY,
   permissionHintEntries,
@@ -2376,4 +2490,4 @@ export {
   formatPlatformKeybindingNotice,
   createKeybindingManager
 };
-//# sourceMappingURL=chunk-KFZI4NIL.js.map
+//# sourceMappingURL=chunk-UAPGZHYC.js.map