ralphctl 0.5.0 → 0.6.0

package/dist/chunk-HIU74KTO.mjs

@@ -0,0 +1,1046 @@
+#!/usr/bin/env node
+
+// src/integration/ui/prompts/auto-mount.tsx
+import "react";
+import { render } from "ink";
+
+// src/business/ports/prompt-port.ts
+var PromptCancelledError = class extends Error {
+  constructor(message = "Prompt cancelled by user") {
+    super(message);
+    this.name = "PromptCancelledError";
+  }
+};
+
+// src/integration/ui/prompts/prompt-host.tsx
+import "react";
+import { Box as Box8 } from "ink";
+
+// src/integration/ui/prompts/hooks.ts
+import { useEffect, useState } from "react";
+
+// src/integration/ui/prompts/prompt-queue.ts
+var SEQUENCE_IDLE_MS = 250;
+var PromptQueue = class {
+  queue = [];
+  history = [];
+  lastResolveAt = 0;
+  idleClearTimer = null;
+  listeners = /* @__PURE__ */ new Set();
+  enqueue(prompt) {
+    if (this.queue.length === 0 && Date.now() - this.lastResolveAt > SEQUENCE_IDLE_MS) {
+      this.history = [];
+    }
+    if (this.idleClearTimer !== null) {
+      clearTimeout(this.idleClearTimer);
+      this.idleClearTimer = null;
+    }
+    this.queue.push(prompt);
+    this.notify();
+  }
+  current() {
+    return this.queue[0] ?? null;
+  }
+  resolveCurrent(value) {
+    const head = this.queue.shift();
+    if (!head) return;
+    this.history.push(buildResolved(head, value));
+    this.lastResolveAt = Date.now();
+    head.resolve(value);
+    this.scheduleIdleClear();
+    this.notify();
+  }
+  cancelCurrent(err) {
+    const head = this.queue.shift();
+    if (!head) return;
+    this.lastResolveAt = Date.now();
+    head.reject(err);
+    this.scheduleIdleClear();
+    this.notify();
+  }
+  /**
+   * After the queue empties, schedule a clear of the visible transcript.
+   * If a new prompt arrives within the idle window the timer is cancelled
+   * (see `enqueue`) and the transcript continues to accumulate. Without
+   * this, completed workflows leave their transcript on screen indefinitely
+   * (e.g. project-add answers persisting on the home view after pop).
+   */
+  scheduleIdleClear() {
+    if (this.queue.length > 0) return;
+    if (this.idleClearTimer !== null) clearTimeout(this.idleClearTimer);
+    this.idleClearTimer = setTimeout(() => {
+      this.idleClearTimer = null;
+      if (this.queue.length === 0) {
+        this.history = [];
+        this.notify();
+      }
+    }, SEQUENCE_IDLE_MS);
+  }
+  /** Drop all pending prompts without resolving. Used on app shutdown. */
+  clear(reason) {
+    while (this.queue.length > 0) {
+      const p = this.queue.shift();
+      p?.reject(reason);
+    }
+    this.history = [];
+    this.notify();
+  }
+  /** Discard the visible transcript without affecting pending prompts. */
+  clearHistory() {
+    this.history = [];
+    this.notify();
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    try {
+      listener(this.snapshot());
+    } catch {
+    }
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  size() {
+    return this.queue.length;
+  }
+  historySnapshot() {
+    return this.history;
+  }
+  snapshot() {
+    return { current: this.current(), history: this.history };
+  }
+  notify() {
+    const snap = this.snapshot();
+    for (const l of this.listeners) {
+      try {
+        l(snap);
+      } catch {
+      }
+    }
+  }
+};
+function buildResolved(prompt, value) {
+  switch (prompt.kind) {
+    case "confirm":
+      return { kind: "confirm", options: prompt.options, value };
+    case "input":
+      return { kind: "input", options: prompt.options, value };
+    case "select":
+      return { kind: "select", options: prompt.options, value };
+    case "checkbox":
+      return { kind: "checkbox", options: prompt.options, value };
+    case "editor":
+      return { kind: "editor", options: prompt.options, value };
+    case "fileBrowser":
+      return { kind: "fileBrowser", options: prompt.options, value };
+  }
+}
+var promptQueue = new PromptQueue();
+
+// src/integration/ui/prompts/hooks.ts
+function useCurrentPrompt() {
+  const [current, setCurrent] = useState(null);
+  useEffect(() => {
+    const unsubscribe = promptQueue.subscribe((state) => {
+      setCurrent(state.current);
+    });
+    return unsubscribe;
+  }, []);
+  return current;
+}
+function usePromptState() {
+  const [state, setState] = useState({ current: null, history: [] });
+  useEffect(() => {
+    const unsubscribe = promptQueue.subscribe(setState);
+    return unsubscribe;
+  }, []);
+  return state;
+}
+
+// src/integration/ui/prompts/prompt-transcript.tsx
+import "react";
+import { Box, Text } from "ink";
+
+// src/integration/ui/theme/tokens.ts
+var inkColors = {
+  // Semantic state
+  success: "#7FB069",
+  // sage — not neon green, easier on the eyes
+  error: "#E76F51",
+  // warm coral — not a pure red klaxon
+  warning: "#E8A13B",
+  // amber
+  info: "#6CA6B0",
+  // dusty cyan
+  // UI state
+  muted: "#8B8680",
+  // warm gray (hint of yellow, matches the mustard brand)
+  highlight: "#E8C547",
+  // brand mustard — focus / active
+  // Brand
+  primary: "#E8C547",
+  // mustard — section stamps, accents
+  secondary: "#D98880"
+  // muted rose — Ralph personality pull-quotes
+};
+var glyphs = {
+  // Phase / status
+  phaseDone: "\u25A0",
+  phaseActive: "\u25C6",
+  phasePending: "\u25C7",
+  phaseDisabled: "\u25CC",
+  // Action cursors / bullets
+  actionCursor: "\u25B8",
+  selectMarker: "\u203A",
+  bulletListItem: "\xB7",
+  arrowRight: "\u2192",
+  activityArrow: "\u21B3",
+  // Section markers
+  badge: "\u25A3",
+  sectionRule: "\u2501",
+  // State confirmation
+  check: "\u2713",
+  cross: "\u2717",
+  warningGlyph: "\u26A0",
+  infoGlyph: "i",
+  // Loading (braille spinner frames)
+  spinner: ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"],
+  // Personality rail
+  quoteRail: "\u2503",
+  // Separators
+  inlineDot: "\xB7",
+  emDash: "\u2014",
+  separatorVertical: "\u2502"
+};
+var spacing = {
+  /** Between top-level sections (blank line). */
+  section: 1,
+  /** Before a final CTA row — a beat of breath before a decision. */
+  actionBreak: 2,
+  /** Card internal x-padding. */
+  cardPadX: 1,
+  /** Left-indent for nested content (steps, bullets, children). */
+  indent: 2,
+  /** Internal gutter inside card-like boxes. */
+  gutter: 1
+};
+var FIELD_LABEL_WIDTH = 12;
+var DONUT_EMOJI = "\u{1F369}";
+
+// src/integration/ui/prompts/prompt-transcript.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+function PromptTranscript({ history }) {
+  if (history.length === 0) return null;
+  return /* @__PURE__ */ jsx(Box, { flexDirection: "column", children: history.map((entry, i) => /* @__PURE__ */ jsx(Box, { children: /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+    DONUT_EMOJI,
+    " ",
+    entry.options.message,
+    ": ",
+    renderValue(entry)
+  ] }) }, i)) });
+}
+function renderValue(entry) {
+  switch (entry.kind) {
+    case "confirm":
+      return entry.value ? "yes" : "no";
+    case "input":
+      return entry.value === "" ? "(empty)" : entry.value;
+    case "select": {
+      const choice = entry.options.choices.find((c) => c.value === entry.value);
+      return choice?.label ?? String(entry.value);
+    }
+    case "checkbox": {
+      if (entry.value.length === 0) return "(none)";
+      const labels = entry.value.map((v) => {
+        const choice = entry.options.choices.find((c) => c.value === v);
+        return choice?.label ?? String(v);
+      });
+      return labels.join(", ");
+    }
+    case "editor":
+      if (entry.value === null) return "(cancelled)";
+      if (entry.value === "") return "(empty)";
+      return summariseMultiline(entry.value);
+    case "fileBrowser":
+      return entry.value ?? "(cancelled)";
+  }
+}
+function summariseMultiline(text) {
+  const lines = text.split("\n");
+  if (lines.length === 1) {
+    const first = lines[0] ?? "";
+    return first.length > 60 ? `${first.slice(0, 57)}\u2026` : first;
+  }
+  return `(${String(lines.length)} lines)`;
+}
+
+// src/integration/ui/prompts/confirm-prompt.tsx
+import { useEffect as useEffect2, useMemo, useState as useState2 } from "react";
+import { Box as Box2, Text as Text2, useInput, useStdout } from "ink";
+import { ConfirmInput } from "@inkjs/ui";
+import { Fragment, jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var RESERVED_ROWS = 10;
+var MIN_VIEWPORT = 6;
+var MAX_VIEWPORT = 40;
+function useTerminalRows() {
+  const { stdout } = useStdout();
+  const [rows, setRows] = useState2(stdout.rows);
+  useEffect2(() => {
+    const onResize = () => {
+      setRows(stdout.rows);
+    };
+    stdout.on("resize", onResize);
+    return () => {
+      stdout.off("resize", onResize);
+    };
+  }, [stdout]);
+  return rows;
+}
+function ConfirmPrompt({ options, onSubmit }) {
+  const details = options.details?.trim();
+  const lines = useMemo(() => details ? details.split("\n") : [], [details]);
+  const terminalRows = useTerminalRows();
+  const viewport = Math.max(MIN_VIEWPORT, Math.min(MAX_VIEWPORT, terminalRows - RESERVED_ROWS));
+  const total = lines.length;
+  const maxOffset = Math.max(0, total - viewport);
+  const scrollable = total > viewport;
+  const [offset, setOffset] = useState2(0);
+  useInput((_input, key) => {
+    if (!scrollable) return;
+    if (key.upArrow) setOffset((o) => Math.max(0, o - 1));
+    else if (key.downArrow) setOffset((o) => Math.min(maxOffset, o + 1));
+    else if (key.pageUp) setOffset((o) => Math.max(0, o - viewport));
+    else if (key.pageDown) setOffset((o) => Math.min(maxOffset, o + viewport));
+  });
+  const visibleLines = scrollable ? lines.slice(offset, offset + viewport) : lines;
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
+    details ? /* @__PURE__ */ jsxs2(
+      Box2,
+      {
+        flexDirection: "column",
+        borderStyle: "round",
+        borderColor: inkColors.muted,
+        paddingX: spacing.gutter,
+        marginBottom: spacing.section,
+        children: [
+          visibleLines.map((line, idx) => /* @__PURE__ */ jsx2(Text2, { children: line.length > 0 ? /* @__PURE__ */ jsxs2(Fragment, { children: [
+            /* @__PURE__ */ jsxs2(Text2, { color: inkColors.muted, children: [
+              glyphs.quoteRail,
+              " "
+            ] }),
+            line
+          ] }) : " " }, idx)),
+          scrollable ? /* @__PURE__ */ jsxs2(Text2, { color: inkColors.muted, children: [
+            glyphs.inlineDot,
+            " lines ",
+            String(offset + 1),
+            "\u2013",
+            String(Math.min(offset + viewport, total)),
+            " of",
+            " ",
+            String(total),
+            " ",
+            glyphs.inlineDot,
+            " \u2191/\u2193 scroll ",
+            glyphs.inlineDot,
+            " PgUp/PgDn page"
+          ] }) : null
+        ]
+      }
+    ) : null,
+    /* @__PURE__ */ jsxs2(Box2, { children: [
+      /* @__PURE__ */ jsxs2(Text2, { children: [
+        DONUT_EMOJI,
+        " ",
+        options.message,
+        " "
+      ] }),
+      /* @__PURE__ */ jsx2(
+        ConfirmInput,
+        {
+          defaultChoice: options.default === false ? "cancel" : "confirm",
+          onConfirm: () => {
+            onSubmit(true);
+          },
+          onCancel: () => {
+            onSubmit(false);
+          }
+        }
+      )
+    ] })
+  ] });
+}
+
+// src/integration/ui/prompts/input-prompt.tsx
+import { useState as useState3 } from "react";
+import { Box as Box3, Text as Text3, useInput as useInput2 } from "ink";
+import { TextInput } from "@inkjs/ui";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function InputPrompt({ options, onSubmit, onCancel }) {
+  const [error, setError] = useState3(null);
+  useInput2((_input, key) => {
+    if (key.escape) onCancel();
+  });
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs3(Box3, { children: [
+      /* @__PURE__ */ jsxs3(Text3, { children: [
+        DONUT_EMOJI,
+        " ",
+        options.message,
+        ":",
+        " "
+      ] }),
+      /* @__PURE__ */ jsx3(
+        TextInput,
+        {
+          defaultValue: options.default,
+          placeholder: options.default,
+          onSubmit: (value) => {
+            const validation = options.validate?.(value);
+            if (validation !== void 0 && validation !== true) {
+              if (typeof validation === "string") {
+                setError(validation);
+                return;
+              }
+            }
+            setError(null);
+            onSubmit(value);
+          }
+        }
+      )
+    ] }),
+    error !== null && /* @__PURE__ */ jsx3(Box3, { children: /* @__PURE__ */ jsxs3(Text3, { color: inkColors.error, children: [
+      " \u2717 ",
+      error
+    ] }) })
+  ] });
+}
+
+// src/integration/ui/prompts/select-prompt.tsx
+import { useState as useState4 } from "react";
+import { Box as Box4, Text as Text4, useInput as useInput3 } from "ink";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+function SelectPrompt({ options, onSubmit, onCancel }) {
+  const initialIdx = findInitialIdx(options);
+  const [focusedIdx, setFocusedIdx] = useState4(initialIdx);
+  useInput3((_input, key) => {
+    if (key.escape) {
+      onCancel();
+      return;
+    }
+    if (key.upArrow) {
+      setFocusedIdx((i) => stepFocus(options.choices, i, -1));
+      return;
+    }
+    if (key.downArrow) {
+      setFocusedIdx((i) => stepFocus(options.choices, i, 1));
+      return;
+    }
+    if (key.return) {
+      const picked = options.choices[focusedIdx];
+      if (picked && !isDisabled(picked)) {
+        onSubmit(picked.value);
+      }
+    }
+  });
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx4(Box4, { children: /* @__PURE__ */ jsxs4(Text4, { children: [
+      DONUT_EMOJI,
+      " ",
+      options.message,
+      ":"
+    ] }) }),
+    /* @__PURE__ */ jsx4(Box4, { marginLeft: 2, flexDirection: "column", children: options.choices.map((choice, i) => {
+      const isFocused = i === focusedIdx;
+      const disabled = isDisabled(choice);
+      const color = disabled ? inkColors.muted : isFocused ? inkColors.highlight : void 0;
+      const prefix = isFocused ? glyphs.actionCursor : " ";
+      return /* @__PURE__ */ jsxs4(Box4, { children: [
+        /* @__PURE__ */ jsx4(Text4, { color, bold: isFocused, children: `${prefix} ${choice.label}` }),
+        typeof choice.disabled === "string" ? /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: `  (${choice.disabled})` }) : null
+      ] }, `${String(i)}-${choice.label}`);
+    }) })
+  ] });
+}
+function isDisabled(choice) {
+  return choice.disabled === true || typeof choice.disabled === "string";
+}
+function findInitialIdx(options) {
+  if (options.default !== void 0) {
+    const idx = options.choices.findIndex((c) => c.value === options.default);
+    const chosen = options.choices[idx];
+    if (idx >= 0 && chosen && !isDisabled(chosen)) return idx;
+  }
+  const firstEnabled = options.choices.findIndex((c) => !isDisabled(c));
+  return firstEnabled >= 0 ? firstEnabled : 0;
+}
+function stepFocus(choices, from, delta) {
+  const len = choices.length;
+  if (len === 0) return from;
+  let next = from;
+  for (let i = 0; i < len; i++) {
+    next = (next + delta + len) % len;
+    const candidate = choices[next];
+    if (candidate && !isDisabled(candidate)) return next;
+  }
+  return from;
+}
+
+// src/integration/ui/prompts/checkbox-prompt.tsx
+import { useState as useState5 } from "react";
+import { Box as Box5, Text as Text5, useInput as useInput4 } from "ink";
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+function CheckboxPrompt({ options, onSubmit, onCancel }) {
+  const initialFocus = options.choices.findIndex((c) => !isDisabled2(c));
+  const [focusedIdx, setFocusedIdx] = useState5(initialFocus >= 0 ? initialFocus : 0);
+  const [checked, setChecked] = useState5(() => seedCheckedSet(options));
+  useInput4((input, key) => {
+    if (key.escape) {
+      onCancel();
+      return;
+    }
+    if (key.upArrow) {
+      setFocusedIdx((i) => stepFocus2(options.choices, i, -1));
+      return;
+    }
+    if (key.downArrow) {
+      setFocusedIdx((i) => stepFocus2(options.choices, i, 1));
+      return;
+    }
+    if (input === " ") {
+      const choice = options.choices[focusedIdx];
+      if (choice && !isDisabled2(choice)) {
+        setChecked((prev) => {
+          const next = new Set(prev);
+          if (next.has(focusedIdx)) next.delete(focusedIdx);
+          else next.add(focusedIdx);
+          return next;
+        });
+      }
+      return;
+    }
+    if (key.return) {
+      const picked = [...checked].sort((a, b) => a - b).map((i) => options.choices[i]?.value).filter((v) => v !== void 0);
+      onSubmit(picked);
+    }
+  });
+  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx5(Box5, { children: /* @__PURE__ */ jsxs5(Text5, { children: [
+      DONUT_EMOJI,
+      " ",
+      options.message,
+      ": ",
+      /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "(space toggles, enter submits)" })
+    ] }) }),
+    /* @__PURE__ */ jsx5(Box5, { marginLeft: 2, flexDirection: "column", children: options.choices.map((choice, i) => {
+      const isFocused = i === focusedIdx;
+      const disabled = isDisabled2(choice);
+      const color = disabled ? inkColors.muted : isFocused ? inkColors.highlight : void 0;
+      const cursor = isFocused ? glyphs.actionCursor : " ";
+      const mark = checked.has(i) ? glyphs.check : glyphs.phasePending;
+      return /* @__PURE__ */ jsxs5(Box5, { children: [
+        /* @__PURE__ */ jsx5(Text5, { color, bold: isFocused, children: `${cursor} ${mark} ${choice.label}` }),
+        typeof choice.disabled === "string" ? /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: `  (${choice.disabled})` }) : null
+      ] }, `${String(i)}-${choice.label}`);
+    }) })
+  ] });
+}
+function isDisabled2(choice) {
+  return choice.disabled === true || typeof choice.disabled === "string";
+}
+function seedCheckedSet(options) {
+  const defaults = options.defaults ?? [];
+  const set = /* @__PURE__ */ new Set();
+  for (const v of defaults) {
+    const idx = options.choices.findIndex((c) => c.value === v);
+    if (idx >= 0) set.add(idx);
+  }
+  return set;
+}
+function stepFocus2(choices, from, delta) {
+  const len = choices.length;
+  if (len === 0) return from;
+  let next = from;
+  for (let i = 0; i < len; i++) {
+    next = (next + delta + len) % len;
+    const candidate = choices[next];
+    if (candidate && !isDisabled2(candidate)) return next;
+  }
+  return from;
+}
+
+// src/integration/ui/prompts/editor-prompt.tsx
+import { useState as useState6, useMemo as useMemo2 } from "react";
+import { Box as Box6, Text as Text6, useInput as useInput5 } from "ink";
+import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+var MIN_EDIT_ROWS = 8;
+function splitLines(text) {
+  return text.split("\n");
+}
+function joinLines(lines) {
+  return lines.join("\n");
+}
+function clampCursor(lines, cursor) {
+  const row = Math.max(0, Math.min(cursor.row, lines.length - 1));
+  const line = lines[row] ?? "";
+  const col = Math.max(0, Math.min(cursor.col, line.length));
+  return { row, col };
+}
+function EditorPrompt({ options, onSubmit, onCancel }) {
+  const [lines, setLines] = useState6(() => splitLines(options.default ?? ""));
+  const [cursor, setCursor] = useState6(() => {
+    const init = splitLines(options.default ?? "");
+    const lastRow = init.length - 1;
+    return { row: lastRow, col: (init[lastRow] ?? "").length };
+  });
+  useInput5((input, key) => {
+    if (key.escape || key.ctrl && input === "c") {
+      onCancel();
+      return;
+    }
+    if (key.ctrl && input === "d") {
+      onSubmit(joinLines(lines));
+      return;
+    }
+    if (key.leftArrow) {
+      setCursor((prev) => {
+        if (prev.col > 0) return { row: prev.row, col: prev.col - 1 };
+        if (prev.row > 0) {
+          const up = lines[prev.row - 1] ?? "";
+          return { row: prev.row - 1, col: up.length };
+        }
+        return prev;
+      });
+      return;
+    }
+    if (key.rightArrow) {
+      setCursor((prev) => {
+        const curLine = lines[prev.row] ?? "";
+        if (prev.col < curLine.length) return { row: prev.row, col: prev.col + 1 };
+        if (prev.row < lines.length - 1) return { row: prev.row + 1, col: 0 };
+        return prev;
+      });
+      return;
+    }
+    if (key.upArrow) {
+      setCursor((prev) => clampCursor(lines, { row: prev.row - 1, col: prev.col }));
+      return;
+    }
+    if (key.downArrow) {
+      setCursor((prev) => clampCursor(lines, { row: prev.row + 1, col: prev.col }));
+      return;
+    }
+    if (key.ctrl && input === "a") {
+      setCursor((prev) => ({ row: prev.row, col: 0 }));
+      return;
+    }
+    if (key.ctrl && input === "e") {
+      setCursor((prev) => {
+        const curLine = lines[prev.row] ?? "";
+        return { row: prev.row, col: curLine.length };
+      });
+      return;
+    }
+    if (key.backspace || key.delete) {
+      setLines((prev) => {
+        const next = [...prev];
+        const line = next[cursor.row] ?? "";
+        if (cursor.col > 0) {
+          next[cursor.row] = line.slice(0, cursor.col - 1) + line.slice(cursor.col);
+          setCursor({ row: cursor.row, col: cursor.col - 1 });
+        } else if (cursor.row > 0) {
+          const prevLine = next[cursor.row - 1] ?? "";
+          const mergedCol = prevLine.length;
+          next[cursor.row - 1] = prevLine + line;
+          next.splice(cursor.row, 1);
+          setCursor({ row: cursor.row - 1, col: mergedCol });
+        }
+        return next;
+      });
+      return;
+    }
+    if (key.return) {
+      setLines((prev) => {
+        const next = [...prev];
+        const line = next[cursor.row] ?? "";
+        const before = line.slice(0, cursor.col);
+        const after = line.slice(cursor.col);
+        next[cursor.row] = before;
+        next.splice(cursor.row + 1, 0, after);
+        return next;
+      });
+      setCursor({ row: cursor.row + 1, col: 0 });
+      return;
+    }
+    if (input && !key.ctrl && !key.meta) {
+      const chunk = input;
+      setLines((prev) => {
+        const next = [...prev];
+        const line = next[cursor.row] ?? "";
+        const before = line.slice(0, cursor.col);
+        const after = line.slice(cursor.col);
+        const parts = (before + chunk + after).split("\n");
+        next.splice(cursor.row, 1, ...parts);
+        const insertedLines = chunk.split("\n");
+        const insertedRow = cursor.row + insertedLines.length - 1;
+        const insertedCol = insertedLines.length === 1 ? before.length + chunk.length : (insertedLines[insertedLines.length - 1] ?? "").length;
+        setCursor({ row: insertedRow, col: insertedCol });
+        return next;
+      });
+    }
+  });
+  const renderedLines = useMemo2(() => {
+    const padCount = Math.max(0, MIN_EDIT_ROWS - lines.length);
+    const padded = lines.map((line, i) => {
+      if (i !== cursor.row) return line.length > 0 ? line : " ";
+      const before = line.slice(0, cursor.col);
+      const at = line[cursor.col] ?? " ";
+      const after = line.slice(cursor.col + 1);
+      return { before, at, after };
+    });
+    for (let i = 0; i < padCount; i++) padded.push(" ");
+    return padded;
+  }, [lines, cursor]);
+  const charCount = lines.reduce((sum, l) => sum + l.length, 0);
+  const lineCount = lines.length;
+  return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", borderStyle: "round", borderColor: inkColors.muted, paddingX: 1, width: "100%", children: [
+    /* @__PURE__ */ jsxs6(Box6, { children: [
+      /* @__PURE__ */ jsx6(Text6, { color: inkColors.primary, bold: true, children: glyphs.badge }),
+      /* @__PURE__ */ jsx6(Text6, { color: inkColors.primary, bold: true, children: ` ${options.message.toUpperCase()}` })
+    ] }),
+    /* @__PURE__ */ jsx6(Box6, { marginTop: 1, marginLeft: 1, flexDirection: "column", children: renderedLines.map((item, i) => {
+      if (typeof item === "string") {
+        return /* @__PURE__ */ jsx6(Text6, { dimColor: i >= lines.length, children: item }, i);
+      }
+      return /* @__PURE__ */ jsxs6(Text6, { children: [
+        item.before,
+        /* @__PURE__ */ jsx6(Text6, { inverse: true, children: item.at }),
+        item.after
+      ] }, i);
+    }) }),
+    /* @__PURE__ */ jsxs6(Box6, { marginTop: 1, justifyContent: "space-between", children: [
+      /* @__PURE__ */ jsxs6(Text6, { dimColor: true, children: [
+        "Ctrl+D submit ",
+        glyphs.inlineDot,
+        " Esc cancel ",
+        glyphs.inlineDot,
+        " Enter newline"
+      ] }),
+      /* @__PURE__ */ jsxs6(Text6, { dimColor: true, children: [
+        String(lineCount),
+        " ",
+        lineCount === 1 ? "line" : "lines",
+        " ",
+        glyphs.inlineDot,
+        " ",
+        String(charCount),
+        " ",
+        charCount === 1 ? "char" : "chars"
+      ] })
+    ] })
+  ] });
+}
+
+// src/integration/ui/prompts/file-browser-prompt.tsx
+import { useEffect as useEffect3, useMemo as useMemo3, useState as useState7 } from "react";
+import { readdirSync, statSync } from "fs";
+import { homedir } from "os";
+import { dirname, join, resolve } from "path";
+import { Box as Box7, Text as Text7, useInput as useInput6 } from "ink";
+import { jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
+function listDirectories(dirPath) {
+  try {
+    return readdirSync(dirPath, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => e.name).sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
+  } catch {
+    return [];
+  }
+}
+function isGitRepo(dirPath) {
+  try {
+    return statSync(join(dirPath, ".git")).isDirectory();
+  } catch {
+    return false;
+  }
+}
+var PAGE_SIZE = 12;
+function FileBrowserPrompt({ options, onSubmit, onCancel }) {
+  const [currentPath, setCurrentPath] = useState7(
+    () => options.startPath ? resolve(options.startPath) : homedir()
+  );
+  const [dirs, setDirs] = useState7([]);
+  const [cursor, setCursor] = useState7(0);
+  const [offset, setOffset] = useState7(0);
+  useEffect3(() => {
+    setDirs(listDirectories(currentPath));
+    setCursor(0);
+    setOffset(0);
+  }, [currentPath]);
+  const message = options.message ?? "Browse to directory:";
+  const parent = dirname(currentPath);
+  useInput6((input, key) => {
+    if (key.escape) {
+      onCancel();
+      return;
+    }
+    if (key.upArrow) {
+      setCursor((c) => Math.max(0, c - 1));
+      return;
+    }
+    if (key.downArrow) {
+      setCursor((c) => Math.min(dirs.length - 1, c + 1));
+      return;
+    }
+    if (key.return) {
+      const name = dirs[cursor];
+      if (name) setCurrentPath(join(currentPath, name));
+      return;
+    }
+    if (input === ".") {
+      if (options.mustBeGitRepo && !isGitRepo(currentPath)) return;
+      onSubmit(currentPath);
+      return;
+    }
+    if (key.backspace || input === "u") {
+      if (parent !== currentPath) setCurrentPath(parent);
+      return;
+    }
+    if (input === "h") {
+      setCurrentPath(homedir());
+      return;
+    }
+  });
+  useEffect3(() => {
+    if (cursor < offset) setOffset(cursor);
+    else if (cursor >= offset + PAGE_SIZE) setOffset(cursor - PAGE_SIZE + 1);
+  }, [cursor, offset]);
+  const visible = useMemo3(() => dirs.slice(offset, offset + PAGE_SIZE), [dirs, offset]);
+  return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", borderStyle: "round", borderColor: inkColors.muted, paddingX: 1, children: [
+    /* @__PURE__ */ jsx7(Box7, { children: /* @__PURE__ */ jsxs7(Text7, { children: [
+      DONUT_EMOJI,
+      " ",
+      message
+    ] }) }),
+    /* @__PURE__ */ jsx7(Box7, { children: /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: currentPath }) }),
+    /* @__PURE__ */ jsxs7(Box7, { marginTop: 1, flexDirection: "column", children: [
+      visible.length === 0 && /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "(no subdirectories)" }),
+      visible.map((name, i) => {
+        const absoluteIdx = offset + i;
+        const isSelected = absoluteIdx === cursor;
+        const full = join(currentPath, name);
+        const repo = isGitRepo(full);
+        const icon = repo ? "\u2699 " : "\u25B8 ";
+        return /* @__PURE__ */ jsxs7(Text7, { color: isSelected ? inkColors.highlight : void 0, children: [
+          isSelected ? "\u203A " : "  ",
+          icon,
+          name,
+          repo && /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: " (git repo)" })
+        ] }, name);
+      })
+    ] }),
+    /* @__PURE__ */ jsx7(Box7, { marginTop: 1, children: /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "\u2191/\u2193 move \xB7 Enter descend \xB7 Backspace up \xB7 h home \xB7 . select \xB7 Esc cancel" }) })
+  ] });
+}
+
+// src/integration/ui/prompts/prompt-host.tsx
+import { jsx as jsx8, jsxs as jsxs8 } from "react/jsx-runtime";
+function cancel() {
+  promptQueue.cancelCurrent(new PromptCancelledError());
+}
+function PromptHost() {
+  const { current, history } = usePromptState();
+  if (!current && history.length === 0) return null;
+  return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx8(PromptTranscript, { history }),
+    current ? /* @__PURE__ */ jsx8(ActivePrompt, { prompt: current }) : null
+  ] });
+}
+function ActivePrompt({
+  prompt: current
+}) {
+  switch (current.kind) {
+    case "confirm":
+      return /* @__PURE__ */ jsx8(Box8, { children: /* @__PURE__ */ jsx8(
+        ConfirmPrompt,
+        {
+          options: current.options,
+          onSubmit: (v) => {
+            promptQueue.resolveCurrent(v);
+          },
+          onCancel: cancel
+        }
+      ) });
+    case "input":
+      return /* @__PURE__ */ jsx8(Box8, { children: /* @__PURE__ */ jsx8(
+        InputPrompt,
+        {
+          options: current.options,
+          onSubmit: (v) => {
+            promptQueue.resolveCurrent(v);
+          },
+          onCancel: cancel
+        }
+      ) });
+    case "select":
+      return /* @__PURE__ */ jsx8(Box8, { children: /* @__PURE__ */ jsx8(
+        SelectPrompt,
+        {
+          options: current.options,
+          onSubmit: (v) => {
+            promptQueue.resolveCurrent(v);
+          },
+          onCancel: cancel
+        }
+      ) });
+    case "checkbox":
+      return /* @__PURE__ */ jsx8(Box8, { children: /* @__PURE__ */ jsx8(
+        CheckboxPrompt,
+        {
+          options: current.options,
+          onSubmit: (v) => {
+            promptQueue.resolveCurrent(v);
+          },
+          onCancel: cancel
+        }
+      ) });
+    case "editor":
+      return /* @__PURE__ */ jsx8(Box8, { children: /* @__PURE__ */ jsx8(
+        EditorPrompt,
+        {
+          options: current.options,
+          onSubmit: (v) => {
+            promptQueue.resolveCurrent(v);
+          },
+          onCancel: () => {
+            promptQueue.resolveCurrent(null);
+          }
+        }
+      ) });
+    case "fileBrowser":
+      return /* @__PURE__ */ jsx8(Box8, { children: /* @__PURE__ */ jsx8(
+        FileBrowserPrompt,
+        {
+          options: current.options,
+          onSubmit: (v) => {
+            promptQueue.resolveCurrent(v);
+          },
+          onCancel: () => {
+            promptQueue.resolveCurrent(null);
+          }
+        }
+      ) });
+    default: {
+      const _exhaustive = current;
+      void _exhaustive;
+      return null;
+    }
+  }
+}
+
+// src/integration/ui/prompts/auto-mount.tsx
+import { jsx as jsx9 } from "react/jsx-runtime";
+var hostState = "none";
+var autoInstance = null;
+var drainUnsubscribe = null;
+function registerExternalHost() {
+  hostState = "external";
+  return () => {
+    hostState = "none";
+  };
+}
+function canInteract() {
+  if (process.env["RALPHCTL_NO_TUI"]) return false;
+  if (process.env["CI"]) return false;
+  if (process.env["RALPHCTL_JSON"]) return false;
+  if (!process.stdout.isTTY) return false;
+  if (!process.stdin.isTTY) return false;
+  return true;
+}
+function ensurePromptHost() {
+  if (hostState === "external" || hostState === "auto") return;
+  if (!canInteract()) {
+    throw new PromptCancelledError(
+      "Interactive prompt requested in non-interactive environment. Pass the value as a CLI flag."
+    );
+  }
+  hostState = "auto";
+  autoInstance = render(/* @__PURE__ */ jsx9(PromptHost, {}), { exitOnCtrlC: false });
+  drainUnsubscribe = promptQueue.subscribe((state) => {
+    if (state.current === null) {
+      setImmediate(() => {
+        if (promptQueue.size() === 0) teardownAutoHost();
+      });
+    }
+  });
+}
+function teardownAutoHost() {
+  if (hostState !== "auto") return;
+  drainUnsubscribe?.();
+  drainUnsubscribe = null;
+  autoInstance?.unmount();
+  autoInstance = null;
+  hostState = "none";
+}
+
+// src/integration/ui/prompts/prompt-adapter.ts
+var InkPromptAdapter = class {
+  select(options) {
+    ensurePromptHost();
+    return new Promise((resolve2, reject) => {
+      promptQueue.enqueue({
+        kind: "select",
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+        options,
+        resolve: resolve2,
+        reject
+      });
+    });
+  }
+  confirm(options) {
+    ensurePromptHost();
+    return new Promise((resolve2, reject) => {
+      promptQueue.enqueue({ kind: "confirm", options, resolve: resolve2, reject });
+    });
+  }
+  input(options) {
+    ensurePromptHost();
+    return new Promise((resolve2, reject) => {
+      promptQueue.enqueue({ kind: "input", options, resolve: resolve2, reject });
+    });
+  }
+  checkbox(options) {
+    ensurePromptHost();
+    return new Promise((resolve2, reject) => {
+      promptQueue.enqueue({
+        kind: "checkbox",
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
+        options,
+        resolve: resolve2,
+        reject
+      });
+    });
+  }
+  editor(options) {
+    ensurePromptHost();
+    return new Promise((resolve2, reject) => {
+      promptQueue.enqueue({ kind: "editor", options, resolve: resolve2, reject });
+    });
+  }
+  fileBrowser(options) {
+    ensurePromptHost();
+    return new Promise((resolve2, reject) => {
+      promptQueue.enqueue({ kind: "fileBrowser", options, resolve: resolve2, reject });
+    });
+  }
+};
+
+export {
+  PromptCancelledError,
+  useCurrentPrompt,
+  inkColors,
+  glyphs,
+  spacing,
+  FIELD_LABEL_WIDTH,
+  PromptHost,
+  registerExternalHost,
+  InkPromptAdapter
+};