@fieldwangai/agentflow 0.1.154 → 0.1.157

package/bin/lib/flow-dsl/cli.mjs

@@ -150,7 +150,7 @@ export function layoutWorkspaceFlowDir(flowDir, { all = false, workspaceRoot = "
 }
 
 /** 没有节点丢失时的空损耗清单，让返回值形状始终一致。 */
-const NO_LOSS = { remapped: [], dropped: [], droppedEdges: [], warnings: [] };
+const NO_LOSS = { remapped: [], dropped: [], droppedEdges: [], renamedIds: [], warnings: [] };
 
 /**
  * 把一个流程目录就地迁移成代码形态。两个来源：
@@ -207,6 +207,7 @@ function migrateLegacyYamlDir(dir, { force = false, marketplaceRoot = "" } = {})
     remapped: converted.remapped,
     dropped: converted.dropped,
     droppedEdges: converted.droppedEdges,
+    renamedIds: converted.renamedIds,
     warnings: converted.warnings,
   };
   // `control_end` 和指向它的边标了 benign——丢了等于没丢，不该拦住迁移。

package/bin/lib/flow-dsl/codegen.mjs

@@ -70,6 +70,25 @@ export function generateFlowSource(ir, opts = {}) {
     return rel;
   };
 
+  // 节点 id 就是顶层变量名，可能刚好叫 display / flow / file。节点 id 不能为了代码生成
+  // 偷偷改掉（那会变成另一张图），所以冲突时给 DSL API import 起别名：
+  // `import { display as displayApi } ...; const display = displayApi.markdown(...)`。
+  // 所有顶层标识符共用 taken；先给内置 API 占位，后面的输出解构和包 import 也会避开它们。
+  const taken = new Set(Object.keys(N));
+  const uniqueName = (base, fallback) => {
+    let name = isIdentifier(base) ? base : fallback;
+    if (taken.has(name)) name = fallback;
+    while (taken.has(name)) name += "_";
+    taken.add(name);
+    return name;
+  };
+  const flowApiRoots = ["agent", "control", "display", "file", "flow", "provide", "tool", "workspace"];
+  const flowApiBinding = new Map(flowApiRoots.map((root) => [root, uniqueName(root, `${root}Api`)]));
+  const apiCall = (name) => {
+    const [root, ...tail] = String(name || "").split(".");
+    return [flowApiBinding.get(root) || root, ...tail].join(".");
+  };
+
   // 同一个节点的 body 和某个引脚值可能都超阈值，文件名必须带槽名区分：都叫
   // `prompts/<id>.md` 的话两段不同的文本会写进同一个文件，往返时后写的覆盖先写的。
   const externalize = (id, slot, text) => {
@@ -83,7 +102,7 @@ export function generateFlowSource(ir, opts = {}) {
   };
   const textArg = (id, slot, text) => {
     const rel = externalize(id, slot, text);
-    return rel ? `file(${JSON.stringify(rel)})` : literal(text);
+    return rel ? `${apiCall("file")}(${JSON.stringify(rel)})` : literal(text);
   };
 
   const controlNext = new Map();
@@ -114,18 +133,6 @@ export function generateFlowSource(ir, opts = {}) {
     }),
   );
 
-  // 文件里所有顶层标识符共用一个命名空间：节点 id、解构出来的输出变量、import 绑定名。
-  // 分开发号就会撞——两个节点各有一个叫 ok 的自定义输出槽，是完全正常的图，但会生成两条
-  // `const { ok } = ...`，文件根本解析不回来。
-  const taken = new Set(Object.keys(N));
-  const uniqueName = (base, fallback) => {
-    let name = isIdentifier(base) ? base : fallback;
-    if (taken.has(name)) name = fallback;
-    while (taken.has(name)) name += "_";
-    taken.add(name);
-    return name;
-  };
-
   // 自定义输出槽通过解构暴露成变量：`const { storyId } = node;`
   const outVar = new Map();
   for (const [id, slots] of destructured) {
@@ -143,7 +150,7 @@ export function generateFlowSource(ir, opts = {}) {
     const shared = [...bindingOf.values()].find((v) => v.spec === pkg.specifier);
     bindingOf.set(id, shared || { name: uniqueName(base, `${base}Node`), spec: pkg.specifier });
   }
-  const callee = (id) => bindingOf.get(id)?.name || apiName(N[id].definitionId);
+  const callee = (id) => bindingOf.get(id)?.name || apiCall(apiName(N[id].definitionId));
 
   const bodyTextOf = (id) => String(
     (N[id].definitionId === "tool_nodejs" && N[id].script) ? N[id].script : (N[id].body || ""),
@@ -256,7 +263,7 @@ export function generateFlowSource(ir, opts = {}) {
   };
   const printItem = (item) => (
     Array.isArray(item)
-      ? `flow.fork(${item.map((s) => `flow(${s.map(printItem).join(", ")})`).join(", ")})`
+      ? `${apiCall("flow.fork")}(${item.map((s) => `${apiCall("flow")}(${s.map(printItem).join(", ")})`).join(", ")})`
       : item
   );
 
@@ -286,8 +293,8 @@ export function generateFlowSource(ir, opts = {}) {
     if (isIf(id)) {
       const thenIds = (controlNext.get(id) || []).filter((x) => x.slot === "next1").map((x) => x.to);
       const elseIds = (controlNext.get(id) || []).filter((x) => x.slot === "next2").map((x) => x.to);
-      args.push(`flow(${chainFrom(thenIds).map(printItem).join(", ")})`);
-      args.push(`flow(${chainFrom(elseIds).map(printItem).join(", ")})`);
+      args.push(`${apiCall("flow")}(${chainFrom(thenIds).map(printItem).join(", ")})`);
+      args.push(`${apiCall("flow")}(${chainFrom(elseIds).map(printItem).join(", ")})`);
     } else {
       const usesScript = node.definitionId === "tool_nodejs" && node.script;
       const body = usesScript ? node.script : node.body;
@@ -323,14 +330,14 @@ export function generateFlowSource(ir, opts = {}) {
     if (N[runId].label) head.push(literal(N[runId].label));
     // 排程配置存在 run 节点的 body 里，是 JSON 字符串
     if (definitionId === "workspace_scheduled_run") head.push(N[runId].body ? literal(N[runId].body) : "null");
-    const fn = definitionId === "workspace_scheduled_run" ? "flow.schedule" : "flow";
+    const fn = apiCall(definitionId === "workspace_scheduled_run" ? "flow.schedule" : "flow");
     out.push(`export const ${runId} = ${fn}(${[...head, ...seq].join(", ")});\n`);
   }
 
   // 一个 run 直接连到另一个 run：接力，不是子图
   for (const [src, list] of [...controlNext].sort()) {
     for (const x of list) {
-      if (RUN_DEFINITIONS.has(N[x.to].definitionId)) out.push(`flow.resume(${src}, ${x.to});\n`);
+      if (RUN_DEFINITIONS.has(N[x.to].definitionId)) out.push(`${apiCall("flow.resume")}(${src}, ${x.to});\n`);
     }
   }
 
@@ -339,13 +346,17 @@ export function generateFlowSource(ir, opts = {}) {
   for (const id of ids) {
     if (declared.has(id) || RUN_DEFINITIONS.has(N[id].definitionId) || controlTargets.has(id)) continue;
     if (!(controlNext.get(id) || []).length) continue;
-    out.push(`flow.detached(${chainFrom([id]).map(printItem).join(", ")});\n`);
+    out.push(`${apiCall("flow.detached")}(${chainFrom([id]).map(printItem).join(", ")});\n`);
   }
   for (const id of ids) {
     if (!declared.has(id) && !RUN_DEFINITIONS.has(N[id].definitionId)) declare(id, true);
   }
 
-  const imports = [`import { agent, control, display, file, flow, provide, tool, workspace } from "agentflow/flow";`];
+  const flowImports = flowApiRoots.map((root) => {
+    const local = flowApiBinding.get(root);
+    return local === root ? root : `${root} as ${local}`;
+  });
+  const imports = [`import { ${flowImports.join(", ")} } from "agentflow/flow";`];
   const seenBinding = new Set();
   for (const id of ids) {
     const binding = bindingOf.get(id);

package/bin/lib/flow-dsl/legacy-yaml.mjs

@@ -67,6 +67,34 @@ function slotsOf(instance, definitionId, kind) {
 
 const isNodeSlot = (slot) => String(slot?.type || "") === "node";
 
+// DSL 里的节点 id 同时也是顶层 `const` 变量名。旧 YAML 允许 `foo-bar`、数字开头，
+// 甚至 JS 关键字；直接交给 codegen 会生成无法解析的 workspace.flow.js，整张图只能退回
+// graph.json。迁移时稳定地改成合法且唯一的绑定名，并把改名清单返回给调用方。
+const JS_RESERVED_WORDS = new Set([
+  "arguments", "await", "break", "case", "catch", "class", "const", "continue", "debugger", "default",
+  "delete", "do", "else", "enum", "export", "extends", "false", "finally", "for", "function",
+  "if", "implements", "import", "in", "instanceof", "interface", "let", "new", "null", "package", "eval",
+  "private", "protected", "public", "return", "static", "super", "switch", "this", "throw", "true",
+  "try", "typeof", "var", "void", "while", "with", "yield",
+]);
+
+function legacyNodeIdMap(ids) {
+  const used = new Set();
+  const mapping = new Map();
+  for (const raw of ids) {
+    let base = String(raw || "").replace(/[^A-Za-z0-9_$]/g, "_");
+    if (!/^[A-Za-z_$]/.test(base)) base = `node_${base}`;
+    if (!base) base = "node";
+    if (JS_RESERVED_WORDS.has(base)) base = `${base}_node`;
+    let next = base;
+    let suffix = 2;
+    while (used.has(next)) next = `${base}_${suffix++}`;
+    used.add(next);
+    mapping.set(raw, next);
+  }
+  return mapping;
+}
+
 /**
  * 把老实例的槽位搬到新定义的槽位表上：先对名字，对不上的按位置兜底。
  *
@@ -121,6 +149,7 @@ function rebuildSlots(oldSlots, newDefSlots) {
  *   remapped: Array<{ id: string, from: string, to: string, caveat?: string }>,
  *   dropped: Array<{ id: string, definitionId: string, reason: string }>,
  *   droppedEdges: Array<{ source: string, target: string, reason: string }>,
+ *   renamedIds: Array<{ from: string, to: string }>,
  *   warnings: string[],
  * }}
  */
@@ -129,10 +158,14 @@ export function legacyYamlToDesignGraph(yamlText) {
   if (!parsed || typeof parsed !== "object") throw new Error("flow.yaml 解析不出对象");
   const srcInstances = parsed.instances && typeof parsed.instances === "object" ? parsed.instances : {};
   const srcEdges = Array.isArray(parsed.edges) ? parsed.edges : [];
+  const idMap = legacyNodeIdMap(Object.keys(srcInstances));
 
   const remapped = [];
   const dropped = [];
   const droppedEdges = [];
+  const renamedIds = [...idMap]
+    .filter(([from, to]) => from !== to)
+    .map(([from, to]) => ({ from, to }));
   const warnings = [];
 
   /** id -> { input, output, renameIn, renameOut }，用来重接边。 */
@@ -141,7 +174,8 @@ export function legacyYamlToDesignGraph(yamlText) {
   const benignDrops = new Set();
   const instances = {};
 
-  for (const [id, raw] of Object.entries(srcInstances)) {
+  for (const [legacyId, raw] of Object.entries(srcInstances)) {
+    const id = idMap.get(legacyId);
     const instance = raw && typeof raw === "object" ? raw : {};
     const from = String(instance.definitionId || "");
     const oldIn = slotsOf(instance, from, "input");
@@ -154,17 +188,17 @@ export function legacyYamlToDesignGraph(yamlText) {
     // 终点节点本来就没有对应物需要表达。所以标 benign——报出来，但不算有损。
     if (hasRemap && to === null) {
       dropped.push({
-        id,
+        id: legacyId,
         definitionId: from,
         benign: true,
         reason: "Workspace 没有终点节点，跑到没有后继就结束",
       });
-      benignDrops.add(id);
+      benignDrops.add(legacyId);
       continue;
     }
     if (!hasRemap && definitionOf(from).runtime === "none") {
       dropped.push({
-        id,
+        id: legacyId,
         definitionId: from,
         benign: false,
         reason: DEFINITIONS[from]
@@ -180,13 +214,14 @@ export function legacyYamlToDesignGraph(yamlText) {
       const rebuiltOut = rebuildSlots(oldOut, def.output || []);
       const next = { ...instance, definitionId: to, input: rebuiltIn.slots, output: rebuiltOut.slots };
       instances[id] = next;
-      kept.set(id, {
+      kept.set(legacyId, {
+        id,
         input: next.input,
         output: next.output,
         renameIn: rebuiltIn.renames,
         renameOut: rebuiltOut.renames,
       });
-      const entry = { id, from, to };
+      const entry = { id: legacyId, from, to };
       const droppedFields = [];
       for (const field of REMAP_DROPPED_FIELDS[to] || []) {
         const text = String(next[field] ?? "").trim();
@@ -204,7 +239,7 @@ export function legacyYamlToDesignGraph(yamlText) {
       // 拿定义去覆盖会把作者加的输入抹掉。
       const next = { ...instance, input: [...oldIn], output: [...oldOut] };
       instances[id] = next;
-      kept.set(id, { input: next.input, output: next.output, renameIn: new Map(), renameOut: new Map() });
+      kept.set(legacyId, { id, input: next.input, output: next.output, renameIn: new Map(), renameOut: new Map() });
     }
   }
 
@@ -241,28 +276,28 @@ export function legacyYamlToDesignGraph(yamlText) {
     }
     // Workspace 禁止 fan-in：同一个输入槽只能有一条入边。老图里靠 control_anyOne
     // 汇合的分支，删掉汇合点之后会撞在同一个槽上。
-    const key = `${target} input-${tgtIdx}`;
+    const key = `${to.id} input-${tgtIdx}`;
     if (takenTargets.has(key)) {
       droppedEdges.push({ source, target, benign: false, reason: `${target}.${tgtFinal} 已经有入边了，Workspace 不允许 fan-in` });
       continue;
     }
     takenTargets.add(key);
-    edges.push({ source, target, sourceHandle: `output-${srcIdx}`, targetHandle: `input-${tgtIdx}` });
+    edges.push({ source: from.id, target: to.id, sourceHandle: `output-${srcIdx}`, targetHandle: `input-${tgtIdx}` });
   }
 
   // ── ui ────────────────────────────────────────────────────────────────────
   const srcUi = parsed.ui && typeof parsed.ui === "object" ? parsed.ui : {};
   const nodePositions = {};
   for (const [id, pos] of Object.entries(srcUi.nodePositions || {})) {
-    if (kept.has(id)) nodePositions[id] = pos;
+    if (kept.has(id)) nodePositions[kept.get(id).id] = pos;
   }
   const ui = { nodePositions, nodeSizes: {} };
   if (typeof srcUi.description === "string" && srcUi.description.trim()) ui.description = srcUi.description;
 
   if (!Object.keys(instances).length) warnings.push("迁移之后一个节点都不剩");
-  else if (![...kept.keys()].some((id) => instances[id].definitionId === "workspace_run")) {
+  else if (![...kept.values()].some(({ id }) => instances[id].definitionId === "workspace_run")) {
     warnings.push("图里没有运行节点（老流程缺 control_start）；补一个 workspace_run 才能跑");
   }
 
-  return { graph: { version: 1, instances, edges, ui }, remapped, dropped, droppedEdges, warnings };
+  return { graph: { version: 1, instances, edges, ui }, remapped, dropped, droppedEdges, renamedIds, warnings };
 }

package/bin/lib/flow-dsl/parser.mjs

@@ -59,6 +59,26 @@ export function parseFlowSource(source, opts = {}) {
     unresolved.push({ line: node?.loc?.start?.line || 0, message });
   };
 
+  // codegen 在节点 id 与 DSL API 名冲突时会生成
+  // `import { display as displayApi } from "agentflow/flow"`。静态解析时先把 local 名还原成
+  // canonical API 名，后面的节点类型、flow 控制语句和 file() 才仍走同一套规则。
+  const flowApiOf = new Map();
+  for (const stmt of ast.body) {
+    if (stmt.type !== "ImportDeclaration" || String(stmt.source.value) !== "agentflow/flow") continue;
+    for (const specifier of stmt.specifiers || []) {
+      if (specifier.type !== "ImportSpecifier") continue;
+      const imported = specifier.imported?.name ?? specifier.imported?.value;
+      const local = specifier.local?.name;
+      if (imported && local) flowApiOf.set(local, String(imported));
+    }
+  }
+  const apiCalleePath = (node) => {
+    const raw = calleePath(node);
+    if (!raw) return raw;
+    const [root, ...tail] = raw.split(".");
+    return [flowApiOf.get(root) || root, ...tail].join(".");
+  };
+
   function stringOf(node) {
     if (!node) return null;
     if (node.type === "Literal" && typeof node.value === "string") return node.value;
@@ -72,7 +92,7 @@ export function parseFlowSource(source, opts = {}) {
       return String(node.operator === "-" ? -node.argument.value : node.argument.value);
     }
     if (node.type === "TemplateLiteral" && node.expressions.length === 0) return node.quasis[0].value.cooked;
-    if (node.type === "CallExpression" && calleePath(node.callee) === "file") {
+    if (node.type === "CallExpression" && apiCalleePath(node.callee) === "file") {
       const rel = stringOf(node.arguments[0]);
       if (rel == null) return null;
       if (!(rel in files)) throw new Error(`file(${JSON.stringify(rel)}) 找不到对应文件`);
@@ -229,7 +249,7 @@ export function parseFlowSource(source, opts = {}) {
     const out = [];
     for (const arg of call.arguments) {
       if (arg.type === "Identifier") out.push(arg.name);
-      else if (arg.type === "CallExpression" && calleePath(arg.callee) === "flow.fork") {
+      else if (arg.type === "CallExpression" && apiCalleePath(arg.callee) === "flow.fork") {
         out.push({ fork: arg.arguments.map(itemsOf) });
       } else {
         unresolvedAt(arg, "控制流参数只能是节点变量名或 flow.fork(...)");
@@ -277,7 +297,7 @@ export function parseFlowSource(source, opts = {}) {
         unresolvedAt(d, `${id}: 节点声明右边必须是一次节点调用`);
         continue;
       }
-      const path = calleePath(init.callee);
+      const path = apiCalleePath(init.callee);
       const args = [...init.arguments];
 
       const first = args[0];
@@ -384,7 +404,7 @@ export function parseFlowSource(source, opts = {}) {
     }
 
     if (decl?.type === "ExpressionStatement" && decl.expression.type === "CallExpression") {
-      const path = calleePath(decl.expression.callee);
+      const path = apiCalleePath(decl.expression.callee);
       if (path === "flow.resume") {
         const [a, b] = decl.expression.arguments.map((x) => x.name);
         if (a && b) edges.push(`${a}|next|${b}|prev`);