@noobdemon/noob-cli 1.12.1 → 1.12.3

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