jeo-code 0.6.4 → 0.6.6

package/src/tui/components/input-box.ts

@@ -159,3 +159,59 @@ export function renderInputFrame(line: string, opts: InputBoxOptions = {}): Inpu
 export function renderInputBox(line: string, opts: InputBoxOptions = {}): string[] {
   return renderInputFrame(line, opts).lines;
 }
+/** Visual (row, display-col) of every caret position 0..N of `text` wrapped at `width`,
+ *  using the SAME wrapping rule as the input box (`wrapWithCursor`). Index i is the caret
+ *  sitting BEFORE char i (N = end of text); `cursor` offsets are code points, matching how
+ *  `renderInputFrame` clamps `opts.cursor` against `Array.from(text)`. */
+export interface CaretCell {
+  row: number;
+  col: number;
+}
+export function caretCells(text: string, width: number): CaretCell[] {
+  const cells: CaretCell[] = [];
+  let curW = 0;
+  let row = 0;
+  const chars = Array.from(text.replace(/\r/g, ""));
+  for (let i = 0; i <= chars.length; i++) {
+    const ch = i < chars.length ? chars[i]! : "";
+    const w = ch === "" || ch === "\n" ? 0 : ch === "\t" ? 2 : visibleWidth(ch);
+    // Wrap BEFORE recording the caret so a caret on a wrapping char follows it down — the
+    // exact order wrapWithCursor uses, so cell rows match the rendered box rows.
+    if (w > 0 && curW + w > width && curW > 0) { row += 1; curW = 0; }
+    cells.push({ row, col: curW });
+    if (ch === "\n") { row += 1; curW = 0; continue; }
+    if (ch !== "") curW += w;
+  }
+  return cells;
+}
+
+/** New caret offset after an Up/Down move within the wrapped input box, keeping the
+ *  display column (textarea convention: snap to the nearest column ≤ the current one on the
+ *  target row). Returns null when already on the top row (Up) or bottom row (Down), so the
+ *  caller can fall through to readline's input-history recall. */
+export function verticalCursorOffset(
+  text: string,
+  cursor: number,
+  width: number,
+  dir: "up" | "down",
+): number | null {
+  const cells = caretCells(text, Math.max(1, width));
+  if (cells.length === 0) return null;
+  const pos = Math.max(0, Math.min(cursor, cells.length - 1));
+  const curRow = cells[pos]!.row;
+  const targetRow = dir === "up" ? curRow - 1 : curRow + 1;
+  const maxRow = cells[cells.length - 1]!.row;
+  if (targetRow < 0 || targetRow > maxRow) return null;
+  const curCol = cells[pos]!.col;
+  let best = -1;
+  let bestCol = -1;
+  let firstOnRow = -1;
+  for (let p = 0; p < cells.length; p++) {
+    if (cells[p]!.row !== targetRow) continue;
+    if (firstOnRow === -1) firstOnRow = p;
+    const c = cells[p]!.col;
+    // Largest column not past the current one — the standard column-preserving snap.
+    if (c <= curCol && c > bestCol) { best = p; bestCol = c; }
+  }
+  return best !== -1 ? best : firstOnRow;
+}

package/src/tui/components/welcome.ts

