@buildaharness/aielia 0.3.3 → 0.3.5

package/dist/{tui-app-CFfOP2DC.js → tui-app-BLR-PRFp.js}

@@ -3,11 +3,11 @@ var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { en
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 import { jsxs, jsx } from "react/jsx-runtime";
 import { Readable, Writable } from "node:stream";
-import { useState, useRef, useCallback, useSyncExternalStore, useEffect } from "react";
+import { useState, useRef, useMemo, useCallback, useSyncExternalStore, useEffect } from "react";
 import { useWindowSize, usePaste, useInput, Box, Text, render, Static } from "ink";
-import { r as runCli, P as PLAN_LINE_PREFIX, I as ICONS } from "./bin-Btzhiyzi.js";
+import { r as renderPlan, t as toLines, a as runCli, P as PLAN_LINE_PREFIX, I as ICONS } from "./bin-CjKpxDxl.js";
 import { format } from "node:util";
-import { h as DIFF_INDENT } from "./cli-session-DnSc6Hhx.js";
+import { n as DIFF_INDENT } from "./provider-setup-LFsaTkpf.js";
 function classify(raw, stream) {
   if (raw.startsWith("\r")) {
     return { type: "progress", text: raw.replace(/\r/g, "").trimEnd() };
@@ -244,6 +244,189 @@ function SelectPrompt(props) {
     ] }, option.key)) })
   ] });
 }
