@fieldwangai/agentflow 0.1.153 → 0.1.154

package/bin/pipeline/resolve-inputs.mjs

@@ -1,201 +0,0 @@
-#!/usr/bin/env node
-/**
- * 按 flow 结构 + 中间文件为单个 instance 计算 resolvedInputs（不注入常量；上游 output 路径已带对应 input handler 的 execId）。
- * 供 get-resolved-values 等用时现算，不依赖 flow.json 中的 resolvedInputs。
- * 约定：上游节点的 output 槽路径使用该前驱的 latestResultExecId，即 output/<predId>/node_<predId>_<execId>_<slot>.md。
- * 用法（模块）：import { computeResolvedInputsForInstance } from "./resolve-inputs.mjs";
- * @returns {{ ok: true, resolvedInputs: object }} 或 {{ ok: false, error: string }}
- */
-
-import fs from "fs";
-import path from "path";
-
-import { getRunDir, PIPELINES_DIR } from "../lib/paths.mjs";
-import { getFlowDir } from "../lib/workspace.mjs";
-import {
-  loadAllExecIds,
-  latestResultExecId,
-  intermediateResultBasename,
-  outputDirForNode,
-  outputNodeBasename,
-} from "./get-exec-id.mjs";
-import {
-  loadFlowDefinition,
-  parseResultOutputPath,
-  instanceEntryToSlots,
-  parseInstanceSlots,
-  readInstanceContent,
-  extractPlaceholders,
-} from "./parse-flow.mjs";
-
-/**
- * 为指定 instanceId 计算 resolvedInputs（与 parse-flow resolvePlaceholders 单实例逻辑一致）。
- */
-export function computeResolvedInputsForInstance(workspaceRoot, flowName, uuid, instanceId) {
-  const root = path.resolve(workspaceRoot);
-  const runDir = getRunDir(workspaceRoot, flowName, uuid);
-  const flowJsonPath = path.join(runDir, "intermediate", "flow.json");
-  const intermediateDir = path.join(runDir, "intermediate");
-
-  if (!fs.existsSync(flowJsonPath)) {
-    return { ok: false, error: `flow.json not found: ${flowJsonPath}. Run parse-flow.mjs first.` };
-  }
-
-  let flow;
-  try {
-    flow = JSON.parse(fs.readFileSync(flowJsonPath, "utf-8"));
-  } catch (e) {
-    return { ok: false, error: e.message || "Invalid flow.json" };
-  }
-  if (!flow.ok) {
-    return { ok: false, error: flow.error || "flow.json indicates error" };
-  }
-
-  let flowDir = getFlowDir(root, flowName) || path.join(root, PIPELINES_DIR, flowName);
-  if (flow.flowDir && typeof flow.flowDir === "string" && flow.flowDir.trim()) {
-    flowDir = path.isAbsolute(flow.flowDir) ? flow.flowDir : path.join(root, flow.flowDir);
-  }
-  const instanceDir = path.join(flowDir, "instance");
-
-  const order = flow.order || [];
-  const edges = flow.edges || [];
-  if (!order.length) {
-    return { ok: false, error: "flow.json missing order" };
-  }
-
-  if (!order.includes(instanceId)) {
-    return { ok: false, error: `instanceId ${instanceId} not in flow order` };
-  }
-
-  const flowData = loadFlowDefinition(flowDir);
-  const instances = flowData?.instances && typeof flowData.instances === "object" ? flowData.instances : {};
-  const useYaml = Object.keys(instances).length > 0;
-
-  let execIds = {};
-  if (fs.existsSync(intermediateDir)) {
-    try {
-      execIds = loadAllExecIds(workspaceRoot, flowName, uuid, order);
-    } catch (_) {}
-  }
-
-  /** 入边：target -> [{ source, sourceHandle, targetHandle }] */
-  const predecessors = new Map();
-  for (const e of edges) {
-    if (!e.target) continue;
-    if (!predecessors.has(e.target)) predecessors.set(e.target, []);
-    predecessors.get(e.target).push({
-      source: e.source,
-      sourceHandle: e.sourceHandle || "output-0",
-      targetHandle: e.targetHandle,
-    });
-  }
-
-  const getSlotsFor = (id) => {
-    if (useYaml && instances[id]) return instanceEntryToSlots(instances[id]);
-    const instPath = path.join(instanceDir, `${id}.md`);
-    return fs.existsSync(instPath) ? parseInstanceSlots(instPath) : instanceEntryToSlots(null);
-  };
-
-  const getContentFor = (id) => {
-    if (useYaml && instances[id] && instances[id].body != null) return String(instances[id].body || "").trim();
-    return readInstanceContent(path.join(instanceDir, `${id}.md`));
-  };
-
-  const getNodeOutput = (id, sourceHandle) => {
-    const slots = getSlotsFor(id);
-    const outValues = Object.values(slots.output || {});
-    if (sourceHandle && /^output-(\d+)$/.test(sourceHandle)) {
-      const idx = parseInt(sourceHandle.replace("output-", ""), 10);
-      if (idx >= 0 && idx < outValues.length) return outValues[idx] ?? null;
-    }
-    return outValues[0] ?? null;
-  };
-
-  const getNodeOutputFromResult = (id) => {
-    const latestE = latestResultExecId(execIds[id] ?? 1);
-    if (!latestE) return null;
-    const resultPath = path.join(intermediateDir, id, intermediateResultBasename(id, latestE));
-    return parseResultOutputPath(resultPath);
-  };
-
-  const resolvedInputs = {};
-  const slots = getSlotsFor(instanceId);
-  const { inputs: inputRefs } = extractPlaceholders(getContentFor(instanceId));
-  const preds = predecessors.get(instanceId) || [];
-  const inputSlotNames = Object.keys(slots.input || {});
-
-  for (let i = 0; i < inputSlotNames.length; i++) {
-    const slotName = inputSlotNames[i];
-    const targetHandle = `input-${i}`;
-    const pred = preds.find((p) => p.targetHandle === targetHandle);
-    if (!pred) continue;
-
-    const fromResult = getNodeOutputFromResult(pred.source);
-    const fromInstance = getNodeOutput(pred.source, pred.sourceHandle);
-    let value = fromResult ?? fromInstance;
-
-    if (pred.sourceHandle && /^output-(\d+)$/.test(pred.sourceHandle)) {
-      const sourceSlots = getSlotsFor(pred.source);
-      const outSlotNames = Object.keys(sourceSlots.output || {});
-      if (outSlotNames.length > 0) {
-        const idx = parseInt(pred.sourceHandle.replace("output-", ""), 10);
-        if (idx >= 0 && idx < outSlotNames.length) {
-          const predExecId = latestResultExecId(execIds[pred.source] ?? 1);
-          const slotPath = `${outputDirForNode(pred.source)}/${outputNodeBasename(pred.source, predExecId, outSlotNames[idx])}`;
-          if (!value || value === "" || outSlotNames.length > 1) {
-            value = slotPath;
-          }
-        }
-      }
-    }
-
-    if (value != null) {
-      const slotType = (slots.inputTypes && slots.inputTypes[slotName]) || null;
-      if (slotType === "节点" || slotType === "node") {
-        value = pred.source;
-      }
-      resolvedInputs[slotName] = value;
-    }
-  }
-
-  for (const slotName of inputSlotNames) {
-    if (resolvedInputs[slotName] != null) continue;
-    const defaultVal = slots.input && slots.input[slotName];
-    if (defaultVal !== undefined && defaultVal !== "") {
-      resolvedInputs[slotName] = defaultVal;
-    }
-  }
-
-  // --input 覆盖：仅当对应上游是 provide_ 节点，且用户传了该 slotName 的值时生效。
-  // parse-flow 初始阶段也会写入 flow.json 的 cliInputsApplied，但此处在运行时重算 resolvedInputs，
-  // 必须在同一处再打一次 patch，否则 override 会丢失（provide 节点原 default 值会覆盖用户输入）。
-  if (flow.cliInputsApplied && typeof flow.cliInputsApplied === "object") {
-    for (let i = 0; i < inputSlotNames.length; i++) {
-      const slotName = inputSlotNames[i];
-      const cliVal = flow.cliInputsApplied[slotName];
-      if (!cliVal || typeof cliVal !== "object") continue;
-      const pred = preds.find((p) => p.targetHandle === `input-${i}`);
-      if (!pred?.source) continue;
-      const sourceInst = instances[pred.source];
-      if (!sourceInst?.definitionId?.startsWith?.("provide_")) continue;
-      const overrideValue = cliVal.type === "file" ? cliVal.path : cliVal.value;
-      if (overrideValue == null) continue;
-      resolvedInputs[slotName] = overrideValue;
-    }
-  }
-
-  if (inputRefs.length > 0 && preds.length > 0 && !Object.keys(resolvedInputs).length) {
-    const pred = preds[0];
-    const fromResult = getNodeOutputFromResult(pred.source);
-    const fromInstance = getNodeOutput(pred.source, pred.sourceHandle);
-    let v = fromResult ?? fromInstance;
-    if (v != null) {
-      const firstSlotName = inputSlotNames[0];
-      const firstType = (slots.inputTypes && slots.inputTypes[firstSlotName]) || null;
-      if (firstType === "节点" || firstType === "node") v = pred.source;
-      return { ok: true, resolvedInputs: { _: v } };
-    }
-  }
-
-  return { ok: true, resolvedInputs };
-}

