@fieldwangai/agentflow 0.1.33 → 0.1.35

package/bin/lib/agent-runners.mjs

@@ -711,6 +711,14 @@ function truncateComposerLine(s) {
   return t.slice(0, COMPOSER_STATUS_MAX - 1) + "…";
 }
 
+const RAW_TRACE_MAX_CHARS = 4096;
+
+function rawTraceText(value) {
+  const text = typeof value === "string" ? value : JSON.stringify(value);
+  if (!text) return "";
+  return text.length > RAW_TRACE_MAX_CHARS ? text.slice(0, RAW_TRACE_MAX_CHARS) + "\n...[truncated]" : text;
+}
+
 function normalizeStreamTextChunk(t) {
   if (!t || typeof t !== "string") return "";
   return t.replace(/\\n/g, "\n").replace(/\\t/g, "\t");
@@ -728,6 +736,7 @@ function extractCursorStreamNlText(event) {
   }
   if (typeof event.text === "string" && event.text.trim()) return normalizeStreamTextChunk(event.text);
   if (typeof event.thinking === "string" && event.thinking.trim()) return normalizeStreamTextChunk(event.thinking);
+  if (typeof event.delta === "string" && event.delta.trim()) return normalizeStreamTextChunk(event.delta);
   return "";
 }
 
