@noobdemon/noob-cli 1.12.3 → 1.12.5

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 Tất cả thay đổi đáng kể của `@noobdemon/noob-cli` được ghi vào file này.
 
+## [1.12.5] - 2026-06-12
+
+### Added
+- **Rule VERIFY-BEFORE-DISMISS** (`src/agent.js` SYSTEM + `noob.md` Rules): chống over-confidence ngược chiều với ANTI-HALLUCINATION. Model trước đây gặp TOOL RESULT trông lạ (output từ phiên cũ, lệnh không khớp) là tự phán "giả/noise/injection" rồi bỏ qua — cùng bản chất hallucination success (thay evidence bằng memory). Giờ default = tin runtime, nghi ngờ bản thân: thấy result lạ → coi như THẬT → chạy 1 tool xác minh (`read_file`/`grep`/`list_dir`/re-run) → chỉ khi tool xác minh MÂU THUẪN mới được gọi stale, và làm việc theo kết quả MỚI.
+
+## [1.12.4] - 2026-06-12
+
+### Fixed
+- **Bảng markdown không render khi stream** (`src/repl.js`): fix `1.12.3` chỉ áp dụng cho path NON-STREAM (`printAnswer` → `renderMarkdown`). Khi stream từng dòng qua `makeStreamPrinter`, mỗi dòng render độc lập qua `renderStreamLine` (chỉ hiểu heading + inline) → bảng `| ... |` đi raw ra terminal. Giờ thêm `renderStreamBlock(lines, fenceState)` export, detect table bằng cặp header-row + separator regex `TABLE_SEP_RE` (`/^\s*\|?\s*:?-{3,}:?\s*(\|\s*:?-{3,}:?\s*)+\|?\s*$/`), gom các row liên tiếp → 1 call `renderMarkdown`. `flushCompleteLines` HOLD các dòng cuối là table-row/sep candidate (max 64 dòng) để chờ đủ data — nếu flush ngay khi gặp `\n` thì header bị emit trước, separator đến sau không gom được. Cả `push(beforeTool)` và `flush()` cũng route qua `renderStreamBlock`. Code fence vẫn bypass ưu tiên cao nhất. Smoke `scripts/smoke-table-stream2.mjs` 5/5 PASS (table đơn, prose+table+prose, no-table regression, code fence bypass, false-positive pipe in prose).
+
 ## [1.12.3] - 2026-06-12
 
 ### Fixed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noobdemon/noob-cli",
-  "version": "1.12.3",
+  "version": "1.12.5",
   "publishConfig": {
     "access": "public"
   },

package/src/agent.js

@@ -36,6 +36,7 @@ Context is finite. Don't slurp the whole repo up front. Discover information pro
 # Rules
 - TODO-BASED EXECUTION: For multi-step tasks, you MUST keep going until ALL items are "- [x]". NEVER stop mid-list. Flow: (1) write todo list, (2) start first item, (3) after EVERY tool result, check off the completed item AND IMMEDIATELY start the next unchecked item, (4) repeat until all done. Your response is NOT finished until ALL items are checked. The ONLY valid reason to stop is: (a) all items done, or (b) you are WAITING for a user reply. If you just got a tool result, you MUST continue — do NOT output a summary, do NOT ask "what next", do NOT stop. After write_file/edit_file returns, immediately do the next item.
 - GROUND TRUTH = real TOOL RESULTs in this conversation, not your memory or what you intended to do. A file changed only if a write_file/edit_file result confirms it (see the FILES CHANGED list). A test passed / build succeeded / command worked only if a run_command result above shows it. Never narrate outcomes you didn't observe; if you haven't checked, say so and check now (read_file / list_dir / run the command). Before any "done/summary" reply, reconcile every file and result you're about to claim against the actual tool results above — if it isn't there, you didn't do it yet.
