@tiens.nguyen/gu-cli 1.0.787 → 1.0.789

package/terminal-layout.mjs

@@ -2434,11 +2434,104 @@ export function firstToolArg(codePart) {
   return { name: m[1], arg: String(value).trim() };
 }
 
+/**
+ * WHERE A THOUGHT LINE REALLY STARTS (task #333).
+ *
+ * The live line once read `one, call use_skill(name) FIRST, read what it returns, and follow it".
+ * I'll…` for 83 seconds, and later `` `, `bootstrap-api-service.mjs` — add … `` — both the tail of
+ * a sentence whose head had been cut away. The main cause is fixed where it happened (a heartbeat
+ * splitting the thought, see the fence handling in gu-repl.mjs); this is the guard for every other
+ * way a line can arrive headless (a poll boundary, a buffer cap): a line that opens with closing
+ * punctuation, or with a lower-case word, is the middle of something. Start at the next sentence
+ * instead — and when there is none, say nothing ("" keeps whatever the line showed before).
+ */
+const _SENTENCE_END = /[.!?]["'”’`)\]]*\s+(?=["'“‘`(\[]?[A-Z0-9])/g;
+
+export function thoughtLineStart(line) {
+  const s = String(line ?? "").trim();
+  if (!s) return "";
+  const headless =
+    /^[`'"”’)\]}]*\s*[,.;:!?)\]}]/.test(s) || // "`, `bootstrap…", ", and then", ") so"
+    /^[a-z]/.test(s);                          // "one, call use_skill…" — a sentence starts with a capital
+  if (!headless) return s;
+  _SENTENCE_END.lastIndex = 0;
+  const m = _SENTENCE_END.exec(s);
+  return m ? s.slice(m.index + m[0].length).trim() : "";
+}
+
+/**
+ * gu's OWN INSTRUCTIONS, recited (task #333). A model weighing its prompt quotes it — "Rules say
+ * call use_skill FIRST when the task matches" — and the status line then shows gu's scaffolding as
+ * if it were news about the user's task. Matched by the fixed phrases of the prompt blocks the
+ * worker writes (gu_skills.prompt_block, the workspace directives); a sentence carrying one is
+ * not shown on the live line.
+ */
+const _PROMPT_ECHO = /use_skill\(name\)|call use_skill\b[^.]*\bFIRST\b|When the TASK matches|WORK LIKE A SENIOR DEVELOPER|packaged instructions for particular kinds of work/i;
+
+/** Split prose into sentences, keeping each one's own punctuation. */
+function _sentences(text) {
+  const s = String(text ?? "").trim();
+  const out = [];
+  let from = 0;
+  _SENTENCE_END.lastIndex = 0;
+  let m;
+  while ((m = _SENTENCE_END.exec(s))) {
+    out.push(s.slice(from, m.index + m[0].length).trim());
+    from = m.index + m[0].length;
+  }
+  if (from < s.length) out.push(s.slice(from).trim());
+  return out.filter(Boolean);
+}
+
+/** The line to show live: from its first real sentence, past any recital of gu's own prompt. */
+export function liveThoughtText(line) {
+  const sentences = _sentences(thoughtLineStart(line));
+  const at = sentences.findIndex((x) => !_PROMPT_ECHO.test(x));
+  return at < 0 ? "" : sentences.slice(at).join(" ");
+}
+
+/**
+ * THE QUESTION, SAID BACK (task #333). A thought that opens "The user wants me to use the .env
+ * file and add a template file." sits directly under ">> currently we are not using the .env
+ * file, please use that and also add a template file" — the same thing twice, and on the two
+ * collapsed rows that are all most people read. Measured on this machine's stored turns: 169 of
+ * 296 first thoughts (57%) open this way.
+ *
+ * Leading sentences that restate are dropped; what the model said NEXT — what it will look at,
+ * what it found — becomes the block's first row. Two tests, either is enough: the sentence is
+ * shaped like a restatement ("The user wants/says/asks…", "Let me understand the task"), or most
+ * of its words are the question's own. Only from the START, and never the whole thought: when
+ * every sentence restates, the last one is kept, so a thought is shortened, not lost.
+ * Display only — what the model wrote, and what is sent back to it, are untouched.
+ */
+const _RESTATE_SHAPE = /^(?:(?:ok(?:ay)?|so|alright|right|now|first)[,.]?\s+)*(?:let me (?:first\s+)?(?:understand|re-?read|restate|parse|break down|think about)\b[^.]*\b(?:task|request|question|ask)|the user(?:'s (?:request|question|task|message))?\s+(?:wants?|says?|said|is asking|asks?|asked|would like|needs?|is|has asked|requests?)|the (?:task|request|question)(?:\s+is)?\s*[:,]|(?:the )?user (?:request|query|message)\s*[:,]|the (?:system prompt|instructions?|rules?|skill)\s+(?:says?|tells?|states?|wants?|requires?)|(?:rules?|instructions?) say\b)/i;
+
+const _words = (t) => String(t ?? "").toLowerCase().match(/[a-z0-9_.-]{3,}/g) ?? [];
+
+/** Is this ONE sentence the question (or gu's instructions) said back? */
+export function isRestatement(sentence, question = "") {
+  if (_RESTATE_SHAPE.test(sentence)) return true;
+  const asked = new Set(_words(question));
+  if (asked.size < 4) return false;
+  const w = _words(sentence);
+  if (w.length < 4) return false;
+  return w.filter((x) => asked.has(x)).length / w.length >= 0.7;
+}
+
+export function dropRestatement(prose, question = "") {
+  const sentences = _sentences(prose);
+  if (sentences.length < 2) return String(prose ?? "").trim();
+  const restates = (sentence) => isRestatement(sentence, question);
+  let at = 0;
+  while (at < sentences.length - 1 && restates(sentences[at])) at++;
+  return sentences.slice(at).join(" ");
+}
+
 /**
  * Raw in-fence stream → a short, meaningful status: a real Thought clause if the model wrote
  * one, else a label naming the tool it is calling, else "" (the caller shows "Thinking…").
  */
-export function normalizeThought(buf) {
+export function normalizeThought(buf, { question = null } = {}) {
   const t = String(buf || "");
   const ci = t.search(/<code[\s>]/i);
   const head = ci >= 0 ? t.slice(0, ci) : t;
@@ -2455,7 +2548,24 @@ export function normalizeThought(buf) {
     .map((x) => x.trim())
     .find(Boolean);
   const proseIsClause = !!prose && prose.length >= 6 && prose.trim().split(/\s+/).length >= 2;
-  if (proseIsClause && !_thoughtLooksCodey(prose)) return prose.slice(0, 100);
+  if (proseIsClause && !_thoughtLooksCodey(prose)) {
+    // …from where a sentence starts, and never gu's own prompt said back (#333). A line with
+    // nothing left falls through to the tool label / "", like any other non-thought.
+    //
+    // WITH THE QUESTION KNOWN (the terminal passes it), the line is taken from the whole head
+    // rather than its first line, minus the question said back: "The user wants me to read
+    // package.json…" sat on the status row for the whole wait while the next sentence — what
+    // the model was actually about to do — was already there. While all there is so far IS the
+    // restatement, nothing is shown: the row keeps "Thinking" for the second that takes.
+    let text = prose;
+    if (question !== null) {
+      const whole = head.replace(/^\s*Thought:\s*/i, "").replace(/\s+/g, " ").trim();
+      text = dropRestatement(whole, question);
+      if (isRestatement(text, question)) text = "";
+    }
+    const shown = liveThoughtText(text);
+    if (shown.length >= 6 && shown.split(/\s+/).length >= 2) return shown.slice(0, 100);
+  }
   // 2) otherwise name the tool being called (from the code part).
   const codePart = ci >= 0 ? t.slice(ci) : t;
   const call = firstToolArg(codePart);
@@ -2586,6 +2696,65 @@ export function runningDetailRows(detail, { width = 80, indent = 5, maxRows = 2
   ];
 }
 
+/**
+ * THE COMMAND THAT IS RUNNING, on the live status row (task #331): "$ find . -type f … (17s · 5 lines)".
+ *
+ * It used to read "Running <first 70 characters>… (17s)" with every newline squashed to a space,
+ * so a heredoc was one run-on line and a long pipeline stopped mid-flag. Now: the shell's "$", the
+ * command's FIRST LINE (a heredoc's first line is what names it), and at the right what the user
+ * is waiting to learn — how long it has run and how much it has printed.
+ *
+ * ONE ROW, ALWAYS — the status block is redrawn in place and a taller block moves the input line.
+ * The rest of the command is a click (or Ctrl+T) away: see runningCommandRows. → { label, more }
+ * `more` = there is more of the command than this row shows, i.e. the click has something to open.
+ */
+export function runningCommandLabel(command, { room = 66, secs = 0, lines = 0, expanded = false } = {}) {
+  const all = String(command ?? "").replace(/\r/g, "").split("\n").map((l) => l.replace(/\t/g, "  ").replace(/\s+$/, "")).filter((l) => l.trim());
+  const n = Math.max(0, Number(lines) || 0);
+  const suffix = `(${Math.max(0, secs | 0)}s${n ? ` · ${n} line${n === 1 ? "" : "s"}` : ""})`;
+  const multi = all.length > 1;
+  // opened: the rows underneath ARE the command, so the row above them just says what they are
+  if (expanded) return { label: `Running command  ${suffix}`, more: true };
+  const head = `$ ${(all[0] ?? "").trim()}`;
+  const space = Math.max(8, (room | 0) - suffix.length - 2);
+  const cut = head.length + (multi ? 2 : 0) > space;
+  const shown = cut ? head.slice(0, Math.max(1, space - 1)).replace(/\s+$/, "") + "…" : head + (multi ? " …" : "");
+  return { label: `${shown}  ${suffix}`, more: cut || multi };
+}
+
+/**
+ * The whole command, opened under the status row: "└ $ …" with a hanging indent, its own line
+ * breaks kept (a heredoc reads as the script it is), long lines wrapped at a space, and a cap —
+ * past it the last row ends in "…". Rows NEVER exceed `width`: the block is redrawn by walking
+ * physical rows, and a row that wraps on its own breaks every row under it (#109, #138).
+ */
+export function runningCommandRows(command, { width = 76, maxRows = 5 } = {}) {
+  const lead = "└ $ ";
+  const pad = " ".repeat(lead.length);
+  const room = Math.max(12, (width | 0) - lead.length);
+  const out = [];
+  for (const raw of String(command ?? "").replace(/\r/g, "").split("\n")) {
+    let rest = raw.replace(/\t/g, "  ").replace(/\s+$/, "");
+    if (!rest.trim()) continue;
+    while (rest.length > room) {
+      const sp = rest.lastIndexOf(" ", room);
+      // …but never break inside the leading indentation, or a wrapped line loses its shape
+      const cut = sp > room * 0.5 ? sp : room;
+      out.push(rest.slice(0, cut));
+      rest = rest.slice(cut).replace(/^ /, "");
+    }
+    out.push(rest);
+  }
+  if (!out.length) return [];
+  const cap = Math.max(1, maxRows | 0);
+  const rows = out.slice(0, cap);
+  if (out.length > cap) {
+    const last = rows[cap - 1];
+    rows[cap - 1] = (last.length >= room ? last.slice(0, room - 1) : last) + "…";
+  }
+  return rows.map((r, i) => (i ? pad : lead) + r);
+}
+
 /**
  * How long the turn took, for the line above the answer (task #178).
  *