@@ -21,6 +21,8 @@ export interface WelcomeData {
   accentShadow?: (s: string) => string;
   unicode?: boolean;       // default true
   color?: boolean;         // default true
+  /** Center the hero box horizontally within `cols` (gjc forge screen placement). */
+  center?: boolean;
 }
 
 function getVisibleWidth(s: string): number {
@@ -55,7 +57,20 @@ export function renderWelcome(d: WelcomeData): string[] {
     return [ `jeo v${d.version} · ${d.model}` ];
   }
 
-  const W = Math.min(100, cols - 2);
+  // The banner hugs a NATURAL hero width so it reads as a proportional box — the
+  // grand DNA-claw framed by even margins — instead of stretching into a mostly
+  // empty rectangle on wide terminals. When the terminal is SMALLER than that
+  // initial/native width it shrinks proportionally: the box narrows and the claw
+  // steps grand→compact (below) so the art keeps its shape and never clips.
+  const grandWidth = Math.max(...DNA_CLAW_ART_GRAND.map(l => l.length));
+  // Title rides ON the top border: `─── jeo v{version} · JEO forge ───`. Defined
+  // once here so the natural-width calc and the border render below can't drift.
+  const titleDashes = 3;
+  const titleLabel = ` jeo v${d.version} · JEO forge `;
+  const titleWidth = titleDashes + titleLabel.length;
+  // grand art (36) + a 6-col margin each side, never narrower than the title.
+  const naturalInner = Math.max(grandWidth + 12, titleWidth + 2);
+  const W = Math.min(cols - 2, naturalInner + 2);
   const inner = W - 2;
 
   const BOX_UNICODE = { tl: "╭", tr: "╮", bl: "╰", br: "╯", h: "─", v: "│" };
@@ -67,9 +82,9 @@ export function renderWelcome(d: WelcomeData): string[] {
   const lit = useColor ? (d.accent ?? chalk.gray) : (s: string) => s;
   const shadow = useColor ? (d.accentShadow ?? ((s: string) => chalk.dim(chalk.gray(s)))) : (s: string) => s;
 
-  // Title text: ─── jeo v{version} · JEO forge ─── (bold for contrast against the border)
-  const dashStr = g.h.repeat(3);
-  const titleLabel = ` jeo v${d.version} · JEO forge `;
+  // Title text: ─── jeo v{version} · JEO forge ─── (bold for contrast against the border).
+  // `titleDashes`/`titleLabel` were fixed above so width and render stay in sync.
+  const dashStr = g.h.repeat(titleDashes);
   const titleHead = `${dashStr}${titleLabel}`;
   let topBorderLine: string;
   if (titleHead.length + 2 > inner) {
@@ -87,7 +102,6 @@ export function renderWelcome(d: WelcomeData): string[] {
 
   // Grand symbol when the box is wide enough; compact DNA Claw otherwise.
   const colorLevel = useColor ? detectColorLevel(process.env, isTTY()) : ColorLevel.None;
-  const grandWidth = Math.max(...DNA_CLAW_ART_GRAND.map(l => l.length));
   const grand = inner >= grandWidth;
   const artLines = renderDnaClaw({
     color: useColor,
@@ -125,7 +139,15 @@ export function renderWelcome(d: WelcomeData): string[] {
     return leftBorder + line + rightBorder;
   });
 
-  return [topBorderLine, ...finalContentLines, bottomBorderLine];
+  const boxLines = [topBorderLine, ...finalContentLines, bottomBorderLine];
+  // Center the hero box on screen (gjc forge placement): pad every row by half the
+  // slack between the terminal width and the box width. Leading spaces only — the
+  // box borders/ANSI are untouched, so color and width math stay exact.
+  if (d.center && cols > W) {
+    const leftPad = " ".repeat(Math.floor((cols - W) / 2));
+    return boxLines.map(line => leftPad + line);
+  }
+  return boxLines;
 }
 
 /**

package/src/tui/renderer.ts

@@ -29,6 +29,7 @@ export class Renderer {
   private cols: () => number;
   private prev: string[] = [];
   private prevCols?: number;
+  private prevRows?: number;
   private readonly reserve: boolean;
   // Stale rows left on screen by the previous frame after insertAbove() dropped the
   // baseline; the next render() must EL-clear any of them beyond the new frame.
@@ -45,10 +46,13 @@ export class Renderer {
 
   render(lines: string[]): void {
     const currentCols = this.cols();
-    if (this.prevCols !== undefined && this.prevCols !== currentCols) {
+    const currentRows = size().rows;
+    if ((this.prevCols !== undefined && this.prevCols !== currentCols) ||
+        (this.prevRows !== undefined && this.prevRows !== currentRows)) {
       this.clear();
     }
     this.prevCols = currentCols;
+    this.prevRows = currentRows;
 
     const next = lines.map(line => truncate(line, currentCols));
     // Rows physically occupied by the prior frame — or recorded by reset() when the
@@ -61,7 +65,7 @@ export class Renderer {
     let cursorRow = 0;
     let out = "";
 
-    if (this.reserve && next.length > occupied && next.length <= Math.max(1, size().rows)) {
+    if (this.reserve && next.length > occupied && next.length <= Math.max(1, currentRows)) {
       // The cursor rests on the frame's first row (the anchor). Walk to the last
       // currently-occupied row, emit one newline per missing row (scrolling the
       // viewport when at the bottom margin), then hop back up to the — possibly

package/src/tui/terminal.ts

@@ -22,6 +22,13 @@ export function clearToEnd(): string {
   return `${ESC}0J`;
 }
 
+/** Full reset of the visible screen: erase the screen (2J), erase the scrollback
+ *  buffer (3J), and home the cursor (H). This is the gjc-style "fresh start" clear —
+ *  use it at launch and for `/clear`, NEVER mid-turn (it would flood tmux scrollback). */
+export function clearScreen(): string {
+  return `${ESC}2J${ESC}3J${ESC}H`;
+}
+
 export function hideCursor(): string {
   return `${ESC}?25l`;
 }