@fieldwangai/agentflow 0.1.34 → 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/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;
 }