package/bin/pipeline/run-tool-nodejs.mjs

@@ -1,167 +0,0 @@
-#!/usr/bin/env node
-/**
- * 运行 tool_nodejs 脚本并将结果写入流水线。
- *
- * 成败判定（Unix 哲学）：
- *   - 进程 exit code 0 → success，非 0 → failed
- *   - 若 stdout 为合法 JSON 且含 err_code，err_code 优先（向后兼容旧脚本）
- *
- * stdout 内容 → result 槽位：
- *   - JSON 模式：提取 message.result
- *   - 纯文本模式：整段 stdout 作为 result
- *
- * 用法：node run-tool-nodejs.mjs <workspaceRoot> <flowName> <uuid> <instanceId> [execId] -- <scriptCmd> [args...]
- */
-
-import { spawnSync } from "child_process";
-import fs from "fs";
-import path from "path";
-import { fileURLToPath } from "url";
-
-import { getRunDir } from "../lib/paths.mjs";
-import { readMergedEnvObject } from "../lib/user-env.mjs";
-import { validateAndParse } from "./validate-script-output.mjs";
-import { writeResult } from "./write-result.mjs";
-import { loadExecId, outputNodeBasename, outputDirForNode } from "./get-exec-id.mjs";
-import { nodeToolCommandToArgv } from "../lib/normalize-node-tool-command.mjs";
-import { buildPipelineScriptPathHint } from "../lib/flow-normalize.mjs";
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const MAX_RETRIES = 3;
-const RETRY_DELAY_MS = 1000;
-
-function runtimeEnv() {
-  return { ...process.env, ...readMergedEnvObject(process.env.AGENTFLOW_USER_ID || "") };
-}
-
-function runOnce(workspaceRoot, flowName, uuid, instanceId, execId, scriptArgs) {
-  const runDir = getRunDir(workspaceRoot, flowName, uuid);
-  const outputDir = path.join(runDir, outputDirForNode(instanceId));
-
-  const rawLine = scriptArgs.join(" ");
-  const { argv, commandLine: normalizedCmd } = nodeToolCommandToArgv(rawLine);
-  const child =
-    /^node\s/i.test(String(normalizedCmd).trim()) && argv.length >= 1
-      ? spawnSync(process.execPath, argv, {
-          cwd: workspaceRoot,
-          shell: false,
-          stdio: ["inherit", "pipe", "pipe"],
-          env: runtimeEnv(),
-        })
-      : spawnSync(normalizedCmd, [], {
-          cwd: workspaceRoot,
-          shell: true,
-          stdio: ["inherit", "pipe", "pipe"],
-          env: runtimeEnv(),
-        });
-
-  const stdout = child.stdout?.toString("utf-8") ?? "";
-  const stderr = child.stderr?.toString("utf-8") ?? "";
-  const exitCode = child.status ?? 1;
-
-  if (child.signal) {
-    persistStderr(outputDir, instanceId, execId, stderr);
-    return { success: false, fatal: true, detail: `Script killed: ${child.signal}` };
-  }
-
-  const { ok, errors, payload } = validateAndParse(stdout);
-
-  if (!ok) {
-    const baseDetail = exitCode !== 0
-      ? `脚本退出码 ${exitCode}` + (stderr.trim() ? `：${stderr.trim().slice(0, 200)}` : "")
-      : (errors.length ? errors.join("; ") : "脚本无输出");
-    const detail = baseDetail + buildPipelineScriptPathHint(stderr);
-    writeResult(workspaceRoot, flowName, uuid, instanceId, {
-      status: "failed",
-      message: detail,
-    }, { preserveBody: true, execId });
-    persistStderr(outputDir, instanceId, execId, stderr);
-    return { success: false, fatal: false, detail };
-  }
-
-  const isSynthetic = Boolean(payload._synthetic);
-  const success = isSynthetic ? exitCode === 0 : (payload.err_code === 0);
-  const message = payload.message;
-
-  try {
-    fs.mkdirSync(outputDir, { recursive: true });
-    // 备份由 snapshotPriorRoundIfNeeded 在 pre-process 入口统一处理。
-    for (const slot of Object.keys(message)) {
-      if (slot === "_synthetic") continue;
-      const content = message[slot];
-      if (content == null) continue;
-      fs.writeFileSync(
-        path.join(outputDir, outputNodeBasename(instanceId, execId, slot)),
-        String(content),
-        "utf-8",
-      );
-    }
-    writeResult(workspaceRoot, flowName, uuid, instanceId, {
-      status: success ? "success" : "failed",
-      message: success ? "执行完成" : "执行未通过",
-    }, { preserveBody: true, execId });
-  } catch (e) {
-    writeResult(workspaceRoot, flowName, uuid, instanceId, {
-      status: "failed",
-      message: e.message || "写入 output/result 异常",
-    }, { preserveBody: true, execId });
-    persistStderr(outputDir, instanceId, execId, stderr);
-    return { success: false, fatal: false, detail: e.message };
-  }
-
-  persistStderr(outputDir, instanceId, execId, stderr);
-  return { success, fatal: false, detail: success ? "" : `脚本退出码 ${exitCode}` };
-}
-
-function persistStderr(outputDir, instanceId, execId, stderr) {
-  if (!stderr) return;
-  try {
-    fs.mkdirSync(outputDir, { recursive: true });
-    fs.writeFileSync(
-      path.join(outputDir, outputNodeBasename(instanceId, execId, "stderr")),
-      stderr,
-      "utf-8",
-    );
-  } catch (_) {}
-}
-
-function main() {
-  const args = process.argv.slice(2);
-  const sep = args.indexOf("--");
-  if (sep < 0 || args.length < sep + 2) {
-    console.error(
-      "Usage: node run-tool-nodejs.mjs <workspaceRoot> <flowName> <uuid> <instanceId> [execId] -- <scriptCmd> [args...]",
-    );
-    process.exit(2);
-  }
-
-  const workspaceRoot = path.resolve(args[0]);
-  const flowName = args[1];
-  const uuid = args[2];
-  const instanceId = args[3];
-  const execId =
-    sep >= 5 && args[4] !== "--"
-      ? (parseInt(String(args[4]), 10) || 1)
-      : loadExecId(workspaceRoot, flowName, uuid, instanceId);
-  const scriptArgs = args.slice(sep + 1);
-
-  for (let attempt = 1; attempt <= MAX_RETRIES + 1; attempt++) {
-    const result = runOnce(workspaceRoot, flowName, uuid, instanceId, execId, scriptArgs);
-    if (result.success) {
-      process.exit(0);
-    }
-    if (result.fatal) {
-      console.error(result.detail);
-      process.exit(1);
-    }
-    if (attempt <= MAX_RETRIES) {
-      console.error(`[tool_nodejs 自愈] ${instanceId} 第 ${attempt}/${MAX_RETRIES} 次重试：${result.detail?.slice(0, 200) || "unknown"}`);
-      spawnSync("sleep", [String(RETRY_DELAY_MS / 1000)], { stdio: "ignore" });
-    } else {
-      console.error(result.detail);
-      process.exit(1);
-    }
-  }
-}
-
-main();