+function navModelFrom(nodes, boxes) {
+  const byId = new Map(boxes.map((b) => [b.id, b]));
+  const ids = nodes.map((n) => n.id).filter((id) => byId.has(id));
+  const dependents = Object.fromEntries(ids.map((id) => [id, []]));
+  for (const n of nodes) if (byId.has(n.id)) {
+    for (const d of n.deps) if (dependents[d]) dependents[d].push(n.id);
+  }
+  return {
+    ids,
+    taskOrder: ids,
+    x: Object.fromEntries(ids.map((id) => [id, byId.get(id).x + byId.get(id).w / 2])),
+    y: Object.fromEntries(ids.map((id) => [id, byId.get(id).y])),
+    deps: Object.fromEntries(nodes.map((n) => [n.id, n.deps.filter((d) => byId.has(d))])),
+    dependents
+  };
+}
+const cmp = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+const byX = (m, ids) => [...ids].sort((a, b) => m.x[a] - m.x[b] || cmp(a, b));
+const planNavigator = {
+  start: (_m, id) => ({ cur: id, k: 0 }),
+  press(m, st, key) {
+    if (key === "tab" || key === "shiftTab") {
+      const n = m.taskOrder.length;
+      if (!n) return st;
+      const i2 = m.taskOrder.indexOf(st.cur);
+      return { cur: m.taskOrder[(i2 + (key === "tab" ? 1 : -1) + n) % n], k: 0 };
+    }
+    if (key === "up" || key === "down") {
+      const origin = st.lastKey === key && st.lastFrom !== void 0 ? st.lastFrom : st.cur;
+      const cands = byX(m, (key === "up" ? m.deps[origin] : m.dependents[origin]) ?? []);
+      if (!cands.length) return st;
+      const nearest = [...cands].sort((a, b) => Math.abs(m.x[a] - m.x[origin]) - Math.abs(m.x[b] - m.x[origin]) || cmp(a, b))[0];
+      const k = st.lastKey === key ? (st.k + 1) % cands.length : 0;
+      return { cur: cands[(cands.indexOf(nearest) + k) % cands.length], lastKey: key, lastFrom: origin, k };
+    }
+    const rank = byX(m, m.ids.filter((id) => m.y[id] === m.y[st.cur]));
+    const i = rank.indexOf(st.cur);
+    if (i < 0) return st;
+    return { cur: rank[(i + (key === "left" ? -1 : 1) + rank.length) % rank.length], lastKey: key, k: 0 };
+  }
+};
+function followSelection(prev, box, grid, term) {
+  const width = Math.min(term.cols, grid.width);
+  const height = Math.min(term.rows, grid.height);
+  const fit = (start, size, bStart, bSize, total) => {
+    let s = start;
+    if (bStart < s) s = bStart;
+    if (bStart + bSize > s + size) s = bStart + bSize - size;
+    return Math.max(0, Math.min(s, total - size));
+  };
+  return { width, height, left: fit(prev.left, width, box.x, box.w, grid.width), top: fit(prev.top, height, box.y, box.h, grid.height) };
+}
+function scrollIndicators(v, grid) {
+  return { up: v.top > 0, down: v.top + v.height < grid.height, left: v.left > 0, right: v.left + v.width < grid.width };
+}
+const STATUS_WORD = {
+  pending: "pending",
+  ready: "ready to run",
+  running: "running",
+  done: "done",
+  failed: "failed",
+  awaiting_user: "waiting for you",
+  awaiting_input: "blocked, waiting for input",
+  cancelled: "cancelled"
+};
+function wrap(text, width) {
+  const out = [];
+  let line = "";
+  for (const word of text.split(/\s+/).filter(Boolean)) {
+    let w = word;
+    while (w.length > width) {
+      if (line) {
+        out.push(line);
+        line = "";
+      }
+      out.push(w.slice(0, width));
+      w = w.slice(width);
+    }
+    if (!line) line = w;
+    else if (line.length + 1 + w.length <= width) line += ` ${w}`;
+    else {
+      out.push(line);
+      line = w;
+    }
+  }
+  if (line) out.push(line);
+  return out;
+}
+function planDetailLines(nodes, id, width) {
+  const node = nodes.find((n) => n.id === id);
+  if (!node) return ["No task selected."];
+  const w = Math.max(10, width);
+  const name = (i) => {
+    var _a;
+    return ((_a = nodes.find((n) => n.id === i)) == null ? void 0 : _a.id) ?? i;
+  };
+  const dependents = nodes.filter((n) => n.deps.includes(node.id)).map((n) => n.id);
+  return [
+    ...wrap(node.id, w),
+    "",
+    ...wrap(node.label, w),
+    "",
+    `Status: ${STATUS_WORD[node.status] ?? node.status}`,
+    ...wrap(`Depends on: ${node.deps.length ? node.deps.map(name).join(", ") : "nothing"}`, w),
+    ...wrap(`Needed by: ${dependents.length ? dependents.join(", ") : "nothing"}`, w)
+  ];
+}
+const DRAWER_DOCK_COLUMNS = 120;
+const DRAWER_WIDTH = 36;
+function PlanGraphPane({ nodes, columns, rows, active = true, color = true, ascii = false, onClose }) {
+  const docked = columns >= DRAWER_DOCK_COLUMNS;
+  const [drawerOpen, setDrawerOpen] = useState(false);
+  const showDrawer = docked || drawerOpen;
+  const graphCols = showDrawer ? Math.max(20, columns - DRAWER_WIDTH - 1) : columns;
+  const graphRows = Math.max(3, rows - 2);
+  const [nav, setNav] = useState(void 0);
+  const lastIndex = useRef(0);
+  const viewport = useRef({ left: 0, top: 0, width: 0, height: 0 });
+  const base = useMemo(() => renderPlan(nodes, { maxCols: graphCols, ascii, color: false }), [nodes, graphCols, ascii]);
+  const model = useMemo(() => base.ok ? navModelFrom(nodes, base.boxes) : void 0, [nodes, base]);
+  let selectedId;
+  if (model && model.ids.length) {
+    if (nav && model.ids.includes(nav.cur)) selectedId = nav.cur;
+    else selectedId = model.taskOrder[Math.min(lastIndex.current, model.taskOrder.length - 1)];
+  }
+  if (model && selectedId) lastIndex.current = model.taskOrder.indexOf(selectedId);
+  const detail = useMemo(() => planDetailLines(nodes, selectedId, DRAWER_WIDTH - 2), [nodes, selectedId]);
+  const [scroll, setScroll] = useState({ id: void 0, offset: 0 });
+  const drawerRows = graphRows;
+  const maxScroll = Math.max(0, detail.length - drawerRows);
+  const drawerOffset = scroll.id === selectedId ? Math.min(scroll.offset, maxScroll) : 0;
+  const scrollDrawer = (delta) => setScroll({ id: selectedId, offset: Math.max(0, Math.min(maxScroll, drawerOffset + delta)) });
+  useInput(
+    (input, key) => {
+      if (key.escape || input === "q") return onClose();
+      if (key.return || input === "d") return setDrawerOpen((open) => !open);
+      if (showDrawer) {
+        if (input === "j") return scrollDrawer(1);
+        if (input === "k") return scrollDrawer(-1);
+        if (key.pageDown) return scrollDrawer(drawerRows);
+        if (key.pageUp) return scrollDrawer(-drawerRows);
+      }
+      if (!model || !selectedId) return;
+      const k = key.upArrow || input === "[" ? "up" : key.downArrow || input === "]" ? "down" : key.leftArrow ? "left" : key.rightArrow ? "right" : key.tab ? key.shift ? "shiftTab" : "tab" : void 0;
+      if (!k) return;
+      const from = nav && nav.cur === selectedId ? nav : planNavigator.start(model, selectedId);
+      setNav(planNavigator.press(model, from, k));
+    },
+    { isActive: active }
+  );
+  if (!base.ok || !model) {
+    return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", height: rows, children: [
+      /* @__PURE__ */ jsxs(Text, { children: [
+        "Plan graph unavailable: ",
+        base.ok ? "nothing to draw" : base.message
+      ] }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "q / Esc closes" })
+    ] });
+  }
+  const r = renderPlan(nodes, { maxCols: graphCols, ascii, color, selectedId });
+  if (!r.ok) return /* @__PURE__ */ jsxs(Text, { children: [
+    "Plan graph unavailable: ",
+    r.message
+  ] });
+  const box = r.boxes.find((b) => b.id === selectedId);
+  const vp = box ? followSelection(viewport.current, box, r, { cols: graphCols, rows: graphRows }) : { left: 0, top: 0, width: Math.min(graphCols, r.width), height: Math.min(graphRows, r.height) };
+  viewport.current = vp;
+  const lines = toLines(r.cells, r.styles, [vp.top, vp.top + vp.height], [vp.left, vp.left + vp.width]);
+  const more = scrollIndicators(vp, r);
+  const arrows = `${more.up ? "↑" : " "}${more.down ? "↓" : " "}${more.left ? "←" : " "}${more.right ? "→" : " "}`;
+  const done = nodes.filter((n) => n.status === "done").length;
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", height: rows, children: [
+    /* @__PURE__ */ jsxs(Text, { bold: true, children: [
+      `Plan graph — ${done}/${nodes.length} done `,
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: arrows })
+    ] }),
+    /* @__PURE__ */ jsxs(Box, { flexDirection: "row", flexGrow: 1, children: [
+      /* @__PURE__ */ jsx(Box, { flexDirection: "column", width: graphCols, children: lines.map((line, i) => /* @__PURE__ */ jsx(Text, { wrap: "truncate", children: line.length ? line : " " }, i)) }),
+      showDrawer && /* @__PURE__ */ jsx(Box, { flexDirection: "column", width: DRAWER_WIDTH + 1, paddingLeft: 1, borderStyle: "single", borderTop: false, borderBottom: false, borderRight: false, children: detail.slice(drawerOffset, drawerOffset + drawerRows).map((line, i) => /* @__PURE__ */ jsx(Text, { wrap: "truncate", children: line.length ? line : " " }, i)) })
+    ] }),
+    /* @__PURE__ */ jsx(Text, { dimColor: true, children: docked ? "↑↓←→ move · Tab next · j/k PgUp/PgDn scroll details · q close" : "↑↓←→ move · Tab next · Enter details · q close" })
+  ] });
+}
 const HEADER_RE = /^(#{1,6})\s+(.*)$/;
 const CHECKBOX_RE = /^(\s*[-*]\s)\[([ xX])\]\s+(.*)$/;
 const DIFF_LINE_RE = /^(\s*\d+) ([+\- ])(.*)$/;
@@ -463,6 +646,107 @@ class StatusBridge {
     for (const listener of this.listeners) listener();
   }
 }