+- VERIFY BEFORE DISMISSING: never declare a TOOL RESULT "fake", "spurious", "injected", "unrelated", or "from a previous turn" without first verifying with a fresh tool call. If a result looks off (unexpected content, output you didn't ask for, weird command), your DEFAULT is: treat it as REAL runtime output, then run a small verification (read_file the affected path, grep for the symbol, list_dir, re-run the command) to confirm actual state. Only after the verification tool result contradicts the suspicious one may you call it stale/leftover — and even then, work from the FRESH result, never from your guess. Trusting your own skepticism over the runtime is the same over-confidence bug as hallucinating success: both substitute memory for evidence.
 - Investigate before editing: read the relevant files first; never invent file contents.
 - Make the smallest change that fully solves the task. Match the surrounding code style.
 - Prefer edit_file over write_file for existing files.

package/src/repl.js

@@ -2138,12 +2138,69 @@ function printAnswer(text, name, color) {
 //   - Trên dòng đang dở (chưa thấy \n), giữ trong buffer; cuối cùng `flush()` xử lý.
 //   - Block code fence (```lang ... ```) bypass renderer: in nguyên xi giữa cặp ```.
 //   - ```tool trở đi: nuốt sạch (sẽ render riêng qua tool dispatcher).
+//   - Bảng markdown (header + separator |---|) cần parse đa dòng → gom thành
+//     table block, render qua marked.parse() 1 lần (renderStreamBlock).
+//     QUAN TRỌNG: stream line-by-line không tương thích với block elements
+//     đa dòng — flushCompleteLines phải HOLD các dòng cuối là table-row/sep
+//     candidate để chờ đủ data trước khi parse.
 function renderStreamLine(line, inCodeFence) {
   if (inCodeFence) return line; // code fence body: in raw, không parse markdown.
   const heading = renderHeadingLine(line);
   if (heading !== null) return heading;
   return renderInline(renderBulletPrefix(line));
 }
+// Dòng separator của bảng markdown: |---|---| hoặc |:---:|---:| v.v.
+const TABLE_SEP_RE = /^\s*\|?\s*:?-{3,}:?\s*(\|\s*:?-{3,}:?\s*)+\|?\s*$/;
+// Dòng có ít nhất 1 pipe ở giữa (không tính pipe đầu/cuối) → ứng viên row của bảng.
+function looksLikeTableRow(line) {
+  const trimmed = line.trim();
+  if (!trimmed.startsWith('|') && !trimmed.includes('|')) return false;
+  // Cần ít nhất 1 ký tự `|` thực sự phân tách cột.
+  const stripped = trimmed.replace(/^\|/, '').replace(/\|$/, '');
+  return stripped.includes('|');
+}
+// Render block lines (mảng dòng KHÔNG có \n cuối) thành ANSI. Detect table block
+// và parse qua marked; phần còn lại render line-by-line như cũ.
+export function renderStreamBlock(lines, fenceState) {
+  const out = [];
+  let i = 0;
+  while (i < lines.length) {
+    const ln = lines[i];
+    // Code fence ưu tiên cao nhất — không đụng vào nội dung fence.
+    const fenceMatch = ln.match(/^\s*```/);
+    if (fenceMatch) {
+      out.push(renderStreamLine(ln, fenceState.inCodeFence));
+      fenceState.inCodeFence = !fenceState.inCodeFence;
+      i++;
+      continue;
+    }
+    if (fenceState.inCodeFence) {
+      out.push(ln);
+      i++;
+      continue;
+    }
+    // Detect table: dòng hiện tại là row + dòng kế tiếp là separator.
+    if (
+      looksLikeTableRow(ln) &&
+      i + 1 < lines.length &&
+      TABLE_SEP_RE.test(lines[i + 1])
+    ) {
+      // Gom hết các dòng row liên tiếp.
+      const tableLines = [ln, lines[i + 1]];
+      let j = i + 2;
+      while (j < lines.length && looksLikeTableRow(lines[j])) {
+        tableLines.push(lines[j]);
+        j++;
+      }
+      out.push(renderMarkdown(tableLines.join('\n')));
+      i = j;
+      continue;
+    }
+    out.push(renderStreamLine(ln, false));
+    i++;
+  }
+  return out.join('\n');
+}
 function makeStreamPrinter(name, color) {
   let buf = ''; // toàn bộ delta đã nhận (chưa cắt)
   let printed = 0; // offset đã in trong buf
@@ -2164,28 +2221,36 @@ function makeStreamPrinter(name, color) {
   };
   // Render & emit từ printed → end. Chỉ flush các dòng đã HOÀN CHỈNH (có \n).
   // Dòng cuối chưa có \n: chừa lại trong buf cho lần push tiếp theo.
+  // Lùi mốc flush nếu các dòng cuối là table-row/separator candidate — chờ đủ
+  // data để gom thành table block parse 1 lần qua marked (xem renderStreamBlock).
   const flushCompleteLines = (end) => {
     const slice = buf.slice(printed, end);
     if (!slice) return;
     const lastNl = slice.lastIndexOf('\n');
-    if (lastNl === -1) return; // chưa có dòng nào hoàn chỉnh trong khoảng này
-    const complete = slice.slice(0, lastNl + 1); // bao gồm \n cuối
-    printed += lastNl + 1;
-    // Render từng dòng (split giữ \n)
-    const lines = complete.split('\n');
-    // split với chuỗi kết thúc \n → mảng cuối là '' — bỏ qua
-    const rendered = lines.map((ln, i) => {
-      if (i === lines.length - 1 && ln === '') return '';
-      // Toggle code fence khi gặp ``` ở đầu dòng (allow indent).
-      const fenceMatch = ln.match(/^\s*```/);
-      if (fenceMatch) {
-        const out = renderStreamLine(ln, inCodeFence);
-        inCodeFence = !inCodeFence;
-        return out;
-      }
-      return renderStreamLine(ln, inCodeFence);
-    }).join('\n');
-    emit(rendered);
+    if (lastNl === -1) return;
+    let complete = slice.slice(0, lastNl + 1);
+    let completeLines = complete.split('\n');
+    if (completeLines[completeLines.length - 1] === '') completeLines.pop();
+    let hold = 0;
+    while (
+      completeLines.length - hold > 0 &&
+      (looksLikeTableRow(completeLines[completeLines.length - 1 - hold]) ||
+        TABLE_SEP_RE.test(completeLines[completeLines.length - 1 - hold]))
+    ) {
+      hold++;
+      if (hold > 64) break;
+    }
+    if (hold > 0) {
+      const keptLines = completeLines.slice(0, completeLines.length - hold);
+      if (keptLines.length === 0) return; // toàn bộ slice là table candidate → chờ
+      complete = keptLines.join('\n') + '\n';
+      completeLines = keptLines;
+    }
+    printed += complete.length;
+    const fenceState = { inCodeFence };
+    const rendered = renderStreamBlock(completeLines, fenceState);
+    inCodeFence = fenceState.inCodeFence;
+    emit(rendered + '\n');
   };
   return {
     get started() {
@@ -2203,17 +2268,12 @@ function makeStreamPrinter(name, color) {
         // vì sắp suppress, không cần chừa buffer nữa).
         const beforeTool = buf.slice(printed, f);
         if (beforeTool) {
-          // Render từng dòng kể cả dòng dở cuối
           const parts = beforeTool.split('\n');
-          const rendered = parts.map((ln) => {
-            const fenceMatch = ln.match(/^\s*```/);
-            if (fenceMatch) {
-              const out = renderStreamLine(ln, inCodeFence);
-              inCodeFence = !inCodeFence;
-              return out;
-            }
-            return renderStreamLine(ln, inCodeFence);
-          }).join('\n');
+          // bỏ '' cuối nếu kết thúc bằng \n
+          if (parts[parts.length - 1] === '') parts.pop();
+          const fenceState = { inCodeFence };
+          const rendered = renderStreamBlock(parts, fenceState);
+          inCodeFence = fenceState.inCodeFence;
           emit(rendered);
         }
         printed = buf.length;
@@ -2229,16 +2289,10 @@ function makeStreamPrinter(name, color) {
         // Render phần còn lại (kể cả dòng cuối chưa có \n).
         const tail = buf.slice(printed);
         const parts = tail.split('\n');
-        const rendered = parts.map((ln, i) => {
-          // Toggle fence
-          const fenceMatch = ln.match(/^\s*```/);
-          if (fenceMatch) {
-            const out = renderStreamLine(ln, inCodeFence);
-            inCodeFence = !inCodeFence;
-            return out;
-          }
-          return renderStreamLine(ln, inCodeFence);
-        }).join('\n');
+        if (parts[parts.length - 1] === '') parts.pop();
+        const fenceState = { inCodeFence };
+        const rendered = renderStreamBlock(parts, fenceState);
+        inCodeFence = fenceState.inCodeFence;
         emit(rendered);
         printed = buf.length;
       }