package/bin/pipeline/save-key.mjs

@@ -1,93 +0,0 @@
-#!/usr/bin/env node
-/**
- * tool_save_key 执行脚本：按 key 将 value 写入 run 目录下 memory 存储，stdout 输出 tool_nodejs 约定 JSON。
- * 存储路径与格式由本脚本内部实现，节点不感知。key/value 由命令行参数传入，不读 flow。
- * value 若为 run 目录内相对路径则读取文件内容后写入。
- * 用法：node save-key.mjs <workspaceRoot> <flowName> <uuid> <key> [value]
- * 输出（stdout 一行 JSON）：成功时 result 为写入的 value；err_code 0=成功 1=失败，无 next。
- */
-
-import fs from "fs";
-import path from "path";
-
-import { getRunDir } from "../lib/paths.mjs";
-
-const MEMORY_FILENAME = "memory.md";
-
-function parseMemory(content) {
-  const map = new Map();
-  for (const line of (content || "").split(/\r?\n/)) {
-    const idx = line.indexOf(": ");
-    if (idx <= 0) continue;
-    const k = line.slice(0, idx).trim();
-    const v = line.slice(idx + 2).trim();
-    if (k) map.set(k, v);
-  }
-  return map;
-}
-
-function serializeMemory(map) {
-  return (
-    Array.from(map.entries())
-      .map(([k, v]) => `${k}: ${String(v).replace(/\r?\n/g, " ")}`)
-      .join("\n") + (map.size ? "\n" : "")
-  );
-}
-
-function main() {
-  const [root, flowName, uuid, keyArg, valueArg] = process.argv.slice(2);
-  if (!root || !flowName || !uuid) {
-    console.log(
-      JSON.stringify({
-        err_code: 1,
-        message: { result: "" },
-      }),
-    );
-    process.exit(0);
-  }
-
-  const key = keyArg != null ? String(keyArg).trim() : "";
-  let value = valueArg != null ? String(valueArg).trim() : "";
-
-  const workspaceRoot = path.resolve(root);
-  const runDir = getRunDir(workspaceRoot, flowName, uuid);
-  const memoryPath = path.join(runDir, MEMORY_FILENAME);
-
-  if (!key) {
-    console.log(
-      JSON.stringify({
-        err_code: 0,
-        message: { result: "" },
-      }),
-    );
-    process.exit(0);
-  }
-
-  if (
-    value &&
-    (value.includes("/") || value.startsWith("output") || value.startsWith("intermediate"))
-  ) {
-    const valuePath = path.join(runDir, value);
-    if (fs.existsSync(valuePath)) {
-      try {
-        value = fs.readFileSync(valuePath, "utf-8").trim();
-      } catch (_) {}
-    }
-  }
-
-  const existing = fs.existsSync(memoryPath)
-    ? parseMemory(fs.readFileSync(memoryPath, "utf-8"))
-    : new Map();
-  existing.set(key, value);
-  fs.mkdirSync(path.dirname(memoryPath), { recursive: true });
-  fs.writeFileSync(memoryPath, serializeMemory(existing), "utf-8");
-
-  console.log(
-    JSON.stringify({
-      err_code: 0,
-      message: { result: value },
-    }),
-  );
-}
-
-main();