+const ALT_SCREEN_ON = "\x1B[?1049h";
+const ALT_SCREEN_OFF = "\x1B[?1049l";
+const ALT_SCREEN_SETTLE_MS = 80;
+const PLAN_GRAPH_MIN_RENDER_MS = 100;
+class PlanGraphBridge {
+  constructor(writeRaw, settleMs = ALT_SCREEN_SETTLE_MS, minRenderMs = PLAN_GRAPH_MIN_RENDER_MS) {
+    __publicField(this, "view", { mode: "chat", nodes: [] });
+    __publicField(this, "listeners", /* @__PURE__ */ new Set());
+    __publicField(this, "timer");
+    __publicField(this, "pendingNodes");
+    __publicField(this, "transition", Promise.resolve());
+    __publicField(this, "subscribe", (listener) => {
+      this.listeners.add(listener);
+      return () => {
+        this.listeners.delete(listener);
+      };
+    });
+    __publicField(this, "getSnapshot", () => this.view);
+    this.writeRaw = writeRaw;
+    this.settleMs = settleMs;
+    this.minRenderMs = minRenderMs;
+  }
+  isOpen() {
+    return this.view.mode !== "chat";
+  }
+  set(view) {
+    this.view = view;
+    for (const listener of this.listeners) listener();
+  }
+  sleep() {
+    return new Promise((resolve) => setTimeout(resolve, this.settleMs));
+  }
+  open(nodes) {
+    this.transition = this.transition.then(async () => {
+      if (this.view.mode !== "chat") {
+        this.update(nodes);
+        return;
+      }
+      this.set({ mode: "blank", nodes });
+      await this.sleep();
+      this.writeRaw(ALT_SCREEN_ON);
+      this.set({ mode: "pane", nodes: this.pendingNodes ?? nodes });
+      this.pendingNodes = void 0;
+    });
+    return this.transition;
+  }
+  close() {
+    this.transition = this.transition.then(async () => {
+      if (this.view.mode === "chat") return;
+      this.clearTimer();
+      this.set({ mode: "blank", nodes: this.view.nodes });
+      await this.sleep();
+      this.writeRaw(ALT_SCREEN_OFF);
+      this.set({ mode: "chat", nodes: [] });
+    });
+    return this.transition;
+  }
+  /** Synchronous leave for process exit: restores the main screen without waiting. */
+  restore() {
+    this.clearTimer();
+    if (this.view.mode === "pane") this.writeRaw(ALT_SCREEN_OFF);
+    this.view = { mode: "chat", nodes: [] };
+  }
+  /** Throttled node update: the first goes through at once, later ones coalesce to the newest within `minRenderMs`. Identical content is ignored. */
+  update(nodes) {
+    if (this.view.mode === "chat") return;
+    if (this.view.mode === "blank") {
+      this.pendingNodes = nodes;
+      return;
+    }
+    if (this.timer) {
+      this.pendingNodes = nodes;
+      return;
+    }
+    this.apply(nodes);
+    this.timer = setTimeout(() => this.flush(), this.minRenderMs);
+  }
+  apply(nodes) {
+    if (this.view.mode !== "pane" || JSON.stringify(nodes) === JSON.stringify(this.view.nodes)) return;
+    this.set({ mode: "pane", nodes });
+  }
+  flush() {
+    this.timer = void 0;
+    const next = this.pendingNodes;
+    this.pendingNodes = void 0;
+    if (next) {
+      this.apply(next);
+      this.timer = setTimeout(() => this.flush(), this.minRenderMs);
+    }
+  }
+  clearTimer() {
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = void 0;
+    this.pendingNodes = void 0;
+  }
+}
+const NO_PLAN_GRAPH = { subscribe: () => () => {
+}, getSnapshot: /* @__PURE__ */ (() => {
+  const v = { mode: "chat", nodes: [] };
+  return () => v;
+})() };
 function UserMessageBox({ text, width, borderColor = "gray" }) {
   return /* @__PURE__ */ jsx(Box, { borderStyle: "round", borderColor, flexDirection: "column", paddingX: 1, width, children: text.split("\n").map((line, i) => /* @__PURE__ */ jsx(Text, { children: line.length > 0 ? line : " " }, i)) });
 }
