@bahulam/code 2.6.13 → 2.6.15

package/src/ui/input-dock.mjs

@@ -52,6 +52,7 @@ const INPUT_RIGHT_PAD = 2;
 const META_INDENT = 4;
 
 const DEFAULT_MAX_INPUT_ROWS = 6;
+const DEFAULT_OVERLAY_MAX_ROWS = 8;
 const MIN_INPUT_ROWS = 1;
 const MAX_INPUT_ROWS_CAP = 12;
 
@@ -71,10 +72,25 @@ let unsubResize = null;
 // the cursor at the correct input position. Without this, readline echoes
 // land on rows the dock briefly moved through mid-render and characters
 // appear above/below the input row.
-let lastFrame = { context: '', meta: '', tips: '', prefix: '', value: '', cursor: null };
+let lastFrame = { context: '', meta: '', tips: '', prefix: '', value: '', cursor: null, overlayLines: null };
 let resetting = false;
-
-function write(s) { try { OUT.write(s); } catch {} }
+let lastGeometry = null;
+let contentCursorRow = 1;
+let contentCursorCol = 1;
+let contentTrackingActive = false;
+let suppressWriteTracking = 0;
+let originalStdoutWrite = null;
+let originalStderrWrite = null;
+
+function write(s) {
+  try {
+    suppressWriteTracking++;
+    OUT.write(s);
+  } catch {
+  } finally {
+    suppressWriteTracking = Math.max(0, suppressWriteTracking - 1);
+  }
+}
 function setScrollRegion(top, bottom) { write(`${ESC}${top};${bottom}r`); }
 function clearScrollRegion() { write(`${ESC}r`); }
 function saveCursor() { write(`${ESC}s`); }
@@ -90,10 +106,80 @@ function cols() {
   return Math.max(40, term().columns || 80);
 }
 
+function drawableColumns() {
+  // Avoid writing into the final terminal column. Many terminals enter
+  // autowrap state there; during rapid resizes that can push fixed dock
+  // frame lines into scrollback.
+  return Math.max(1, cols() - 1);
+}
+
 function contentBottomRow() {
   return Math.max(1, rows() - reservedRows);
 }
 
