@fieldwangai/agentflow 0.1.25

package/bin/pipeline/collect-nodes.mjs

@@ -0,0 +1,212 @@
+#!/usr/bin/env node
+/**
+ * 收集所有节点（内置 + 当前流水线）的元数据，按 tool_nodejs 约定向 stdout 输出一行 JSON。
+ * 用法：agentflow apply -ai collect-nodes <workspaceRoot> <flowName> [runDir]
+ * 输出（仅 stdout 一行）：{ "err_code": 0, "message": { "result": "<节点元数据 markdown>" } }；err_code 0=成功 1=失败，无 next。
+ * 不写任何文件，由 agentflow apply -ai run-tool-nodejs 根据 message 写入 output。
+ */
+
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import yaml from "js-yaml";
+
+import { LEGACY_NODES_DIR, PIPELINES_DIR, PROJECT_NODES_DIR } from "../lib/paths.mjs";
+import { getFlowDir } from "../lib/workspace.mjs";
+
+const __dirnameCollect = path.dirname(fileURLToPath(import.meta.url));
+const PACKAGE_BUILTIN_NODES_DIR = path.join(path.resolve(__dirnameCollect, "..", ".."), "builtin", "nodes");
+
+function extractFrontmatter(raw) {
+  const m = raw.match(/^---\s*\n([\s\S]*?)\n---/);
+  return m ? m[1] : "";
+}
+
+function parseDescription(fm) {
+  const match = fm.match(/\bdescription:\s*["']?([^"'\n#][^\n]*)["']?/);
+  return match ? match[1].trim().replace(/^["']|["']$/g, "") : "";
+}
+
+function parseDisplayName(fm) {
+  const match = fm.match(/\bdisplayName:\s*["']?([^"'\n#][^\n]*)["']?/);
+  return match ? match[1].trim().replace(/^["']|["']$/g, "") : "";
+}
+
+/** 解析 frontmatter 中的 input/output 数组，返回 [{ type, name, defaultOrValue }, ...] */
+function parseSlots(fm, key) {
+  const slots = [];
+  const re = new RegExp(`\\b${key}:\\s*\\n([\\s\\S]*?)(?=\\n[a-zA-Z_][a-zA-Z0-9_]*\\s*:|---|$)`, "m");
+  const blockMatch = fm.match(re);
+  if (!blockMatch) return slots;
+  const block = blockMatch[1];
+  let current = {};
+  for (const line of block.split("\n")) {
+    const typeMatch = line.match(/^\s*-\s+type:\s*["']?([^"'\n]*)["']?/);
+    if (typeMatch) {
+      if (current.type) slots.push({ ...current });
+      current = { type: typeMatch[1].trim() };
+      continue;
+    }
+    const nameMatch = line.match(/^\s+name:\s*["']?([^"'\n]*)["']?/);
+    if (nameMatch) {
+      current.name = nameMatch[1].trim();
+      continue;
+    }
+    const defaultMatch = line.match(/^\s+(?:default|value):\s*(.*)$/);
+    if (defaultMatch) {
+      current.defaultOrValue = defaultMatch[1].trim().replace(/^["']|["']$/g, "");
+      slots.push({ ...current });
+      current = {};
+    }
+  }
+  if (current.type) slots.push({ ...current });
+  return slots;
+}
+
+function readNodeMeta(filePath) {
+  try {
+    if (!fs.existsSync(filePath)) return null;
+    const raw = fs.readFileSync(filePath, "utf-8");
+    const fm = extractFrontmatter(raw);
+    return {
+      description: parseDescription(fm),
+      displayName: parseDisplayName(fm),
+      input: parseSlots(fm, "input"),
+      output: parseSlots(fm, "output"),
+    };
+  } catch {
+    return null;
+  }
+}
+
+/** 从 flow.yaml 的 instances 得到节点列表，每项 { id, label, definitionId, input, output }，input/output 为 [{ type, name, defaultOrValue }] */
+function loadFlowYamlNodes(flowDir) {
+  const flowPath = path.join(flowDir, "flow.yaml");
+  if (!fs.existsSync(flowPath)) return [];
+  try {
+    const raw = fs.readFileSync(flowPath, "utf-8");
+    const data = yaml.load(raw);
+    const instances = data?.instances && typeof data.instances === "object" ? data.instances : {};
+    return Object.entries(instances).map(([id, inst]) => {
+      const inp = Array.isArray(inst.input) ? inst.input : [];
+      const out = Array.isArray(inst.output) ? inst.output : [];
+      const input = inp.map((s) => ({
+        type: (s && s.type != null) ? String(s.type).trim() : "",
+        name: (s && s.name != null) ? String(s.name).trim() : "",
+        defaultOrValue: (s && (s.value != null || s.default != null)) ? String(s.value ?? s.default ?? "").trim() : "",
+      }));
+      const output = out.map((s) => ({
+        type: (s && s.type != null) ? String(s.type).trim() : "",
+        name: (s && s.name != null) ? String(s.name).trim() : "",
+        defaultOrValue: (s && (s.value != null || s.default != null)) ? String(s.value ?? s.default ?? "").trim() : "",
+      }));
+      return {
+        id,
+        label: (inst.label != null) ? String(inst.label) : id,
+        definitionId: (inst.definitionId != null) ? String(inst.definitionId) : id,
+        input,
+        output,
+      };
+    });
+  } catch (_) {
+    return [];
+  }
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  if (args.length < 2) {
+    const payload = { err_code: 1, message: { result: "Usage: agentflow apply -ai collect-nodes <workspaceRoot> <flowName> [runDir]" } };
+    console.log(JSON.stringify(payload));
+    process.exit(1);
+  }
+
+  const [workspaceRoot, flowName] = args.map((p) => path.resolve(p));
+  const nodesDirLegacy = path.join(workspaceRoot, LEGACY_NODES_DIR);
+  const nodesDirNew = path.join(workspaceRoot, PROJECT_NODES_DIR);
+  const flowDir = getFlowDir(workspaceRoot, flowName) || path.join(workspaceRoot, PIPELINES_DIR, flowName);
+
+  const out = [];
+
+  // 1. 内置节点：包内 builtin/nodes + 项目 .workspace/agentflow/nodes（覆盖旧 .cursor/...），包内同 id 优先
+  out.push("# 节点元数据（内置 + 当前流水线）\n");
+  out.push("## 1. 内置节点元数据\n\n");
+  const builtinFiles = new Map();
+  if (fs.existsSync(PACKAGE_BUILTIN_NODES_DIR)) {
+    for (const file of fs.readdirSync(PACKAGE_BUILTIN_NODES_DIR).filter((f) => f.endsWith(".md")).sort()) {
+      builtinFiles.set(file.replace(/\.md$/, ""), path.join(PACKAGE_BUILTIN_NODES_DIR, file));
+    }
+  }
+  const projectById = new Map();
+  const mergeProjectDir = (dir) => {
+    if (!fs.existsSync(dir)) return;
+    for (const file of fs.readdirSync(dir).filter((f) => f.endsWith(".md")).sort()) {
+      projectById.set(file.replace(/\.md$/, ""), path.join(dir, file));
+    }
+  };
+  mergeProjectDir(nodesDirLegacy);
+  mergeProjectDir(nodesDirNew);
+  for (const [id, fp] of projectById) {
+    if (!builtinFiles.has(id)) builtinFiles.set(id, fp);
+  }
+  for (const [definitionId, filePath] of builtinFiles) {
+    const meta = readNodeMeta(filePath);
+    if (!meta) continue;
+    out.push(`### ${definitionId}\n`);
+    out.push(`- **displayName**: ${meta.displayName || definitionId}\n`);
+    out.push(`- **description**: ${meta.description || ""}\n`);
+    out.push(`- **input** (handle: input-0, input-1, …):\n`);
+    if (meta.input.length) meta.input.forEach((s, i) => out.push(`  - \`${s.name || "?"}\` (${s.type || "?"}) → input-${i}\n`));
+    else out.push("  - 无\n");
+    out.push(`- **output** (handle: output-0, output-1, …):\n`);
+    if (meta.output.length) meta.output.forEach((s, i) => out.push(`  - \`${s.name || "?"}\` (${s.type || "?"}) → output-${i}\n`));
+    else out.push("  - 无\n");
+    out.push("\n");
+  }
+  if (builtinFiles.size === 0) out.push("（无内置节点目录）\n");
+
+  // 2. 当前流水线节点（来自 flow.yaml instances）
+  out.push("## 2. 当前流水线节点元数据\n\n");
+  const flowNodes = loadFlowYamlNodes(flowDir);
+  for (const node of flowNodes) {
+    const { id, label, definitionId, input: nodeInput, output: nodeOutput } = node;
+    let input = nodeInput || [];
+    let output = nodeOutput || [];
+    if (input.length === 0 && output.length === 0) {
+      const tryPaths = [
+        path.join(flowDir, "nodes", `${definitionId}.md`),
+        path.join(nodesDirNew, `${definitionId}.md`),
+        path.join(nodesDirLegacy, `${definitionId}.md`),
+        path.join(PACKAGE_BUILTIN_NODES_DIR, `${definitionId}.md`),
+      ];
+      let meta = null;
+      for (const defPath of tryPaths) {
+        meta = readNodeMeta(defPath);
+        if (meta) break;
+      }
+      if (meta) {
+        input = meta.input;
+        output = meta.output;
+      }
+    }
+    out.push(`### ${id}\n`);
+    out.push(`- **label**: ${label || id}\n`);
+    out.push(`- **definitionId**: ${definitionId || ""}\n`);
+    out.push(`- **input** (handle):\n`);
+    if (input.length) input.forEach((s, i) => out.push(`  - \`${s.name || "?"}\` (${s.type || "?"}) → input-${i}\n`));
+    else out.push("  - 无\n");
+    out.push(`- **output** (handle):\n`);
+    if (output.length) output.forEach((s, i) => out.push(`  - \`${s.name || "?"}\` (${s.type || "?"}) → output-${i}\n`));
+    else out.push("  - 无\n");
+    out.push("\n");
+  }
+
+  const content = out.join("");
+  const payload = {
+    err_code: 0,
+    message: { result: content },
+  };
+  console.log(JSON.stringify(payload));
+}
+
+main();

package/bin/pipeline/compute-cache-md5.mjs

@@ -0,0 +1,177 @@
+#!/usr/bin/env node
+/**
+ * 根据 prompt 内容 + resolvedInputs 计算缓存键 MD5 与 cacheInputInfo，供前处理与 check-cache 共用。
+ * 用法（模块）：import { computeCacheMd5 } from "./compute-cache-md5.mjs";
+ * 返回 { cacheMd5, cacheInputInfo, payload } 或 { ok: false, error }。payload 为计算 MD5 的完整字符串，供 pre/now 落盘排查。
+ *
+ * 当前 .cache.json 文件结构（写入路径：intermediate/<instanceId>/<instanceId>.cache.json）：
+ * - cacheMd5: string   — 对 payload 的 MD5 十六进制串
+ * - cacheInputInfo: string — JSON 字符串，解析后为 { instanceId, definitionId, inputPaths }
+ *   - inputPaths: Array<{ slot: string, execId: number, value: string }>，即 forCache 各 key 及参与 MD5 的值
+ * - execId: number      — 本轮写入时的 execId
+ * - inputHandlerExecIds?: Record<前驱节点 id, number> — 各前驱在本轮计算时用的 execId（可选）
+ * - payload?: string   — 用于算 MD5 的完整字符串：prompt 全文 + "\\n" + forCache 规范化串（可选，便于排查）
+ */
+
+import crypto from "crypto";
+import fs from "fs";
+import path from "path";
+
+import { getRunDir, PIPELINES_DIR } from "../lib/paths.mjs";
+import { getFlowDir } from "../lib/workspace.mjs";
+
+import { buildNodePrompt } from "./build-node-prompt.mjs";
+import { getResolvedValues } from "./get-resolved-values.mjs";
+import { loadAllExecIds, latestResultExecId, intermediatePromptBasename, intermediateCacheBasename } from "./get-exec-id.mjs";
+import { loadFlowDefinition, instanceEntryToSlots, parseInstanceSlots } from "./parse-flow.mjs";
+
+/** 从 intermediate/<instanceId>/<instanceId>.cache.json 读取 cacheMd5，无则返回 "" */
+function readUpstreamCacheMd5(intermediateDir, instanceId, execId) {
+  const basename = intermediateCacheBasename(instanceId, execId);
+  const p = path.join(intermediateDir, instanceId, basename);
+  if (!fs.existsSync(p)) return "";
+  try {
+    const o = JSON.parse(fs.readFileSync(p, "utf-8"));
+    return o.cacheMd5 != null ? String(o.cacheMd5) : "";
+  } catch {
+    return "";
+  }
+}
+
+/**
+ * 计算节点的 cacheMd5 与 cacheInputInfo。
+ * payload 不含 execId，使相同输入得到稳定 cache 键，避免缓存持续失效。
+ * 约定：payload = prompt 内容 + "\n" + 规范化的 forCache（仅 resolvedInputs、upstreamMd5）。
+ * @returns {{ ok: true, cacheMd5: string, cacheInputInfo: string, payload: string }} 或 {{ ok: false, error: string }}
+ */
+export function computeCacheMd5(workspaceRoot, flowName, uuid, instanceId, execId = 1) {
+  const runDir = getRunDir(workspaceRoot, flowName, uuid);
+  const intermediateDir = path.join(runDir, "intermediate");
+  const build = buildNodePrompt(workspaceRoot, flowName, uuid, instanceId, execId);
+  if (!build.ok) {
+    return { ok: false, error: build.error || "buildNodePrompt failed" };
+  }
+  const promptBasename = intermediatePromptBasename(instanceId, execId);
+  const promptPath = path.join(intermediateDir, instanceId, promptBasename);
+  if (!fs.existsSync(promptPath)) {
+    return { ok: false, error: "Prompt file not found" };
+  }
+  const promptContent = fs.readFileSync(promptPath, "utf-8");
+
+  /** 所有写 .cache.json 的节点（含 control_if、control_anyOne、tool_load_key、tool_save_key、tool_get_env、普通节点）均由此处统一解析输入；
+   * 输入来自 getResolvedValues → computeResolvedInputsForInstance，按 flow.edges 的 targetHandle 与 instance 的 input 槽位一一对应赋值，无按 definitionId 的特殊分支。
+   * 只要 flow 中该节点的 edge 与 instance 定义正确，各 input 槽会正确赋值。 */
+  const data = getResolvedValues(workspaceRoot, flowName, uuid, instanceId);
+  if (!data.ok) {
+    return { ok: false, error: data.error || "getResolvedValues failed" };
+  }
+  const resolvedInputs = data.resolvedInputs || {};
+
+  /** 上游 edge 对应 node 的 cacheMd5 与各 input handler 的 execId：从 flow.json 取 predecessors，再读各前驱的 .cache.json */
+  let upstreamMd5 = "";
+  /** 各 input handler（前驱节点）在本次计算时使用的 execId，用于落盘与参与 cache 计算 */
+  let inputHandlerExecIds = {};
+  const flowJsonPath = path.join(intermediateDir, "flow.json");
+  if (fs.existsSync(flowJsonPath)) {
+    try {
+      const flow = JSON.parse(fs.readFileSync(flowJsonPath, "utf-8"));
+      if (flow.ok) {
+        let preds = flow.predecessors && flow.predecessors[instanceId];
+        if (!preds && Array.isArray(flow.edges)) {
+          preds = [];
+          const seen = new Set();
+          for (const e of flow.edges) {
+            if (e.target !== instanceId || !e.source) continue;
+            if (!seen.has(e.source)) {
+              seen.add(e.source);
+              preds.push(e.source);
+            }
+          }
+        }
+        if (Array.isArray(preds) && preds.length > 0) {
+          const order = flow.order || [];
+          const execIds = loadAllExecIds(workspaceRoot, flowName, uuid, order);
+          const sorted = [...new Set(preds)].sort();
+          upstreamMd5 = sorted
+            .map((predId) => {
+              const predExecId = latestResultExecId(execIds[predId] ?? 1);
+              inputHandlerExecIds[predId] = predExecId;
+              return `${predId}:${readUpstreamCacheMd5(intermediateDir, predId, 1)}`;
+            })
+            .join("\n");
+        }
+      }
+    } catch (_) {}
+  }
+
+  /** forCache 仅含 resolvedInputs 与 upstreamMd5，不包含 execId，保证 payload 稳定 */
+  const forCache = {
+    ...resolvedInputs,
+    upstreamMd5,
+  };
+  const keys = Object.keys(forCache).sort();
+  const parts = keys.map((k) => `${k}:${String(forCache[k] ?? "")}`);
+  const canonicalInputString = parts.join("\n");
+
+  const payload = promptContent + "\n" + canonicalInputString;
+  const cacheMd5 = crypto.createHash("md5").update(payload, "utf8").digest("hex");
+
+  let definitionId = "";
+  let flow = null;
+  if (fs.existsSync(flowJsonPath)) {
+    try {
+      flow = JSON.parse(fs.readFileSync(flowJsonPath, "utf-8"));
+      if (flow.ok && flow.nodes) {
+        const node = flow.nodes.find((n) => n.id === instanceId);
+        definitionId = node?.definitionId ?? "";
+      }
+    } catch (_) {}
+  }
+
+  /** 每个 slot 对应的 input handler 的 execId（该槽由哪次执行的 handler 提供）；非 handler 槽用 0，本节点 execId 槽用当前 execId */
+  const slotToHandlerExecId = {};
+  if (flow?.ok && flow.edges && (inputHandlerExecIds && Object.keys(inputHandlerExecIds).length > 0)) {
+    const predsWithHandle = (flow.edges || [])
+      .filter((e) => e.target === instanceId && e.source)
+      .map((e) => ({ source: e.source, targetHandle: e.targetHandle || "input-0" }));
+    let flowDir = getFlowDir(workspaceRoot, flowName) || path.join(path.resolve(workspaceRoot), PIPELINES_DIR, flowName);
+    if (flow?.flowDir && typeof flow.flowDir === "string" && flow.flowDir.trim()) {
+      flowDir = path.isAbsolute(flow.flowDir) ? flow.flowDir : path.join(workspaceRoot, flow.flowDir);
+    }
+    const flowData = loadFlowDefinition(flowDir);
+    const instanceDir = path.join(flowDir, "instance");
+    const getSlotsFor = (id) => {
+      if (flowData?.instances?.[id]) return instanceEntryToSlots(flowData.instances[id]);
+      try {
+        return parseInstanceSlots(path.join(instanceDir, `${id}.md`));
+      } catch {
+        return { input: {}, output: {}, inputTypes: {}, outputTypes: {} };
+      }
+    };
+    const inputSlotNames = Object.keys(getSlotsFor(instanceId).input || {});
+    for (let i = 0; i < inputSlotNames.length; i++) {
+      const slotName = inputSlotNames[i];
+      const targetHandle = `input-${i}`;
+      const pred = predsWithHandle.find((p) => p.targetHandle === targetHandle);
+      if (pred && inputHandlerExecIds[pred.source] != null) {
+        slotToHandlerExecId[slotName] = inputHandlerExecIds[pred.source];
+      }
+    }
+  }
+  const currentExecId = execId ?? 1;
+  const inputPaths = keys.map((k) => ({
+    slot: k,
+    execId: slotToHandlerExecId[k] ?? (k === "execId" ? currentExecId : 0),
+    value: forCache[k],
+  }));
+  const cacheInputInfo = JSON.stringify({ instanceId, definitionId, inputPaths });
+
+  return {
+    ok: true,
+    cacheMd5,
+    cacheInputInfo,
+    payload,
+    execId: execId ?? 1,
+    inputHandlerExecIds,
+  };
+}

package/bin/pipeline/ensure-run-dir.mjs

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+/**
+ * 生成本次运行 uuid（未传时）并创建 run 目录，避免由 Agent 每次生成。
+ * 用法：node ensure-run-dir.mjs <workspaceRoot> [uuid] <flowName>
+ * uuid 须为 14 位数字（YYYYMMDDhhmmss），否则视为未传并自动生成。
+ * flowName 必传；run 目录为 <workspaceRoot>/.workspace/agentflow/runBuild/<flowName>/<uuid>/，其下创建 intermediate/、output/。
+ * 若传入合法 uuid：仅确保上述目录存在。
+ * 输出（stdout JSON）：{ "ok": true, "uuid": "..." }
+ */
+
+import fs from "fs";
+import path from "path";
+
+import { getRunDir } from "../lib/paths.mjs";
+
+/** 合法 uuid：14 位数字 YYYYMMDDhhmmss，避免误传 flow name 等当作 uuid */
+function isValidUuid(value) {
+  return typeof value === "string" && /^\d{14}$/.test(value);
+}
+
+function generateUuid() {
+  const now = new Date();
+  const y = now.getFullYear();
+  const m = String(now.getMonth() + 1).padStart(2, "0");
+  const d = String(now.getDate()).padStart(2, "0");
+  const h = String(now.getHours()).padStart(2, "0");
+  const min = String(now.getMinutes()).padStart(2, "0");
+  const s = String(now.getSeconds()).padStart(2, "0");
+  return `${y}${m}${d}${h}${min}${s}`;
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  if (args.length < 1) {
+    console.error(
+      JSON.stringify({
+        ok: false,
+        error: "Usage: node ensure-run-dir.mjs <workspaceRoot> [uuid] <flowName>",
+      }),
+    );
+    process.exit(1);
+  }
+
+  const workspaceRoot = path.resolve(args[0]);
+  const uuid = isValidUuid(args[1]) ? args[1] : generateUuid();
+  const flowName = typeof args[2] === "string" && args[2].trim() !== "" ? args[2].trim() : null;
+  if (!flowName) {
+    console.error(
+      JSON.stringify({ ok: false, error: "Usage: node ensure-run-dir.mjs <workspaceRoot> [uuid] <flowName> (flowName required)" }),
+    );
+    process.exit(1);
+  }
+
+  const runDir = getRunDir(workspaceRoot, flowName, uuid);
+  const intermediateDir = path.join(runDir, "intermediate");
+  const outputDir = path.join(runDir, "output");
+
+  try {
+    fs.mkdirSync(intermediateDir, { recursive: true });
+    fs.mkdirSync(outputDir, { recursive: true });
+  } catch (e) {
+    console.error(
+      JSON.stringify({ ok: false, error: e.message || "Failed to create run dir" }),
+    );
+    process.exit(1);
+  }
+
+  console.log(JSON.stringify({ ok: true, uuid }));
+}
+
+main();