@@ -509,12 +793,15 @@ function StatusLine({ indicators }) {
   ] }, indicator)) });
 }
 function TuiApp(props) {
-  const { eventLog, prompt, status, onSubmitChat, onExit, columns } = props;
+  const { eventLog, prompt, status, planGraph, onSubmitChat, onExit, columns } = props;
   const log = useStore(eventLog);
   const pending = useStore(prompt);
   const statusIndicators = useStore(status);
   const windowSize = useWindowSize();
   const width = columns ?? windowSize.columns;
+  const graphView = useStore(planGraph ?? NO_PLAN_GRAPH);
+  const frozenLines = useRef(0);
+  if (graphView.mode === "chat") frozenLines.current = log.lines.length;
   useInput((input, key) => {
     if (key.ctrl && input === "c") onExit();
   });
@@ -538,10 +825,24 @@ function TuiApp(props) {
     },
     [eventLog, prompt, pending]
   );
+  const closePane = useCallback(() => {
+    void (planGraph == null ? void 0 : planGraph.close());
+  }, [planGraph]);
   const hasTransient = log.progressText.length > 0 || log.transientText.length > 0;
   const showSpinner = log.waitingForOutput && !hasTransient;
+  const staticItems = graphView.mode === "chat" ? log.lines : log.lines.slice(0, frozenLines.current);
+  const paneRows = Math.max(3, (windowSize.rows ?? 24) - 1);
+  if (graphView.mode !== "chat") {
+    const promptRows = pending ? Math.min(10, Math.floor(paneRows / 2)) : 0;
+    return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx(Static, { items: staticItems, children: (line, index) => /* @__PURE__ */ jsx(LogLineText, { line, width }, index) }),
+      graphView.mode === "pane" && /* @__PURE__ */ jsx(PlanGraphPane, { nodes: graphView.nodes, columns: width, rows: paneRows - promptRows, active: !pending, color: !process.env.NO_COLOR, onClose: closePane }),
+      graphView.mode === "pane" && (pending == null ? void 0 : pending.options) && /* @__PURE__ */ jsx(SelectPrompt, { question: pending.question, options: pending.options, onSubmit: handleSubmitPrompt }),
+      graphView.mode === "pane" && pending && !pending.options && /* @__PURE__ */ jsx(TuiInput, { promptLabel: pending.question, onSubmitChat: handleSubmitChat, onSubmitPrompt: handleSubmitPrompt, columns })
+    ] });
+  }
   return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsx(Static, { items: log.lines, children: (line, index) => /* @__PURE__ */ jsx(LogLineText, { line, width }, index) }),