+function clampContentCursor() {
+  const bottom = contentBottomRow();
+  contentCursorRow = Math.max(1, Math.min(bottom, contentCursorRow || 1));
+  contentCursorCol = Math.max(1, Math.min(cols(), contentCursorCol || 1));
+}
+
+function resetContentCursor(row = 1, col = 1) {
+  contentCursorRow = Math.max(1, Math.min(contentBottomRow(), Math.floor(row || 1)));
+  contentCursorCol = Math.max(1, Math.min(cols(), Math.floor(col || 1)));
+}
+
+function trackContentWrite(chunk) {
+  if (!mounted || !contentTrackingActive || suppressWriteTracking > 0) return;
+  const text = Buffer.isBuffer(chunk) ? chunk.toString('utf8') : String(chunk ?? '');
+  if (!text) return;
+  const clean = text
+    .replace(/\x1b\[[0-9;?]*[ -/]*[@-~]/g, '')
+    .replace(/\x1b[()][A-Za-z0-9]/g, '');
+  const bottom = contentBottomRow();
+  const width = Math.max(1, drawableColumns());
+  for (const ch of clean) {
+    if (ch === '\r') {
+      contentCursorCol = 1;
+      continue;
+    }
+    if (ch === '\n') {
+      contentCursorRow = Math.min(bottom, contentCursorRow + 1);
+      contentCursorCol = 1;
+      continue;
+    }
+    contentCursorCol++;
+    if (contentCursorCol > width) {
+      contentCursorRow = Math.min(bottom, contentCursorRow + 1);
+      contentCursorCol = 1;
+    }
+  }
+}
+
+function patchOutputTracking() {
+  if (originalStdoutWrite || originalStderrWrite) return;
+  originalStdoutWrite = process.stdout.write.bind(process.stdout);
+  originalStderrWrite = process.stderr.write.bind(process.stderr);
+  process.stdout.write = function trackedStdoutWrite(chunk, ...args) {
+    trackContentWrite(chunk);
+    return originalStdoutWrite(chunk, ...args);
+  };
+  process.stderr.write = function trackedStderrWrite(chunk, ...args) {
+    trackContentWrite(chunk);
+    return originalStderrWrite(chunk, ...args);
+  };
+}
+
+function unpatchOutputTracking() {
+  if (originalStdoutWrite) {
+    process.stdout.write = originalStdoutWrite;
+    originalStdoutWrite = null;
+  }
+  if (originalStderrWrite) {
+    process.stderr.write = originalStderrWrite;
+    originalStderrWrite = null;
+  }
+}
+
 // Row map (top → bottom of the reserved region).
 function topRuleRow()       { return contentBottomRow() + 1; }
 function spacerAboveRow()   { return topRuleRow() + 1; }
@@ -117,6 +203,18 @@ function resolveMaxInputRows(requested) {
   return Math.max(MIN_INPUT_ROWS, Math.min(MAX_INPUT_ROWS_CAP, n));
 }
 
+function resolveOverlayRowCap(requested = DEFAULT_OVERLAY_MAX_ROWS) {
+  const n = Number.parseInt(String(requested), 10);
+  if (!Number.isFinite(n)) return DEFAULT_OVERLAY_MAX_ROWS;
+  return Math.max(MIN_INPUT_ROWS, Math.min(MAX_INPUT_ROWS_CAP, n));
+}
+
+function overlayRowsForWrapped(wrappedLength, requestedMaxRows = DEFAULT_OVERLAY_MAX_ROWS) {
+  const rowCap = resolveOverlayRowCap(requestedMaxRows);
+  const wanted = Math.max(MIN_INPUT_ROWS, Math.floor(Number(wrappedLength) || 0));
+  return Math.min(rowCap, wanted);
+}
+
 // How many input rows does this (prefix + value) buffer need? Wrapped line
 // count clamped to [1, inputRowsMax]. Beyond the cap, tail-with-ellipsis
 // takes over inside drawInputLines so at most inputRowsMax rows render.
@@ -137,8 +235,8 @@ function computeInputRowsForBuffer(prefix, value) {
 // meta line) which then leaks into the transcript as streamed content
 // scrolls past them. We clear the old dock region BEFORE moving the frame
 // so the freed rows are blank when they enter the scroll region.
-function setInputRowsTo(nextRows) {
-  const clamped = Math.max(MIN_INPUT_ROWS, Math.min(inputRowsMax, Math.floor(nextRows)));
+function setInputRowsTo(nextRows, { maxRows = inputRowsMax } = {}) {
+  const clamped = Math.max(MIN_INPUT_ROWS, Math.min(maxRows, Math.floor(nextRows)));
   if (clamped === inputRows) return false;
   const shrinking = clamped < inputRows;
   if (mounted && shrinking) {
@@ -162,7 +260,7 @@ function setInputRowsTo(nextRows) {
 
 function padLine(text) {
   const value = String(text || '');
-  const pad = Math.max(0, cols() - visibleWidth(value));
+  const pad = Math.max(0, drawableColumns() - visibleWidth(value));
   return value + ' '.repeat(pad);
 }
 
@@ -183,7 +281,7 @@ function ruleChars(count) {
 // - Optional right-aligned context strip (session tokens/elapsed) with rule
 //   fill between label and context
 function topRuleLine(context = '') {
-  const w = Math.max(0, cols() - 1);
+  const w = Math.max(0, drawableColumns());
   const brand = paint.brand.primary;
   const bold = paint.bold;
 
@@ -192,14 +290,19 @@ function topRuleLine(context = '') {
   const label = bold(brand(BRAND_LABEL));
   const leftBlock = `${leadRule} ${accent}${label}`;
   const leftWidth = visibleWidth(leftBlock);
+  const rightPadRule = 2;
 
-  const ctx = fitText(context, Math.max(0, Math.floor(w / 2)));
+  const maxCtxWidth = Math.max(0, Math.min(
+    Math.floor(w / 2),
+    w - leftWidth - 1 /* left gap */ - 1 /* minimum middle */ - 1 /* ctx gap */ - rightPadRule - 1 /* tail gap */,
+  ));
+  const ctx = fitText(context, maxCtxWidth);
   const ctxWidth = ctx ? visibleWidth(ctx) : 0;
 
   // Rule fill in the middle. Reserve 1 space around ctx when present.
-  const gap = 1;
-  const rightPadRule = 2;
-  const middleWidth = Math.max(1, w - leftWidth - gap - ctxWidth - (ctx ? gap + rightPadRule : 0));
+  const middleWidth = ctx
+    ? Math.max(1, w - leftWidth - ctxWidth - rightPadRule - 3)
+    : Math.max(1, w - leftWidth - 1);
   const middleRule = brand(ruleChars(middleWidth));
 
   if (!ctx) {
@@ -210,7 +313,7 @@ function topRuleLine(context = '') {
 }
 
 function bottomRuleLine() {
-  return paint.brand.primary(ruleChars(Math.max(0, cols() - 1)));
+  return paint.brand.primary(ruleChars(Math.max(0, drawableColumns())));
 }
 
 // Always park the cursor at the tracked (prefix, value) input position.
@@ -229,11 +332,15 @@ function parkCursorAtInput() {
   focusDockInput(prefix, value, lastFrame.cursor);
 }
 
-function applyLayout() {
+function applyLayout({ clearPrevious = false } = {}) {
   if (!mounted) return;
+  if (clearPrevious && lastGeometry) {
+    clearDockArea({ restore: true, geometry: lastGeometry });
+  }
   const bottom = contentBottomRow();
   setScrollRegion(1, bottom);
   renderFrame(lastFrame);
+  clampContentCursor();
   // On (re)mount and resize, park at input if we have one; otherwise sit at
   // the bottom of the content region so any pending content writes flush
   // above the dock rather than into a stale mid-frame position.
@@ -257,6 +364,9 @@ function renderFrame(frame = {}) {
   clearLine();
 
   // (input rows are written by drawInputLines / clearInputRows)
+  if (Array.isArray(lastFrame.overlayLines)) {
+    drawInputLines(lastFrame.overlayLines);
+  }
 
   // Spacer below input.
   moveTo(spacerBelowRow(), 1);
@@ -290,6 +400,20 @@ function renderFrame(frame = {}) {
   // pinned-status writers clobber the outer save and restore to the wrong
   // place. Instead, callers that need the cursor parked at the input row
   // invoke parkCursorAtInput() after renderFrame returns.
+  lastGeometry = {
+    top: topRuleRow(),
+    bottom: rows(),
+  };
+}
+
+function clearDockRows(startRow, endRow) {
+  const maxRow = rows();
+  const start = Math.max(1, Math.min(maxRow, Math.floor(startRow || 1)));
+  const end = Math.max(start, Math.min(maxRow, Math.floor(endRow || maxRow)));
+  for (let row = start; row <= end; row++) {
+    moveTo(row, 1);
+    clearLine();
+  }
 }
 
 function clearInputRows() {
@@ -299,13 +423,10 @@ function clearInputRows() {
   }
 }
 
-export function clearDockArea({ restore = true } = {}) {
+export function clearDockArea({ restore = true, geometry = null } = {}) {
   if (!mounted) return false;
   if (restore) saveCursor();
-  for (let row = topRuleRow(); row <= rows(); row++) {
-    moveTo(row, 1);
-    clearLine();
-  }
+  clearDockRows(geometry?.top || topRuleRow(), geometry?.bottom || rows());
   if (restore) restoreCursor();
   return true;
 }
@@ -329,6 +450,15 @@ function layoutInput(prefix, value) {
   };
 }
 
+function layoutOverlayLines(lines) {
+  const budget = inputTextBudget();
+  const wrapped = [];
+  for (const line of lines) {
+    wrapped.push(...wrapToLines(line, budget));
+  }
+  return wrapped.length ? wrapped : [''];
+}
+
 function drawInputLines(lines) {
   const indent = ' '.repeat(INPUT_INDENT);
   for (let i = 0; i < inputRows; i++) {
@@ -346,7 +476,11 @@ export function isInputDockMounted() {
   return mounted;
 }
 
-export function mountInputDock({ inputRowsMax: requestedMax } = {}) {
+export function mountInputDock({
+  inputRowsMax: requestedMax,
+  initialContentRow = 1,
+  initialContentCol = 1,
+} = {}) {
   const t = term();
   if (!t.isTTY || t.plain) return false;
   if (t.ttyMode !== 'rich' || t.fixedInput === false) return false;
@@ -356,10 +490,13 @@ export function mountInputDock({ inputRowsMax: requestedMax } = {}) {
   inputRowsMax = resolveMaxInputRows(requestedMax);
   inputRows = MIN_INPUT_ROWS;
   reservedRows = FIXED_ROWS + inputRows;
+  resetContentCursor(initialContentRow, initialContentCol);
+  contentTrackingActive = false;
   mounted = true;
+  patchOutputTracking();
   applyLayout();
 
-  unsubResize = onResize(() => applyLayout());
+  unsubResize = onResize(() => applyLayout({ clearPrevious: true }));
   process.once('exit', safeUnmount);
   process.once('SIGTERM', () => { safeUnmount(); process.exit(143); });
   return true;
@@ -376,7 +513,10 @@ export function unmountInputDock() {
     if (unsubResize) { unsubResize(); unsubResize = null; }
   } finally {
     mounted = false;
+    contentTrackingActive = false;
+    unpatchOutputTracking();
     resetting = false;
+    lastGeometry = null;
   }
 }
 
@@ -384,17 +524,19 @@ function safeUnmount() { try { unmountInputDock(); } catch {} }
 
 export function moveToContent() {
   if (!mounted) return false;
-  moveTo(contentBottomRow(), 1);
+  clampContentCursor();
+  contentTrackingActive = true;
+  moveTo(contentCursorRow, contentCursorCol);
   return true;
 }
 
-// One row above the bottom of the scroll region. Writes here won't trigger
-// the scroll-on-LF that happens when writing '\n' at the region's bottom row —
-// exactly what the persistent explore/spinner line needs to overwrite in place
-// without piling copies of itself into scrollback.
+// The next transcript row. Spinner/status overlays live next to the latest
+// content instead of near the scroll-region bottom; otherwise sparse agent
+// events leave large blank holes between visible lines.
 export function pinnedStatusRow() {
   if (!mounted) return null;
-  return Math.max(1, contentBottomRow() - 1);
+  clampContentCursor();
+  return Math.max(1, Math.min(contentBottomRow(), contentCursorRow));
 }
 
 export function drawPinnedStatus(line) {
@@ -426,6 +568,7 @@ export function clearPinnedStatus() {
 // clearing their overlay.
 export function redrawDockFrame() {
   if (!mounted) return false;
+  contentTrackingActive = false;
   renderFrame(lastFrame);
   parkCursorAtInput();
   return true;
@@ -433,17 +576,21 @@ export function redrawDockFrame() {
 
 export function prepareInputPrompt({ context = '', tips = '', meta = '' } = {}) {
   if (!mounted) return false;
+  contentTrackingActive = false;
   setInputRowsTo(MIN_INPUT_ROWS);
   clearInputRows();
-  renderFrame({ context, tips, meta, prefix: '', value: '' });
+  renderFrame({ context, tips, meta, prefix: '', value: '', overlayLines: null });
   moveTo(inputRowStart(), INPUT_INDENT + 1);
   return true;
 }
 
 export function clearInputPrompt() {
   if (!mounted) return false;
-  clearInputRows();
+  contentTrackingActive = false;
   lastFrame.value = '';
+  lastFrame.overlayLines = null;
+  setInputRowsTo(MIN_INPUT_ROWS);
+  clearInputRows();
   renderFrame(lastFrame);
   parkCursorAtInput();
   return true;
@@ -451,14 +598,42 @@ export function clearInputPrompt() {
 
 export function renderDockInput(prefix, value, { context = '', tips = '', meta = '', cursor = null } = {}) {
   if (!mounted) return false;
+  contentTrackingActive = false;
   setInputRowsTo(computeInputRowsForBuffer(prefix, value));
-  renderFrame({ context, tips, meta, prefix, value, cursor });
+  renderFrame({ context, tips, meta, prefix, value, cursor, overlayLines: null });
   const layout = layoutInput(prefix, value);
   drawInputLines(layout.lines);
   focusDockInput(prefix, value, cursor);
   return true;
 }
 
+export function renderDockOverlay({
+  context = '',
+  lines = [],
+  meta = '',
+  tips = '',
+  maxRows = DEFAULT_OVERLAY_MAX_ROWS,
+} = {}) {
+  if (!mounted) return false;
+  contentTrackingActive = false;
+  const sourceLines = Array.isArray(lines) ? lines : String(lines || '').split('\n');
+  const wrapped = layoutOverlayLines(sourceLines);
+  const rowCap = resolveOverlayRowCap(maxRows);
+  setInputRowsTo(overlayRowsForWrapped(wrapped.length, rowCap), { maxRows: rowCap });
+  const tail = tailWithEllipsis(wrapped, inputRows);
+  renderFrame({
+    context,
+    meta,
+    tips,
+    prefix: '',
+    value: '',
+    cursor: null,
+    overlayLines: tail.visible,
+  });
+  moveTo(rows(), 1);
+  return true;
+}
+
 /**
  * Move the terminal cursor to the position that corresponds to
  * `prefix + value[0..cursorInValue]` within the (possibly wrapped and
@@ -470,6 +645,7 @@ export function renderDockInput(prefix, value, { context = '', tips = '', meta =
  */
 export function focusDockInput(prefix, value = '', cursorInValue = null) {
   if (!mounted) return false;
+  contentTrackingActive = false;
   const layout = layoutInput(prefix, value);
   const valueStr = String(value || '');
   const rawCursor = cursorInValue == null
@@ -499,7 +675,16 @@ export function _internals() {
     reservedRows: () => reservedRows,
     layoutInput,
     inputTextBudget,
+    topRuleLine,
+    bottomRuleLine,
+    padLine,
+    drawableColumns,
+    resetContentCursor,
+    contentCursor: () => ({ row: contentCursorRow, col: contentCursorCol, active: contentTrackingActive }),
+    overlayRowsForWrapped,
     FIXED_ROWS,
+    MAX_INPUT_ROWS_CAP,
+    DEFAULT_OVERLAY_MAX_ROWS,
     BRAND_LABEL,
   };
 }

package/src/ui/slash-commands.mjs

@@ -45,6 +45,7 @@ export const COMMANDS = {
   '/surgical':    'Verbosity: show everything (reasoning, expanded tools)',
   '/compact':     'Compact conversation context',
   '/agents':      'List available agents',
+  '/run':         'Run a sub-agent or synced workflow',
   '/explore':     'Code explorer agent',
   '/review':      'Code review agent',
   '/architect':   'Feature architect agent',
@@ -137,11 +138,20 @@ export const HELP_GROUPS = [
       ['/agents create <name>', 'Create .bahulam/agents/<name>.yaml'],
       ['/agents edit <name>', 'Open local agent YAML'],
       ['/agents sync [name]', 'Sync all or one local agent to cloud'],
+      ['/run <agent> [instruction]', 'Run a local or built-in agent'],
       ['/explore <instruction>', 'Explore code'],
       ['/review <instruction>', 'Review code'],
       ['/architect <instruction>', 'Design an approach'],
     ],
   },
+  {
+    key: 'workflows',
+    title: 'Workflows',
+    summary: 'saved automations',
+    commands: [
+      ['/run <workflow> [instruction]', 'Run a synced workflow if no agent matches'],
+    ],
+  },
   {
     key: 'session',
     title: 'Session',