package/bin/pipeline/snapshot-prior-round.mjs

@@ -1,70 +0,0 @@
-#!/usr/bin/env node
-/**
- * 节点每轮执行进入 pre-process 时，统一把「上一轮遗留的当前文件」快照到
- *   <name>_<priorExecId>.<ext>
- * 形式。这是唯一的备份入口，替代分散在 write-result / build-node-prompt /
- * pre-process 内多种辅助 prompt / get-env / run-tool-nodejs 中的 rename 调用。
- *
- * 不变量：
- *   1. 文件后缀 `_K` 严格对应「第 K 轮结束时的文件内容」，无错位。
- *   2. unsuffixed（无 `_N` 后缀）= 当前最新版本，永远存在；snapshot 用 copy
- *      生成 `_K` 历史快照，不破坏 unsuffixed。下游运行时只 resolve unsuffixed，
- *      不应也不需要 fallback 到 `_K`。
- *   3. 幂等：目标 `_K.ext` 已存在或源文件已经是 `_K.ext` 形态，直接跳过。
- *
- * 调用方：bin/pipeline/pre-process-node.mjs 在计算 execId 后、任何 write 前。
- */
-import fs from "fs";
-import path from "path";
-
-import { intermediateDirForNode, outputDirForNode } from "./get-exec-id.mjs";
-
-const BACKUP_SUFFIX_RE = /_\d+$/;
-
-/**
- * @param {string} runDir - .workspace/agentflow/runBuild/<flowName>/<uuid>
- * @param {string} instanceId
- * @param {number} priorExecId - memory 里记录的「上一轮已完成 execId」，首轮传 0/undefined 直接返回
- */
-export function snapshotPriorRoundIfNeeded(runDir, instanceId, priorExecId) {
-  const prior = Number(priorExecId);
-  if (!Number.isFinite(prior) || prior < 1) return;
-  const suffix = `_${prior}`;
-
-  const interDir = path.join(runDir, intermediateDirForNode(instanceId));
-  snapshotDir(interDir, (f) => f.startsWith(instanceId + "."), suffix);
-
-  const outDir = path.join(runDir, outputDirForNode(instanceId));
-  snapshotDir(outDir, (f) => f.startsWith(`node_${instanceId}_`), suffix);
-}
-
-/**
- * @param {string} dir
- * @param {(filename: string) => boolean} predicate
- * @param {string} suffix - `_<N>`
- */
-function snapshotDir(dir, predicate, suffix) {
-  if (!fs.existsSync(dir)) return;
-  let files;
-  try {
-    files = fs.readdirSync(dir);
-  } catch {
-    return;
-  }
-  for (const f of files) {
-    if (!predicate(f)) continue;
-    const ext = path.extname(f);
-    const base = path.basename(f, ext);
-    // 已是备份文件（以 _\d+ 结尾），跳过
-    if (BACKUP_SUFFIX_RE.test(base)) continue;
-    const to = base + suffix + ext;
-    if (to === f) continue;
-    const toPath = path.join(dir, to);
-    if (fs.existsSync(toPath)) continue; // 幂等
-    try {
-      fs.copyFileSync(path.join(dir, f), toPath);
-    } catch {
-      // 并发或权限错误：放弃该文件，其它继续。unsuffixed 保留不动。
-    }
-  }
-}