@noobdemon/noob-cli 1.12.0 → 1.12.2

package/src/repl/agent-dispatch.js

@@ -0,0 +1,168 @@
+// Agent tool dispatcher — xử lý spawn_agent / spawn_agents (sub-agent recursion +
+// workflow journal cache) hoặc forward sang execTool cho các tool thường.
+//
+// Tách khỏi src/repl.js (v1.12.x) để:
+//   - giảm closure-coupling trong startRepl (rule noob.md "pure logic tách khỏi
+//     closure để testable")
+//   - smoke test 6 nhánh chính bằng mock thay vì E2E spawn process
+//
+// Pattern dùng: factory createAgentDispatcher(deps) trả về function dispatchTool.
+// Factory được gọi MỖI turn trong handle() vì abort/printer được rebind theo turn —
+// không cache singleton ở scope startRepl.
+
+import chalk from 'chalk';
+import { runSubAgent as defaultRunSubAgent, MAX_SUBAGENT_DEPTH } from '../subagent.js';
+import { findModel as defaultFindModel } from '../models.js';
+import * as defaultJournal from '../workflow-runs.js';
+import { t } from '../i18n.js';
+
+/**
+ * Tạo dispatcher cho 1 turn agent.
+ *
+ * @param {object} deps
+ * @param {object} deps.state          — state object (cần state.agentMode, state.model, state.workflowRun)
+ * @param {AbortController} deps.abort — controller hiện tại của turn (đọc abort.signal)
+ * @param {object} deps.tokenMeter     — TokenMeter instance, forward xuống sub-agent
+ * @param {function} deps.stopSpin     — dừng spinner UI trước khi log
+ * @param {function} deps.startSpin    — khởi động lại spinner sau log
+ * @param {function} deps.execTool     — async (name, input) → {allow, result} cho tool thường
+ * @param {function} [deps.runSubAgent]  — (chỉ dùng cho test) override sub-agent runner
+ * @param {function} [deps.findModel]    — (chỉ dùng cho test) override model resolver
+ * @param {object}   [deps.journal]      — (chỉ dùng cho test) override workflow journal helpers
+ * @returns {function} dispatchTool(name, input, depth=0) → {allow, result}
+ */
+export function createAgentDispatcher(deps) {
+  const { state, abort, tokenMeter, stopSpin, startSpin, execTool } = deps;
+  // Test injection points: production luôn dùng default; smoke test pass mock.
+  const runSubAgent = deps.runSubAgent || defaultRunSubAgent;
+  const findModel = deps.findModel || defaultFindModel;
+  const j = deps.journal || defaultJournal;
+  const hashWorkflowTask = j.hashTask;
+  const lookupWorkflowTaskResult = j.lookupTaskResult;
+  const recordWorkflowTaskStart = j.recordTaskStart;
+  const recordWorkflowTaskDone = j.recordTaskDone;
+  const recordWorkflowTaskFailed = j.recordTaskFailed;
+
+  const dispatchTool = async (name, input, depth = 0) => {
+    // spawn_agent / spawn_agents chỉ được phép khi agentMode bật; depth giới hạn
+    // bởi MAX_SUBAGENT_DEPTH để tránh đệ quy nổ.
+    if (name === 'spawn_agent' || name === 'spawn_agents') {
+      if (!state.agentMode)
+        return {
+          allow: true,
+          result: 'ERROR: agent mode đang TẮT — gõ /agent on để bật trước khi spawn.',
+        };
+      if (depth >= MAX_SUBAGENT_DEPTH)
+        return {
+          allow: true,
+          result: `ERROR: đã đạt depth tối đa (${MAX_SUBAGENT_DEPTH}) — không spawn thêm.`,
+        };
+      const tasks =
+        name === 'spawn_agent' ? [input] : Array.isArray(input?.agents) ? input.agents : [];
+      if (!tasks.length) return { allow: true, result: 'ERROR: thiếu task cho sub-agent.' };
+      stopSpin();
+      console.log(
+        chalk.hex('#8b5cf6')(
+          `  ⊕ spawn ${tasks.length} sub-agent (depth ${depth + 1}/${MAX_SUBAGENT_DEPTH})`
+        )
+      );
+      startSpin(t.thinking);
+      try {
+        const runData = state.workflowRun?.data || null;
+        const results = await Promise.all(
+          tasks.map((task, i) => {
+            // Per-sub-agent model routing: task.model có thể là id model hoặc tên thân thiện.
+            // findModel() resolve cả hai; nếu không match thì fallback model của cha.
+            let subModel = state.model.id;
+            let modelTag = '';
+            if (task?.model) {
+              const m = findModel(task.model);
+              if (m) {
+                subModel = m.id;
+                modelTag = ` [${m.name}]`;
+              } else
+                modelTag = ` [model "${task.model}" không khớp — dùng ${state.model.name}]`;
+            }
+            const taskBody = task?.task || task?.prompt || '';
+            const taskCtx = task?.context || '';
+            // Workflow journal: nếu đang trong run + task đã done lần trước → return
+            // cached result, tiết kiệm token. Hash = crc32(task+ctx+model).
+            if (runData) {
+              const hash = hashWorkflowTask({ task: taskBody, context: taskCtx, model: subModel });
+              const cached = lookupWorkflowTaskResult(runData, hash);
+              if (cached !== null) {
+                stopSpin();
+                console.log(
+                  chalk.hex('#8b5cf6')(
+                    `  ⊘ sub-agent #${i + 1}${modelTag} skip — đã done trong run trước (cached)`
+                  )
+                );
+                startSpin(t.thinking);
+                return Promise.resolve(
+                  `── sub-agent #${i + 1}${modelTag} (cached) ──\n${cached}`
+                );
+              }
+              recordWorkflowTaskStart(runData, {
+                hash,
+                task: taskBody,
+                context: taskCtx,
+                model: subModel,
+              });
+              // [GỠ BUDGET 2026-06-06] Sub-agent chạy không giới hạn token.
+              return runSubAgent({
+                task: taskBody,
+                context: taskCtx,
+                depth: depth + 1,
+                model: subModel,
+                signal: abort.signal,
+                tokenMeter,
+                dispatchTool: (n, inp) => dispatchTool(n, inp, depth + 1),
+                onLog: (msg) => {
+                  stopSpin();
+                  console.log(chalk.hex('#8b5cf6')('  ' + msg + modelTag));
+                  startSpin(t.thinking);
+                },
+              })
+                .then((r) => {
+                  recordWorkflowTaskDone(runData, hash, r);
+                  return `── sub-agent #${i + 1}${modelTag} ──\n${r}`;
+                })
+                .catch((e) => {
+                  recordWorkflowTaskFailed(runData, hash, e);
+                  return `── sub-agent #${i + 1}${modelTag} (LỖI) ──\n${e?.message || String(e)}`;
+                });
+            }
+            // Không có active workflow run → behavior cũ.
+            return runSubAgent({
+              task: taskBody,
+              context: taskCtx,
+              depth: depth + 1,
+              model: subModel,
+              signal: abort.signal,
+              tokenMeter,
+              dispatchTool: (n, inp) => dispatchTool(n, inp, depth + 1),
+              onLog: (msg) => {
+                stopSpin();
+                console.log(chalk.hex('#8b5cf6')('  ' + msg + modelTag));
+                startSpin(t.thinking);
+              },
+            })
+              .then((r) => `── sub-agent #${i + 1}${modelTag} ──\n${r}`)
+              .catch(
+                (e) => `── sub-agent #${i + 1}${modelTag} (LỖI) ──\n${e?.message || String(e)}`
+              );
+          })
+        );
+        return { allow: true, result: results.join('\n\n') };
+      } catch (err) {
+        return { allow: true, result: 'ERROR sub-agent: ' + (err?.message || String(err)) };
+      }
+    }
+    stopSpin();
+    const res = await execTool(name, input);
+    startSpin(t.thinking);
+    return res;
+  };
+
+  return dispatchTool;
+}