+    /* @__PURE__ */ jsx(Static, { items: staticItems, children: (line, index) => /* @__PURE__ */ jsx(LogLineText, { line, width }, index) }),
     showSpinner && /* @__PURE__ */ jsx(Spinner, {}),
     hasTransient && /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
       log.progressText.length > 0 && /* @__PURE__ */ jsx(Text, { dimColor: true, children: log.progressText }),
@@ -583,11 +884,17 @@ async function runTuiApp(options = {}) {
   const status = new StatusBridge();
   const originalWrite = process.stdout.write.bind(process.stdout);
   const restoreCapture = startCapture((event) => eventLog.handleEvent(event));
+  const planGraph = new PlanGraphBridge((chunk) => void originalWrite(chunk));
+  let instanceRef;
   let instance;
   try {
     const inert = createInertStreams();
     instance = await runCli({
       ...options,
+      openPlanGraph: (nodes) => void planGraph.open(nodes),
+      onPlanProgress: (tasks) => {
+        if (planGraph.isOpen()) void (instanceRef == null ? void 0 : instanceRef.getPlanGraphNodes(tasks).then((nodes) => nodes && planGraph.update(nodes)));
+      },
       input: options.input ?? inert.input,
       output: options.output ?? inert.output,
       askYesNo: prompt.askYesNo,
@@ -598,8 +905,13 @@ async function runTuiApp(options = {}) {
     restoreCapture();
     throw err;
   }
+  instanceRef = instance;
   const refreshStatus = async () => {
     status.set(await instance.getStatusIndicators());
+    if (planGraph.isOpen()) {
+      const nodes = await instance.getPlanGraphNodes();
+      if (nodes) planGraph.update(nodes);
+    }
   };
   await refreshStatus();
   const handleSubmitChat = (line) => {
@@ -609,12 +921,13 @@ async function runTuiApp(options = {}) {
   const exit = () => {
     if (exiting) return;
     exiting = true;
+    planGraph.restore();
     restoreCapture();
     instance.close();
     app.unmount();
     process.exit(0);
   };
-  const app = render(/* @__PURE__ */ jsx(TuiApp, { eventLog, prompt, status, onSubmitChat: handleSubmitChat, onExit: exit }), {
+  const app = render(/* @__PURE__ */ jsx(TuiApp, { eventLog, prompt, status, planGraph, onSubmitChat: handleSubmitChat, onExit: exit }), {
     // Phase 1's startCapture already routes every console.log/process.stdout.write call into
     // eventLog — ink's own patchConsole would double-intercept the same calls with a competing
     // mechanism (writing them above its own Static area independently), not compose with it.
@@ -629,9 +942,10 @@ async function runTuiApp(options = {}) {
 }
 export {
   EventLogBridge,
+  PlanGraphBridge,
   PromptBridge,
   StatusBridge,
   TuiApp,
   runTuiApp
 };
-//# sourceMappingURL=tui-app-CFfOP2DC.js.map
+//# sourceMappingURL=tui-app-BLR-PRFp.js.map