@@ -864,6 +873,7 @@ export function runCursorAgentWithPrompt(cliWorkspace, promptText, options = {})
     for (const line of lines) {
       try {
         const event = JSON.parse(line);
+        emit({ type: "raw", source: "cursor", stream: "stdout", eventType: event?.type || "unknown", text: rawTraceText(event) });
         if (event.type === "assistant" && event.message?.content) {
           const text = extractCursorStreamNlText(event);
           if (text) {
@@ -903,6 +913,7 @@ export function runCursorAgentWithPrompt(cliWorkspace, promptText, options = {})
           emit({ type: "status", line: `${t("runner.event_label")}: ${event.type ?? "unknown"}` });
         }
       } catch (_) {
+        emit({ type: "raw", source: "cursor", stream: "stdout", eventType: "line", text: rawTraceText(line) });
         if (line.includes('"type":"tool_call"') || line.includes('"type": "tool_call"')) {
           let subtype = "?";
           try {
@@ -1017,6 +1028,7 @@ export function runOpenCodeAgentWithPrompt(cliWorkspace, promptText, options = {
       const line = outBuf.slice(0, idx);
       outBuf = outBuf.slice(idx + 1);
       if (line) {
+        emit({ type: "raw", source: "opencode", stream: "stdout", eventType: "line", text: rawTraceText(line) });
         tryEmitOpenCodeLineAsNatural(line, emit);
         emit({ type: "status", line: `[stdout] ${truncateComposerLine(line)}` });
       }
@@ -1032,6 +1044,7 @@ export function runOpenCodeAgentWithPrompt(cliWorkspace, promptText, options = {
       const line = errBuf.slice(0, idx);
       errBuf = errBuf.slice(idx + 1);
       if (line) {
+        emit({ type: "raw", source: "opencode", stream: "stderr", eventType: "line", text: rawTraceText(line) });
         tryEmitOpenCodeLineAsNatural(line, emit);
         emit({ type: "status", line: `[stderr] ${truncateComposerLine(line)}` });
       }
@@ -1051,10 +1064,12 @@ export function runOpenCodeAgentWithPrompt(cliWorkspace, promptText, options = {
       child.stderr.removeAllListeners();
       child.removeAllListeners();
       if (outBuf.trim()) {
+        emit({ type: "raw", source: "opencode", stream: "stdout", eventType: "tail", text: rawTraceText(outBuf.trim()) });
         tryEmitOpenCodeLineAsNatural(outBuf.trim(), emit);
         emit({ type: "status", line: truncateComposerLine(outBuf.trim()) });
       }
       if (errBuf.trim()) {
+        emit({ type: "raw", source: "opencode", stream: "stderr", eventType: "tail", text: rawTraceText(errBuf.trim()) });
         tryEmitOpenCodeLineAsNatural(errBuf.trim(), emit);
         emit({ type: "status", line: `[opencode_stderr] ${truncateComposerLine(errBuf.trim())}` });
       }
@@ -1151,6 +1166,7 @@ export function runClaudeCodeAgentWithPrompt(cliWorkspace, promptText, options =
     for (const line of lines) {
       try {
         const event = JSON.parse(line);
+        emit({ type: "raw", source: "claude-code", stream: "stdout", eventType: event?.type || "unknown", text: rawTraceText(event) });
         if (event.type === "assistant" && event.message && Array.isArray(event.message.content)) {
           for (const block of event.message.content) {
             if (!block || typeof block !== "object") continue;
@@ -1196,6 +1212,7 @@ export function runClaudeCodeAgentWithPrompt(cliWorkspace, promptText, options =
           emit({ type: "status", line: `${t("runner.event_label")}: ${event.type ?? "unknown"}` });
         }
       } catch (_) {
+        emit({ type: "raw", source: "claude-code", stream: "stdout", eventType: "line", text: rawTraceText(line) });
         emit({ type: "status", line: truncateComposerLine(line) });
       }
     }

package/bin/lib/composer-agent.mjs

@@ -106,6 +106,7 @@ export function buildScriptContentBlockForInstances(flowYamlAbs, instanceIds) {
  * @param {string} [opts.modelKey]
  * @param {boolean} [opts.force]
  * @param {(ev: object) => void} [opts.onStreamEvent]
+ * @param {(subtype: string, toolName: string) => void} [opts.onToolCall]
  * @returns {{ child: import('child_process').ChildProcess, finished: Promise<void> }}
  */
 export function startComposerAgent(opts) {
@@ -123,6 +124,7 @@ export function startComposerAgent(opts) {
 
   const common = {
     onStreamEvent: opts.onStreamEvent,
+    onToolCall: opts.onToolCall,
     force: Boolean(opts.force),
     env,
   };

package/bin/lib/composer-skill-router.mjs

@@ -13,7 +13,11 @@
  */
 import fs from "fs";
 import path from "path";
-import { listSkills as registryListSkills, readSkillDetail as registryReadSkillDetail } from "./skill-registry.mjs";
+import {
+  listSkills as registryListSkills,
+  listUniqueSkills as registryListUniqueSkills,
+  readSkillDetail as registryReadSkillDetail,
+} from "./skill-registry.mjs";
 
 // ─── 意图模式定义 ─────────────────────────────────────────────────────────
 
@@ -126,7 +130,7 @@ function readFileCached(absPath) {
 }
 
 export function listComposerSkills(packageRoot, workspaceRoot) {
-  return registryListSkills(packageRoot, workspaceRoot).map(({ body, content, ...skill }) => skill);
+  return registryListUniqueSkills(packageRoot, workspaceRoot).map(({ body, content, ...skill }) => skill);
 }
 
 export function readComposerSkillDetail(packageRoot, workspaceRoot, keyOrName) {
@@ -140,9 +144,24 @@ export function loadResourcesForSkillKeys(skillKeys, packageRoot, workspaceRoot)
   const wanted = new Set(skillKeys.map((x) => String(x || "").trim()).filter(Boolean));
   if (wanted.size === 0) return { skills: [], references: [], skillsHint: "", hasContext: false };
 
-  const skills = [];
-  for (const item of registryListSkills(packageRoot, workspaceRoot)) {
+  const exactByKey = new Map(registryListSkills(packageRoot, workspaceRoot).map((item) => [item.key, item]));
+  const candidateItems = [];
+  const seenKeys = new Set();
+  for (const item of registryListUniqueSkills(packageRoot, workspaceRoot)) {
     if (!wanted.has(item.key) && !wanted.has(item.name)) continue;
+    candidateItems.push(item);
+    seenKeys.add(item.key);
+  }
+  for (const key of wanted) {
+    const exact = exactByKey.get(key);
+    if (exact && !seenKeys.has(exact.key)) {
+      candidateItems.push(exact);
+      seenKeys.add(exact.key);
+    }
+  }
+
+  const skills = [];
+  for (const item of candidateItems) {
     skills.push({
       id: item.name,
       content: item.body,

package/bin/lib/git-worktree.mjs

@@ -112,6 +112,21 @@ export function resolveGitRepoRoot(repoPath) {
   return path.resolve(gitOrThrow(["rev-parse", "--show-toplevel"], abs, "git rev-parse"));
 }
 
+export function inferGitRepoRootFromWorktree(worktreePath) {
+  const raw = String(worktreePath || "").trim();
+  if (!raw) throw new Error("worktreePath is required");
+  const abs = path.resolve(raw);
+  if (!fs.existsSync(abs) || !fs.statSync(abs).isDirectory()) {
+    throw new Error(`worktreePath directory not found: ${abs}`);
+  }
+  const commonDir = gitOrThrow(["rev-parse", "--git-common-dir"], abs, "git rev-parse common dir");
+  const commonAbs = path.resolve(abs, commonDir);
+  if (path.basename(commonAbs) === ".git") {
+    return path.dirname(commonAbs);
+  }
+  return resolveGitRepoRoot(abs);
+}
+
 export function currentGitBranch(repoRoot) {
   const branch = gitOrThrow(["rev-parse", "--abbrev-ref", "HEAD"], repoRoot, "git rev-parse branch");
   return branch === "HEAD" ? "" : branch;

package/bin/lib/locales/en.json

@@ -238,7 +238,7 @@
       "description": "Continues to next when any upstream input is ready"
     },
     "control_toBool": {
-      "displayName": "To Bool",
+      "displayName": "Code ToBool",
       "description": "Execute script to produce true/false prediction. Like tool_nodejs but enforces bool output. Extensible inputs."
     },
     "control_delay": {
@@ -249,13 +249,9 @@
       "displayName": "Wait Until",
       "description": "Persistently wait until an absolute time, then scheduler resumes this run."
     },
-    "control_deadline": {
-      "displayName": "Deadline",
-      "description": "Check whether the deadline has expired and output expired as bool."
-    },
     "control_cancelled": {
-      "displayName": "Cancelled",
-      "description": "Check whether the current run/watch has been cancelled and output cancelled as bool."
+      "displayName": "Cancel Check",
+      "description": "Check whether the current wait/run has been cancelled and output cancelled as bool."
     },
     "control_interval_loop": {
       "displayName": "Interval Loop",

package/bin/lib/locales/zh.json

@@ -238,7 +238,7 @@
       "description": "当任一上游输入就绪时，沿 next 继续执行"
     },
     "control_toBool": {
-      "displayName": "转布尔",
+      "displayName": "代码转布尔",
       "description": "执行 script 脚本输出 true/false 到 prediction，类似 tool_nodejs 但强制 bool 输出，可扩展输入"
     },
     "control_delay": {
@@ -249,13 +249,9 @@
       "displayName": "等待到时间",
       "description": "持久化等待到指定时间，到点后由 scheduler 唤醒当前 run 继续执行"
     },
-    "control_deadline": {
-      "displayName": "截止判断",
-      "description": "判断当前时间是否已超过截止时间，输出 expired 布尔值"
-    },
     "control_cancelled": {
       "displayName": "取消判断",
-      "description": "判断当前 run/watch 是否已被取消，输出 cancelled 布尔值"
+      "description": "判断当前 wait/run 是否已被取消，输出 cancelled 布尔值"
     },
     "control_interval_loop": {
       "displayName": "间隔循环",

package/bin/lib/paths.mjs

@@ -253,7 +253,6 @@ export const LOCAL_ONLY_DEFINITION_IDS = new Set([
   "control_if",
   "control_delay",
   "control_wait_until",
-  "control_deadline",
   "control_cancelled",
   "control_interval_loop",
   "control_cd_workspace",

package/bin/lib/scheduler.mjs

@@ -136,7 +136,7 @@ function readJsonObject(filePath) {
 }
 
 function waitStateKey(state) {
-  return String((state && (state.id || state.instanceId)) || "");
+  return String((state && (state.waitId || state.id || state.instanceId)) || "");
 }
 
 function persistedWaitState(state) {
@@ -181,17 +181,22 @@ function writeWaitState(waitState, patch = {}) {
     ...(patch && typeof patch === "object" ? patch : {}),
     updatedAt: new Date().toISOString(),
   };
+  const key = waitStateKey(next);
+  if (key) {
+    next.waitId = String(next.waitId || key);
+    next.id = String(next.id || next.waitId);
+  }
   const runDir = next.runDir || (next.waitPath ? path.dirname(next.waitPath) : "");
   if (!runDir) return;
 
   const legacyPath = next.legacyPath || next.waitPath || path.join(runDir, WAIT_STATE_FILENAME);
   const registryPath = next.registryPath || path.join(runDir, WAIT_STATES_FILENAME);
   const persisted = persistedWaitState(next);
-  const key = waitStateKey(persisted);
+  const persistedKey = waitStateKey(persisted);
 
   const registry = readJsonObject(registryPath);
   if (registry && Array.isArray(registry.waits)) {
-    const waits = registry.waits.filter((w) => waitStateKey(w) !== key);
+    const waits = registry.waits.filter((w) => waitStateKey(w) !== persistedKey);
     waits.push(persisted);
     fs.writeFileSync(registryPath, JSON.stringify({ ...registry, updatedAt: new Date().toISOString(), waits }, null, 2) + "\n", "utf-8");
   }

package/bin/lib/skill-registry.mjs

@@ -5,6 +5,15 @@ import yaml from "js-yaml";
 
 const fileCache = new Map();
 const CACHE_TTL_MS = 60_000;
+const SOURCE_PRIORITY = new Map([
+  ["workspace-agents", 100],
+  ["workspace-codex", 95],
+  ["workspace-cursor", 90],
+  ["builtin", 80],
+  ["global-agents", 70],
+  ["global-codex", 65],
+  ["global-cursor", 60],
+]);
 
 function readFileCached(absPath) {
   const now = Date.now();
@@ -62,7 +71,15 @@ export function listSkillFiles(dir) {
   try {
     if (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory()) return [];
     return fs.readdirSync(dir, { withFileTypes: true })
-      .filter((entry) => entry.isDirectory())
+      .filter((entry) => {
+        if (entry.isDirectory()) return true;
+        if (!entry.isSymbolicLink()) return false;
+        try {
+          return fs.statSync(path.join(dir, entry.name)).isDirectory();
+        } catch {
+          return false;
+        }
+      })
       .map((entry) => path.join(dir, entry.name, "SKILL.md"))
       .filter((skillPath) => fs.existsSync(skillPath));
   } catch {
@@ -132,14 +149,41 @@ export function listSkillsFromSources(sources, opts = {}) {
   return { skills, warnings };
 }
 
+function skillPriority(skill) {
+  return SOURCE_PRIORITY.get(String(skill?.source || "")) ?? 0;
+}
+
+export function dedupeSkillsByName(skills) {
+  const byName = new Map();
+  for (const skill of Array.isArray(skills) ? skills : []) {
+    const name = String(skill?.name || skill?.id || "").trim();
+    if (!name) continue;
+    const existing = byName.get(name);
+    if (!existing || skillPriority(skill) > skillPriority(existing)) {
+      byName.set(name, skill);
+    }
+  }
+  return Array.from(byName.values()).sort((a, b) => {
+    const bySource = String(a.sourceLabel || "").localeCompare(String(b.sourceLabel || ""));
+    if (bySource !== 0) return bySource;
+    return String(a.name || "").localeCompare(String(b.name || ""));
+  });
+}
+
 export function listSkills(packageRoot, workspaceRoot, opts = {}) {
   return listSkillsFromSources(defaultSkillSources(packageRoot, workspaceRoot), opts).skills;
 }
 
+export function listUniqueSkills(packageRoot, workspaceRoot, opts = {}) {
+  return dedupeSkillsByName(listSkills(packageRoot, workspaceRoot, opts));
+}
+
 export function readSkillDetail(packageRoot, workspaceRoot, keyOrName) {
   const wanted = String(keyOrName || "").trim();
   if (!wanted) return null;
-  const item = listSkills(packageRoot, workspaceRoot).find((skill) => skill.key === wanted || skill.name === wanted);
+  const all = listSkills(packageRoot, workspaceRoot);
+  const item = all.find((skill) => skill.key === wanted)
+    || dedupeSkillsByName(all).find((skill) => skill.name === wanted);
   if (!item) return null;
   return item;
 }