package/src/repl/permission.js

@@ -20,30 +20,42 @@
 //   - truncate: helper cắt chuỗi dài.
 
 /**
- * Hỏi quyền chung cho 1 tool call. Trả về 'y' | 'n' | 'a'.
- * 'a' = auto-approve mọi lần gọi tool name này trong phiên còn lại.
+ * Hỏi quyền chung cho 1 tool call. Trả về 'y' | 'n' | 'a' | 't' | 'f'.
+ *   'y' = đồng ý lần này
+ *   'n' = từ chối
+ *   'a' = always — auto-approve tool này tới hết phiên
+ *   't' = this turn — auto-approve tool này tới hết turn hiện tại
+ *   'f' = this file — auto-approve mọi tool destructive trên path này tới hết phiên
+ *         (chỉ hiện khi có `targetPath`, vd edit_file/write_file)
+ *
+ * `targetPath` (optional) = path file đang bị thao tác — nếu có, hiện kèm option `f`.
  */
-export async function askPermission(name, { tui, ask, pending, c, t, truncate }) {
+export async function askPermission(name, { tui, ask, pending, c, t, truncate, targetPath } = {}) {
   tui.setBusy(false);
-  console.log(
-    c.tool('  ⏸ Cần quyền: ' + name) +
-      c.dim(' — gõ y (đồng ý) / n (từ chối) / a (luôn cho phép)')
-  );
+  const hasFile = typeof targetPath === 'string' && targetPath.length > 0;
+  const headerHint = hasFile
+    ? ' — y (đồng ý) / n (từ chối) / a (luôn cho phép) / t (turn này) / f (file này)'
+    : ' — y (đồng ý) / n (từ chối) / a (luôn cho phép) / t (turn này)';
+  console.log(c.tool('  ⏸ Cần quyền: ' + name) + c.dim(headerHint));
+  if (hasFile) console.log(c.dim('    file: ' + targetPath));
+  const promptHint = hasFile
+    ? '[y] có / [n] không / [a] luôn ' + name + ' / [t] hết turn / [f] file này › '
+    : '[y] có / [n] không / [a] luôn ' + name + ' / [t] hết turn › ';
   try {
     while (true) {
-      const raw = await ask(
-        c.tool('  cho phép? ') + c.dim('[y] có / [n] không / [a] luôn ' + name + ' › ')
-      );
+      const raw = await ask(c.tool('  cho phép? ') + c.dim(promptHint));
       if (raw == null) return 'n';
       const a = raw.trim().toLowerCase();
       if (a === '' || a === 'y' || a === 'yes' || a === 'có') return 'y';
       if (a === 'n' || a === 'no' || a === 'không') return 'n';
       if (a === 'a' || a === 'always' || a === 'luôn') return 'a';
+      if (a === 't' || a === 'turn') return 't';
+      if (hasFile && (a === 'f' || a === 'file')) return 'f';
       if (raw.trim().length > 3) {
         pending.push(raw);
         console.log(c.dim('  ' + t.queued(pending.length, truncate(raw, 60))));
       }
-      console.log(c.dim('  ' + t.permRetry));
+      console.log(c.dim('  ' + (t.permRetryExtended || t.permRetry)));
     }
   } finally {
     tui.setBusy(true, t.thinking);

package/src/repl/state.js

@@ -19,7 +19,9 @@ export function createState(opts = {}, config) {
     model: findModel(opts.model) || findModel(config.model) || findModel(DEFAULT_MODEL),
     mode: 'chat', // chat | merge | search
     history: [],
-    autoApprove: new Set(),
+    autoApprove: new Set(), // tool name → 'a' (always, phiên)
+    autoApproveTurn: new Set(), // tool name → 't' (this turn, reset sau mỗi runAgent)
+    autoApproveFile: new Set(), // 'name:absPath' → 'f' (this file, phiên)
     yolo: !!opts.yolo || config.yoloDefault,
     ultra: false, // /ultra chế độ tự hành đang chạy
     agentMode: false, // /agent on → cho phép spawn_agent / spawn_agents

package/src/repl/todos.js

@@ -1,38 +1,79 @@
-// Parse danh sách todo từ history hội thoại. Scan các assistant message tìm
-// pattern markdown `- [ ] task` và `- [x] task` (case-insensitive cho dấu x).
-// Pure function: chỉ phụ thuộc input `history`, không closure state.
+// Parse danh sách todo từ history hội thoại.
 //
-// Dedupe: nếu cùng một text xuất hiện nhiều lần (model lặp todo qua các lượt),
-// giữ trạng thái CUỐI cùng — phản ánh state hiện tại của model.
+// Quan trọng: chỉ parse list todo CUỐI cùng — assistant message GẦN NHẤT có
+// ít nhất 1 dòng `- [ ]` hoặc `- [x]` được coi là "todo list hiện tại". Mọi
+// message trước đó bị bỏ qua.
+//
+// Lý do: trước đây scan toàn lịch sử rồi dedupe theo text → todo từ task CŨ
+// vẫn đếm vào progress bar dù model đã chuyển sang task mới. Triệu chứng:
+// bar 5/10 nhưng reply mới nhất chỉ có 3 todo. Cách mới tự nhiên reset khi
+// model viết todo list mới, không bao giờ trộn todo từ 2 task khác nhau.
+//
+// Edge case đã xử lý:
+//   - Code fence ``` (cả với info string như ```md): bỏ qua dòng bên trong,
+//     tránh paste README/snippet có checkbox bị parser bắt nhầm thành todo.
+//   - Cả `[x]` và `[X]` (viết hoa) đều coi là done.
+//   - Multi-line message lặp cùng todo text: giữ trạng thái CUỐI.
+//
+// Pure function: chỉ phụ thuộc input `history`.
 
 /**
  * @typedef {{ text: string, done: boolean }} TodoItem
  */
 
+// Regex tách riêng cho rõ ràng + dễ test. Cả 2 dùng cờ `i` để chấp nhận `[X]`
+// (viết hoa) — markdown checkbox không phân biệt hoa thường trong thực tế.
+const RE_DONE = /^\s*-\s*\[x\]\s+(.+)/i;
+const RE_TODO = /^\s*-\s*\[\s?\]\s+(.+)/i;
+// Code fence: ``` đầu dòng, có thể kèm info string (vd ```js, ```md).
+const RE_FENCE = /^\s*```/;
+
 /**
- * Trích todo list từ history.
- * @param {Array<{role: string, content: any}>} history
+ * Parse các dòng todo trong 1 message content. Trả về [] nếu không có dòng nào.
+ * - Bỏ qua dòng nằm trong code fence (``` ... ```).
+ * - Trong cùng 1 message, nếu cùng text xuất hiện 2 lần (vd model lặp khi
+ *   format), giữ trạng thái CUỐI — phản ánh ý định gần nhất.
+ * @param {string} content
  * @returns {TodoItem[]}
  */
-export function parseTodosFromHistory(history) {
-  const todos = [];
-  for (const m of history) {
-    if (m.role !== 'assistant' || typeof m.content !== 'string') continue;
-    const lines = m.content.split('\n');
-    for (const line of lines) {
-      const doneMatch = line.match(/^[\s]*-\s*\[x\]\s+(.+)/i);
-      if (doneMatch) {
-        todos.push({ text: doneMatch[1].trim(), done: true });
-        continue;
-      }
-      const todoMatch = line.match(/^[\s]*-\s*\[\s?\]\s+(.+)/);
-      if (todoMatch) {
-        todos.push({ text: todoMatch[1].trim(), done: false });
-      }
+function parseTodosFromMessage(content) {
+  const out = [];
+  let inFence = false;
+  for (const line of content.split('\n')) {
+    if (RE_FENCE.test(line)) {
+      inFence = !inFence;
+      continue;
     }
+    if (inFence) continue;
+    const m1 = line.match(RE_DONE);
+    if (m1) {
+      out.push({ text: m1[1].trim(), done: true });
+      continue;
+    }
+    const m2 = line.match(RE_TODO);
+    if (m2) out.push({ text: m2[1].trim(), done: false });
   }
-  // Dedupe: giữ item CUỐI cùng cho mỗi text (model có thể lặp todo qua các lượt).
+  // Dedupe trong cùng message: giữ entry CUỐI cho mỗi text. Map<1 entry rẻ
+  // như không có — không cần micro-opt skip khi out.length<=1.
   const seen = new Map();
-  for (const t of todos) seen.set(t.text, t);
+  for (const it of out) seen.set(it.text, it);
   return [...seen.values()];
 }
+
+/**
+ * Trích todo list từ history. Chỉ trả về todo từ assistant message GẦN NHẤT
+ * chứa ít nhất 1 dòng todo. Mọi message trước đó bị bỏ qua.
+ * Bỏ qua message có content kiểu non-string (vd multimodal array) — chưa hỗ trợ.
+ * @param {Array<{role: string, content: any}>} history
+ * @returns {TodoItem[]}
+ */
+export function parseTodosFromHistory(history) {
+  if (!Array.isArray(history)) return [];
+  for (let i = history.length - 1; i >= 0; i--) {
+    const m = history[i];
+    if (!m || m.role !== 'assistant' || typeof m.content !== 'string') continue;
+    const parsed = parseTodosFromMessage(m.content);
+    if (parsed.length) return parsed;
+  }
+  return [];
+}