phewsh 0.15.55 → 0.15.57

package/bin/phewsh.js

@@ -14,6 +14,12 @@ if (command === 'shim-preflight') {
   process.exit(0);
 }
 
+// Smart word-wrap for all prose the CLI prints — wraps at word boundaries
+// instead of the terminal's mid-word hard wrap. TTY-only, idempotent, and it
+// leaves process.stdout.write paths (spinner, streamed AI) alone. Installed
+// after the shim-preflight fast path so that stays instant and untouched.
+try { require('../lib/ui').installSmartWrap(); } catch { /* never block the CLI on cosmetics */ }
+
 // ── ANSI helpers (no chalk dependency)
 const b  = (s) => `\x1b[1m${s}\x1b[0m`;   // bold
 const d  = (s) => `\x1b[2m${s}\x1b[0m`;   // dim

package/lib/md.js

@@ -33,6 +33,43 @@ function inlineMd(t, base = '') {
       (_, x, u) => `${A.uline}${A.teal}${x}${A.reset}${base} ${A.dim}${A.slate}(${u})${A.reset}${base}`);
 }
 
+// Soft-wrap a rendered line at word boundaries to the terminal width — this is
+// what replaces the terminal's mid-word hard wrap (CSS `text-wrap: pretty`, in
+// spirit). We never break inside a word. `base` is the block's colour SGR,
+// re-emitted at the start of each continuation line so colour survives the
+// break; `hang` is the continuation indent (hanging indent under list/quote
+// markers). No-op when width is unknown (piped output) so redirected text and
+// tests stay raw.
+const ANSI = /\x1b\[[0-9;]*m/g;
+const vis = (s) => s.replace(ANSI, '').length;
+
+function softWrap(s, base = '', hang) {
+  const width = process.stdout.columns;
+  if (!width || width < 24 || vis(s) <= width) return s;
+  const lead = s.match(/^ */)[0].length;
+  const indent = hang == null ? lead : hang;
+  const words = s.slice(lead).split(/ +/);
+  const pad = ' '.repeat(indent);
+  const out = [];
+  let cur = ' '.repeat(lead);
+  let len = lead;
+  let started = false;
+  for (const word of words) {
+    const wl = vis(word);
+    if (started && len + 1 + wl > width) {
+      out.push(cur + A.reset);
+      cur = base + pad + word;
+      len = indent + wl;
+    } else {
+      cur += (started ? ' ' : '') + word;
+      len += (started ? 1 : 0) + wl;
+      started = true;
+    }
+  }
+  out.push(cur);
+  return out.join('\n');
+}
+
 // Render one complete line, mutating `state` for block-level context.
 // Body text keeps the default terminal foreground (bright) — only structural
 // elements get colour, so a reply reads as a reply, not as dimmed UI chrome.
@@ -47,12 +84,12 @@ function renderLine(line, state = {}) {
   }
   if (/^#{1,2}\s/.test(line)) return `\n${A.bold}${A.teal}${inlineMd(line.replace(/^#+\s*/, ''), A.teal)}${A.reset}`;
   if (/^#{3,}\s/.test(line)) return `${A.cream}${inlineMd(line.replace(/^#+\s*/, ''), A.cream)}${A.reset}`;
-  if (/^\s*[-*]\s/.test(line)) return `  ${A.teal}·${A.reset} ${A.sage}${inlineMd(line.replace(/^\s*[-*]\s*/, ''), A.sage)}${A.reset}`;
-  if (/^\s*\d+\.\s/.test(line)) return `  ${A.sage}${inlineMd(line.trim(), A.sage)}${A.reset}`;
-  if (/^\s*>\s?/.test(line)) return `  ${A.slate}${A.ital}${inlineMd(line.replace(/^\s*>\s?/, ''), A.slate)}${A.italOff}${A.reset}`;
+  if (/^\s*[-*]\s/.test(line)) return softWrap(`  ${A.teal}·${A.reset} ${A.sage}${inlineMd(line.replace(/^\s*[-*]\s*/, ''), A.sage)}${A.reset}`, A.sage, 4);
+  if (/^\s*\d+\.\s/.test(line)) return softWrap(`  ${A.sage}${inlineMd(line.trim(), A.sage)}${A.reset}`, A.sage, 5);
+  if (/^\s*>\s?/.test(line)) return softWrap(`  ${A.slate}${A.ital}${inlineMd(line.replace(/^\s*>\s?/, ''), A.slate)}${A.italOff}${A.reset}`, A.slate, 4);
   if (/^---+\s*$/.test(line)) return `  ${A.slate}${'─'.repeat(40)}${A.reset}`;
   if (line.trim() === '') return '';
-  return inlineMd(line, ''); // body: default foreground, inline styling only
+  return softWrap(inlineMd(line, ''), '', 0); // body: default foreground, inline styling only
 }
 
 // Line-buffered streaming renderer. Feed raw token text via push(); each time a

package/lib/ui.js

@@ -111,6 +111,72 @@ async function brandReveal(fast = false) {
   console.log('');
 }
 
+// ── Smart line wrap ──────────────────────────────────────
+// The terminal's default hard wrap breaks mid-word at the window edge. This
+// wraps at word boundaries instead (CSS `text-wrap: pretty`, in spirit),
+// ANSI-aware: colour codes carry zero width, and the colour active at a break
+// is re-opened on the continuation line so nothing loses its tint. A word
+// longer than the line is left whole — we never split inside a word, which is
+// the whole point. Per physical line; only over-long lines are touched.
+const SGR = /\x1b\[[0-9;]*m/g;
+const visW = (s) => s.replace(SGR, '').length;
+
+// Active SGR state after consuming `s`, starting from `prev`. A reset clears it;
+// any other colour code accumulates. Good enough to re-open colour at a break.
+function sgrAfter(prev, s) {
+  let active = prev;
+  for (const code of s.match(SGR) || []) {
+    active = (code === '\x1b[0m' || code === '\x1b[m') ? '' : active + code;
+  }
+  return active;
+}
+
+function wrapAnsi(s, width = process.stdout.columns) {
+  if (!width || width < 24) return s;
+  return s.split('\n').map((line) => {
+    if (visW(line) <= width) return line;
+    const lead = line.match(/^ */)[0].length;
+    const pad = ' '.repeat(lead);
+    const words = line.slice(lead).split(/ +/);
+    const out = [];
+    let cur = pad, len = lead, started = false, active = '';
+    for (const word of words) {
+      const wl = visW(word);
+      if (started && len + 1 + wl > width) {
+        out.push(cur + '\x1b[0m');       // close colour cleanly at the break
+        cur = active + pad + word;       // re-open it on the continuation line
+        len = lead + wl;
+      } else {
+        cur += (started ? ' ' : '') + word;
+        len += (started ? 1 : 0) + wl;
+        started = true;
+      }
+      active = sgrAfter(active, word);
+    }
+    out.push(cur);
+    return out.join('\n');
+  }).join('\n');
+}
+
+// Monkeypatch console.log so every prose line the CLI prints wraps at word
+// boundaries. TTY-only (piped/redirected output stays raw for tooling), and
+// only the simple all-string case is transformed — object args pass through
+// untouched. Idempotent. process.stdout.write paths (spinner, typewriter,
+// streamed AI render) are intentionally left alone; they handle their own.
+function installSmartWrap() {
+  if (!process.stdout.isTTY || console.log.__phewshWrapped) return;
+  const orig = console.log.bind(console);
+  const wrapped = (...args) => {
+    if (args.length && args.every((a) => typeof a === 'string')) {
+      orig(wrapAnsi(args.join(' ')));
+    } else {
+      orig(...args);
+    }
+  };
+  wrapped.__phewshWrapped = true;
+  console.log = wrapped;
+}
+
 // ── Status panel ─────────────────────────────────────────
 function statusPanel(title, rows) {
   const maxLabel = Math.max(...rows.map(r => r[0].length));
@@ -267,6 +333,8 @@ module.exports = {
   // Components
   spinner, brandReveal, statusPanel, interopLine, divider, typewrite,
   randomTip, TOUR_PAGES,
+  // Smart wrap
+  wrapAnsi, installSmartWrap,
   // ANSI helpers
   hide, show, up, clearLine, sleep,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "phewsh",
-  "version": "0.15.55",
+  "version": "0.15.57",
   "description": "Turn intent into action. Structure your thinking, execute your next step.",
   "bin": {
     "phewsh": "bin/phewsh.js"