@iowarp/clio-coder 0.3.9 → 0.4.1

package/dist/{chunk-NNNWO6F2.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,8 +569,114 @@ 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();
+
+// src/interactive/modal-marker.ts
+init_esm_shims();
+var MODAL_MARKER_BASE_TITLE = "clio";
+function formatModalMarkerTitle(stack) {
+  const top = stack.at(-1);
+  if (top === void 0) return MODAL_MARKER_BASE_TITLE;
+  const beneath = stack.length - 1;
+  return `${MODAL_MARKER_BASE_TITLE} [modal:${top}${beneath > 0 ? `+${beneath}` : ""}]`;
+}
+function createModalMarkerRegistry() {
+  const entries = [];
+  let sink = null;
+  let published = null;
+  function activeIds() {
+    return entries.filter((entry) => entry.active).map((entry) => entry.id);
+  }
+  function publish() {
+    if (sink === null) return;
+    const title = formatModalMarkerTitle(activeIds());
+    if (published === null && title === MODAL_MARKER_BASE_TITLE) return;
+    if (title === published) return;
+    published = title;
+    sink.setTitle(title);
+  }
+  function enter(id, nextSink) {
+    if (nextSink) sink = nextSink;
+    const entry = { id, active: true };
+    entries.push(entry);
+    publish();
+    let released = false;
+    return {
+      release() {
+        if (released) return;
+        released = true;
+        const index = entries.indexOf(entry);
+        if (index !== -1) entries.splice(index, 1);
+        publish();
+      },
+      setActive(active) {
+        if (released || entry.active === active) return;
+        entry.active = active;
+        publish();
+      },
+      raise() {
+        if (released) return;
+        entry.active = true;
+        const index = entries.indexOf(entry);
+        if (index !== -1 && index !== entries.length - 1) {
+          entries.splice(index, 1);
+          entries.push(entry);
+        }
+        publish();
+      }
+    };
+  }
+  return { enter, stack: () => activeIds() };
+}
+var registry = createModalMarkerRegistry();
+function enterModal(id, sink) {
+  return registry.enter(id, sink);
+}
+
+// src/interactive/overlay-frame.ts
 var DEFAULT_SELECT_THEME = selectListTheme(clioTheme());
 var DEFAULT_SETTINGS_THEME = settingsListTheme(clioTheme());
 var FocusBox = class extends Box {
@@ -708,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";
@@ -800,10 +903,10 @@ var ClioOverlayFrame = class {
   }
 };
 function showClioOverlayFrame(tui, child, options) {
-  const { title, footerHint, tone, width, visible, maxHeight, margin, ...overlayOptions } = options;
+  const { title, footerHint, tone, width, visible, maxHeight, margin, markerId, ...overlayOptions } = options;
   const boxWidth = typeof width === "number" ? width : 0;
   const frame2 = new ClioOverlayFrame(child, title, footerHint, boxWidth, frameAlignForAnchor(options.anchor), tone);
-  return tui.showOverlay(frame2, {
+  const handle = tui.showOverlay(frame2, {
     ...overlayOptions,
     ...margin !== void 0 ? { margin } : {},
     width: "100%",
@@ -816,6 +919,32 @@ function showClioOverlayFrame(tui, child, options) {
       return shown;
     }
   });
+  const marker = enterModal(markerId, modalMarkerSink(tui));
+  return {
+    hide() {
+      marker.release();
+      handle.hide();
+    },
+    setHidden(hidden) {
+      marker.setActive(!hidden);
+      handle.setHidden(hidden);
+    },
+    isHidden: () => handle.isHidden(),
+    focus() {
+      marker.raise();
+      handle.focus();
+    },
+    // A pure passthrough on purpose. The engine hands focus to the next
+    // visible capturing overlay, which is another modal, so the stack is
+    // unchanged; the surface that gives the keyboard back to the composer
+    // does it by hiding, which `setHidden` already reports.
+    unfocus: (unfocusOptions) => unfocusOptions ? handle.unfocus(unfocusOptions) : handle.unfocus(),
+    isFocused: () => handle.isFocused()
+  };
+}
+function modalMarkerSink(tui) {
+  const terminal = tui.terminal;
+  return typeof terminal?.setTitle === "function" ? terminal : null;
 }
 function resolveRowSize(value, termHeight) {
   if (typeof value === "number") return Math.max(1, Math.floor(value));
@@ -922,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;
@@ -969,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
@@ -978,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;
@@ -988,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
@@ -1760,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>
@@ -1798,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"
   }
@@ -2210,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)));
@@ -2235,6 +2436,9 @@ export {
   VStack,
   visibleWidth,
   wrapTextWithAnsi,
+  unguardPastedEditorOperator,
+  parseEditorBashCommand,
+  bashExecutionEntryInput,
   SGR_RESET,
   SGR_DIM,
   fgSequence,
@@ -2271,7 +2475,7 @@ export {
   buildHint,
   buildResponsiveHint,
   formatRuntimeResolutionDiagnostic,
-  runtimeResolutionDiagnosticLine,
+  diagnosticSeverityToken,
   showClioOverlayFrame,
   MUTATION_PREVIEW_KEY,
   permissionHintEntries,
@@ -2286,4 +2490,4 @@ export {
   formatPlatformKeybindingNotice,
   createKeybindingManager
 };
-//# sourceMappingURL=chunk-NNNWO6F2.js.map
+//# sourceMappingURL=chunk-UAPGZHYC.js.map