@fieldwangai/agentflow 0.1.25

package/bin/lib/workspace-tree.mjs

@@ -0,0 +1,266 @@
+/**
+ * 获取工作区目录树结构，用于 UI 工作区面板展开显示
+ */
+import fs from "fs";
+import path from "path";
+import {
+  PIPELINES_DIR,
+  LEGACY_PIPELINES_DIR,
+  ARCHIVED_PIPELINES_DIR_NAME,
+  getUserPipelinesRoot,
+  PACKAGE_BUILTIN_PIPELINES_DIR,
+} from "./paths.mjs";
+import { listAllRunDirs } from "./workspace.mjs";
+
+/**
+ * 获取目录下的子目录列表
+ * @param {string} dir
+ * @returns {Array<{name: string, path: string}>}
+ */
+function getSubdirectories(dir) {
+  if (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory()) {
+    return [];
+  }
+  try {
+    return fs
+      .readdirSync(dir, { withFileTypes: true })
+      .filter((e) => e.isDirectory() && !e.name.startsWith("."))
+      .map((e) => ({ name: e.name, path: path.join(dir, e.name) }));
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * 获取工作区树形结构
+ * @param {string} workspaceRoot
+ * @returns {{
+ *   pipelines: Array<{id: string, source: 'workspace', archived?: boolean}>,
+ *   runs: Array<{flowId: string, runs: Array<{runId: string, at: number}>}>
+ * }}
+ */
+export function getWorkspaceTree(workspaceRoot) {
+  const root = path.resolve(workspaceRoot);
+
+  // 1. 获取 pipelines 列表
+  const pipelines = [];
+  const seenPipelineIds = new Set();
+
+  // 主路径: .workspace/agentflow/pipelines
+  const wsPipelinesDir = path.join(root, PIPELINES_DIR);
+  const wsPipelines = getSubdirectories(wsPipelinesDir).filter(
+    (d) => d.name !== ARCHIVED_PIPELINES_DIR_NAME
+  );
+  for (const p of wsPipelines) {
+    if (!seenPipelineIds.has(p.name)) {
+      seenPipelineIds.add(p.name);
+      pipelines.push({ id: p.name, source: "workspace" });
+    }
+  }
+
+  // 归档路径: .workspace/agentflow/pipelines/_archived
+  const wsArchivedDir = path.join(wsPipelinesDir, ARCHIVED_PIPELINES_DIR_NAME);
+  const wsArchived = getSubdirectories(wsArchivedDir);
+  for (const p of wsArchived) {
+    if (!seenPipelineIds.has(p.name)) {
+      seenPipelineIds.add(p.name);
+      pipelines.push({ id: p.name, source: "workspace", archived: true });
+    }
+  }
+
+  // 旧版路径: .cursor/agentflow/pipelines (兼容读取)
+  const legacyPipelinesDir = path.join(root, LEGACY_PIPELINES_DIR);
+  const legacyPipelines = getSubdirectories(legacyPipelinesDir).filter(
+    (d) => d.name !== ARCHIVED_PIPELINES_DIR_NAME
+  );
+  for (const p of legacyPipelines) {
+    if (!seenPipelineIds.has(p.name)) {
+      seenPipelineIds.add(p.name);
+      pipelines.push({ id: p.name, source: "workspace" });
+    }
+  }
+
+  // 旧版归档路径
+  const legacyArchivedDir = path.join(legacyPipelinesDir, ARCHIVED_PIPELINES_DIR_NAME);
+  const legacyArchived = getSubdirectories(legacyArchivedDir);
+  for (const p of legacyArchived) {
+    if (!seenPipelineIds.has(p.name)) {
+      seenPipelineIds.add(p.name);
+      pipelines.push({ id: p.name, source: "workspace", archived: true });
+    }
+  }
+
+  // 2. 获取 runs 列表 (按 flowId 分组) —— 走统一的 listAllRunDirs，新旧位置都覆盖
+  const runsMap = new Map();
+
+  for (const { flowName: flowId, uuid, runDir } of listAllRunDirs(root)) {
+    let at = 0;
+    try {
+      const memoryPath = path.join(runDir, "memory.md");
+      if (fs.existsSync(memoryPath)) {
+        const content = fs.readFileSync(memoryPath, "utf-8");
+        for (const line of content.split(/\r?\n/)) {
+          const idx = line.indexOf(": ");
+          if (idx > 0 && line.slice(0, idx).trim() === "runStartTime") {
+            const v = line.slice(idx + 2).trim();
+            const n = parseInt(v, 10);
+            if (Number.isFinite(n) && n >= 0) {
+              at = n;
+              break;
+            }
+          }
+        }
+      }
+      if (at === 0) {
+        at = fs.statSync(runDir).mtimeMs;
+      }
+    } catch {
+      try {
+        at = fs.statSync(runDir).mtimeMs;
+      } catch {
+        at = 0;
+      }
+    }
+
+    if (!runsMap.has(flowId)) {
+      runsMap.set(flowId, []);
+    }
+    runsMap.get(flowId).push({ runId: uuid, at });
+  }
+
+  // 转换 runsMap 为数组，并排序
+  const runs = [];
+  for (const [flowId, flowRuns] of runsMap) {
+    flowRuns.sort((a, b) => b.at - a.at); // 最新的在前
+    runs.push({ flowId, runs: flowRuns.slice(0, 10) }); // 每个 flow 最多显示 10 个
+  }
+  runs.sort((a, b) => {
+    const aLatest = a.runs[0]?.at || 0;
+    const bLatest = b.runs[0]?.at || 0;
+    return bLatest - aLatest; // 按最新运行时间排序
+  });
+
+  return { pipelines, runs };
+}
+
+const FILE_ICON_MAP = {
+  ".yaml": "description",
+  ".yml": "description",
+  ".mjs": "code",
+  ".js": "code",
+  ".ts": "code",
+  ".json": "data_object",
+  ".md": "article",
+  ".txt": "note",
+};
+
+function getFileIcon(fileName) {
+  const ext = path.extname(fileName).toLowerCase();
+  return FILE_ICON_MAP[ext] || "draft";
+}
+
+function getDirectoryIcon(dirName) {
+  if (dirName === "scripts") return "terminal";
+  if (dirName === "nodes") return "hub";
+  return "folder";
+}
+
+function readFileSize(filePath) {
+  try {
+    const stats = fs.statSync(filePath);
+    return stats.size;
+  } catch {
+    return 0;
+  }
+}
+
+function readFilesRecursive(dir, baseDir, maxDepth = 2, currentDepth = 0) {
+  if (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory()) {
+    return [];
+  }
+  if (currentDepth >= maxDepth) {
+    return [];
+  }
+  try {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    const result = [];
+    for (const entry of entries) {
+      if (entry.name.startsWith(".")) continue;
+      const entryPath = path.join(dir, entry.name);
+      const relativePath = path.relative(baseDir, entryPath);
+      if (entry.isDirectory()) {
+        const children = readFilesRecursive(entryPath, baseDir, maxDepth, currentDepth + 1);
+        result.push({
+          name: entry.name,
+          type: "directory",
+          icon: getDirectoryIcon(entry.name),
+          path: relativePath,
+          children,
+        });
+      } else if (entry.isFile()) {
+        result.push({
+          name: entry.name,
+          type: "file",
+          icon: getFileIcon(entry.name),
+          path: relativePath,
+          size: readFileSize(entryPath),
+        });
+      }
+    }
+    result.sort((a, b) => {
+      if (a.type !== b.type) return a.type === "directory" ? -1 : 1;
+      if (a.name === "flow.yaml") return -1;
+      if (b.name === "flow.yaml") return 1;
+      if (a.name === "scripts") return -1;
+      if (b.name === "scripts") return 1;
+      return a.name.localeCompare(b.name);
+    });
+    return result;
+  } catch {
+    return [];
+  }
+}
+
+export function getPipelineFiles(workspaceRoot, flowId, flowSource, archived = false) {
+  const root = path.resolve(workspaceRoot);
+  let pipelineDir = null;
+
+  if (archived) {
+    if (flowSource === "user") {
+      pipelineDir = path.join(getUserPipelinesRoot(), ARCHIVED_PIPELINES_DIR_NAME, flowId);
+    } else if (flowSource === "workspace") {
+      pipelineDir = path.join(root, PIPELINES_DIR, ARCHIVED_PIPELINES_DIR_NAME, flowId);
+      if (!fs.existsSync(pipelineDir)) {
+        const alt = path.join(root, LEGACY_PIPELINES_DIR, ARCHIVED_PIPELINES_DIR_NAME, flowId);
+        if (fs.existsSync(alt)) pipelineDir = alt;
+      }
+    }
+  } else {
+    if (flowSource === "builtin") {
+      pipelineDir = path.join(PACKAGE_BUILTIN_PIPELINES_DIR, flowId);
+    } else if (flowSource === "user") {
+      pipelineDir = path.join(getUserPipelinesRoot(), flowId);
+      if (!fs.existsSync(pipelineDir)) {
+        const alt = path.join(root, PIPELINES_DIR, flowId);
+        if (fs.existsSync(alt)) pipelineDir = alt;
+      }
+      if (!fs.existsSync(pipelineDir)) {
+        const altLeg = path.join(root, LEGACY_PIPELINES_DIR, flowId);
+        if (fs.existsSync(altLeg)) pipelineDir = altLeg;
+      }
+    } else if (flowSource === "workspace") {
+      pipelineDir = path.join(root, PIPELINES_DIR, flowId);
+      if (!fs.existsSync(pipelineDir)) {
+        const altLeg = path.join(root, LEGACY_PIPELINES_DIR, flowId);
+        if (fs.existsSync(altLeg)) pipelineDir = altLeg;
+      }
+    }
+  }
+
+  if (!pipelineDir || !fs.existsSync(pipelineDir) || !fs.statSync(pipelineDir).isDirectory()) {
+    return { files: [], error: "Pipeline directory not found" };
+  }
+
+  const files = readFilesRecursive(pipelineDir, pipelineDir, 2, 0);
+  return { files, path: pipelineDir };
+}

package/bin/lib/workspace.mjs

@@ -0,0 +1,180 @@
+import fs from "fs";
+import path from "path";
+import {
+  LEGACY_PIPELINES_DIR,
+  PACKAGE_BUILTIN_PIPELINES_DIR,
+  PACKAGE_REFERENCE_DIR,
+  PIPELINES_DIR,
+  getLegacyUserRunBuildRoot,
+  getReferenceRootAbs,
+  getWorkspaceRunBuildRoot,
+  getUserPipelinesRoot,
+  ARCHIVED_PIPELINES_DIR_NAME,
+} from "./paths.mjs";
+
+export { getRunDir } from "./paths.mjs";
+
+/**
+ * 枚举所有 run 目录（新 per-flow 位置 + 旧 runBuild root 位置）。
+ * 返回扁平列表：{ flowName, uuid, runDir, source }，source ∈ { user, workspace, legacyWorkspaceRoot, legacyUserRoot }
+ * - user: ~/agentflow/pipelines/<name>/runBuild/<uuid>
+ * - workspace: <ws>/.workspace/agentflow/pipelines/<name>/runBuild/<uuid>
+ * - legacyWorkspaceRoot: <ws>/.workspace/agentflow/runBuild/<name>/<uuid>
+ * - legacyUserRoot: ~/agentflow/runBuild/<name>/<uuid>
+ * 后两者仅作为向下兼容读取；新写入只走 user/workspace。
+ */
+export function listAllRunDirs(workspaceRoot) {
+  const root = path.resolve(workspaceRoot);
+  const out = [];
+  const seen = new Set();
+  const add = (flowName, uuid, runDir, source) => {
+    const key = `${flowName}\t${uuid}`;
+    if (seen.has(key)) return;
+    if (!fs.existsSync(runDir)) return;
+    seen.add(key);
+    out.push({ flowName, uuid, runDir, source });
+  };
+
+  const scanPipelinesDir = (pipelinesDir, source) => {
+    if (!fs.existsSync(pipelinesDir)) return;
+    let entries;
+    try {
+      entries = fs.readdirSync(pipelinesDir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      if (!e.isDirectory()) continue;
+      if (e.name === ARCHIVED_PIPELINES_DIR_NAME) continue;
+      const runBuildDir = path.join(pipelinesDir, e.name, "runBuild");
+      if (!fs.existsSync(runBuildDir)) continue;
+      let uuids;
+      try {
+        uuids = fs.readdirSync(runBuildDir, { withFileTypes: true });
+      } catch {
+        continue;
+      }
+      for (const u of uuids) {
+        if (!u.isDirectory()) continue;
+        add(e.name, u.name, path.join(runBuildDir, u.name), source);
+      }
+    }
+  };
+
+  // 新位置（优先）
+  scanPipelinesDir(getUserPipelinesRoot(), "user");
+  scanPipelinesDir(path.join(root, PIPELINES_DIR), "workspace");
+
+  // 旧位置（兼容读）
+  const scanLegacyRoot = (runBuildDir, source) => {
+    if (!fs.existsSync(runBuildDir)) return;
+    let flowEntries;
+    try {
+      flowEntries = fs.readdirSync(runBuildDir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const fe of flowEntries) {
+      if (!fe.isDirectory()) continue;
+      const flowRunDir = path.join(runBuildDir, fe.name);
+      let uuids;
+      try {
+        uuids = fs.readdirSync(flowRunDir, { withFileTypes: true });
+      } catch {
+        continue;
+      }
+      for (const u of uuids) {
+        if (!u.isDirectory()) continue;
+        add(fe.name, u.name, path.join(flowRunDir, u.name), source);
+      }
+    }
+  };
+  scanLegacyRoot(getWorkspaceRunBuildRoot(root), "legacyWorkspaceRoot");
+  scanLegacyRoot(getLegacyUserRunBuildRoot(), "legacyUserRoot");
+
+  return out;
+}
+
+/**
+ * 确保用户数据目录下 reference 存在且含包内 reference 文件。
+ */
+export function ensureReference(_workspaceRoot) {
+  const destDir = getReferenceRootAbs();
+  if (!fs.existsSync(PACKAGE_REFERENCE_DIR) || !fs.statSync(PACKAGE_REFERENCE_DIR).isDirectory()) return;
+  try {
+    fs.mkdirSync(destDir, { recursive: true });
+    const names = fs.readdirSync(PACKAGE_REFERENCE_DIR);
+    for (const name of names) {
+      const srcFile = path.join(PACKAGE_REFERENCE_DIR, name);
+      if (fs.statSync(srcFile).isFile()) {
+        const destFile = path.join(destDir, name);
+        if (!fs.existsSync(destFile)) fs.copyFileSync(srcFile, destFile);
+      }
+    }
+  } catch (_) {}
+}
+
+/** 列出所有存在 logs/log.txt 的 run，供 extract-thinking -list 使用。 */
+export function listRunsWithLogs(workspaceRoot) {
+  const list = [];
+  for (const { flowName, uuid, runDir } of listAllRunDirs(workspaceRoot)) {
+    const logPath = path.join(runDir, "logs", "log.txt");
+    if (!fs.existsSync(logPath)) continue;
+    let size = 0;
+    let lines = 0;
+    try {
+      const stat = fs.statSync(logPath);
+      size = stat.size;
+      const c = fs.readFileSync(logPath, "utf8");
+      lines = c.split(/\r?\n/).length;
+    } catch (_) {}
+    list.push({ flowName, uuid, logPath, size, lines });
+  }
+  list.sort((a, b) => {
+    const fc = a.flowName.localeCompare(b.flowName);
+    if (fc !== 0) return fc;
+    return a.uuid.localeCompare(b.uuid);
+  });
+  return list;
+}
+
+/** 解析 flow 目录：~/agentflow/pipelines → .workspace/agentflow/pipelines → .cursor/agentflow/pipelines（旧）→ builtin/pipelines */
+export function getFlowDir(workspaceRoot, flowName) {
+  const root = path.resolve(workspaceRoot);
+  const hasFlow = (dir) => fs.existsSync(dir) && fs.existsSync(path.join(dir, "flow.yaml"));
+
+  // user pipelines
+  const userRoot = getUserPipelinesRoot();
+  const userFlowDir = path.join(userRoot, flowName);
+  if (hasFlow(userFlowDir)) return userFlowDir;
+  // user archived
+  const userArchivedDir = path.join(userRoot, ARCHIVED_PIPELINES_DIR_NAME, flowName);
+  if (hasFlow(userArchivedDir)) return userArchivedDir;
+
+  // workspace pipelines
+  const wsFlowDir = path.join(root, PIPELINES_DIR, flowName);
+  if (hasFlow(wsFlowDir)) return wsFlowDir;
+  // workspace archived
+  const wsArchivedDir = path.join(root, PIPELINES_DIR, ARCHIVED_PIPELINES_DIR_NAME, flowName);
+  if (hasFlow(wsArchivedDir)) return wsArchivedDir;
+
+  // legacy
+  const legacyFlowDir = path.join(root, LEGACY_PIPELINES_DIR, flowName);
+  if (hasFlow(legacyFlowDir)) return legacyFlowDir;
+
+  // builtin
+  const builtinFlowDir = path.join(PACKAGE_BUILTIN_PIPELINES_DIR, flowName);
+  if (hasFlow(builtinFlowDir)) return builtinFlowDir;
+
+  return null;
+}
+
+/** 两参 replay 时根据 uuid 查找 run 目录，返回 flowName 或 null。 */
+export function findFlowNameByUuid(workspaceRoot, uuid) {
+  for (const entry of listAllRunDirs(workspaceRoot)) {
+    if (entry.uuid !== uuid) continue;
+    const flowJsonPath = path.join(entry.runDir, "intermediate", "flow.json");
+    if (fs.existsSync(flowJsonPath)) return entry.flowName;
+  }
+  return null;
+}

package/bin/pipeline/build-node-prompt.mjs

@@ -0,0 +1,179 @@
+#!/usr/bin/env node
+/**
+ * 执行占位符替换，组装最终 prompt 并写入 intermediate 文件。
+ * 用法：node build-node-prompt.mjs <workspaceRoot> <flowName> <uuid> <instanceId>
+ * 输出（stdout JSON）：{ "ok": true, "promptPath": ".workspace/agentflow/runBuild/<flowName>/<uuid>/intermediate/<instanceId>.prompt.md" }
+ */
+
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+
+import { getRunDir, PIPELINES_DIR } from "../lib/paths.mjs";
+import { getFlowDir } from "../lib/workspace.mjs";
+import { loadFlowDefinition } from "./parse-flow.mjs";
+import { getResolvedValues, getOutputPathForSlot } from "./get-resolved-values.mjs";
+import { loadExecId } from "./get-exec-id.mjs";
+import { intermediatePromptBasename, intermediateDirForNode } from "./get-exec-id.mjs";
+
+function shellQuote(s) {
+  if (s == null) return "''";
+  return "'" + String(s).replace(/'/g, "'\\''") + "'";
+}
+
+function resolvePlaceholder(k, resolvedInputs, resolvedOutputs, opts) {
+  const { instanceId, currentExecId, runDir } = opts;
+  const execId = currentExecId ?? 1;
+  const toAbs = (rel) => (runDir && rel ? path.join(runDir, rel) : rel);
+  if (k.startsWith("input.")) {
+    const slot = k.slice(6);
+    return resolvedInputs[slot] ?? resolvedInputs._ ?? "";
+  }
+  if (k.startsWith("output.")) {
+    const slot = k.slice(7);
+    const v = resolvedOutputs[slot] ?? resolvedOutputs._ ?? "";
+    if (v) return v;
+    if (instanceId && slot in resolvedOutputs) {
+      return toAbs(getOutputPathForSlot(instanceId, execId, slot));
+    }
+    return "";
+  }
+  let v = resolvedInputs[k] ?? resolvedOutputs[k] ?? "";
+  if (!v && !k.includes(".")) {
+    v = resolvedInputs[k + ".md"] ?? resolvedOutputs[k + ".md"] ?? "";
+  }
+  if (!v && instanceId && (k in resolvedOutputs || (k + ".md") in resolvedOutputs)) {
+    const slot = k in resolvedOutputs ? k : k + ".md";
+    v = toAbs(getOutputPathForSlot(instanceId, execId, slot));
+  }
+  return v;
+}
+
+function resolvePlaceholdersInText(
+  text,
+  resolvedInputs,
+  resolvedOutputs,
+  opts = {},
+) {
+  if (!text || typeof text !== "string") return "";
+  return text.replace(/\$\{([^}]+)\}/g, (_, key) => {
+    return resolvePlaceholder(key.trim(), resolvedInputs, resolvedOutputs, opts);
+  });
+}
+
+/**
+ * 解析 script 字段中的 ${} 占位符，每个替换值用 shell 单引号包裹，避免路径含空格/特殊字符时被 shell 误拆分。
+ */
+function resolveScriptCommand(
+  text,
+  resolvedInputs,
+  resolvedOutputs,
+  opts = {},
+) {
+  if (!text || typeof text !== "string") return "";
+  return text.replace(/\$\{([^}]+)\}/g, (_, key) => {
+    return shellQuote(resolvePlaceholder(key.trim(), resolvedInputs, resolvedOutputs, opts));
+  });
+}
+
+/**
+ * 执行占位符替换，组装 prompt 并写入 intermediate 文件（文件名带 _execId）。
+ * @param {number} [execId] - 本轮 execId，缺省则从 memory 读取
+ * @returns {{ ok: boolean, promptPath?: string, nodeContext?: string, taskBody?: string, error?: string }}
+ */
+export function buildNodePrompt(workspaceRoot, flowName, uuid, instanceId, execId) {
+  const runDir = getRunDir(workspaceRoot, flowName, uuid);
+  const flowJsonPath = path.join(runDir, "intermediate", "flow.json");
+  let flowDir = getFlowDir(workspaceRoot, flowName) || path.join(workspaceRoot, PIPELINES_DIR, flowName);
+  if (fs.existsSync(flowJsonPath)) {
+    try {
+      const flow = JSON.parse(fs.readFileSync(flowJsonPath, "utf-8"));
+      if (flow?.flowDir && typeof flow.flowDir === "string" && flow.flowDir.trim()) {
+        flowDir = path.isAbsolute(flow.flowDir) ? flow.flowDir : path.join(workspaceRoot, flow.flowDir);
+      }
+    } catch (_) {}
+  }
+  const nodeIntermediateDir = path.join(runDir, intermediateDirForNode(instanceId));
+  const e = execId ?? loadExecId(workspaceRoot, flowName, uuid, instanceId);
+  const promptBasename = intermediatePromptBasename(instanceId, e);
+  const promptPath = path.join(nodeIntermediateDir, promptBasename);
+
+  const data = getResolvedValues(workspaceRoot, flowName, uuid, instanceId);
+  if (!data.ok) {
+    return { ok: false, error: data.error || "get-resolved-values failed" };
+  }
+
+  const flowData = loadFlowDefinition(flowDir);
+  const inst = flowData?.instances?.[instanceId];
+  const instanceBody =
+    inst?.body != null
+      ? String(inst.body || "").trim()
+      : "";
+  const instanceScript =
+    inst?.script != null
+      ? String(inst.script || "").trim()
+      : "";
+
+  const { resolvedInputs = {}, resolvedOutputs = {}, systemPrompt = "" } = data;
+  const resolveOpts = { instanceId, currentExecId: e, runDir };
+  const taskBody = resolvePlaceholdersInText(
+    instanceBody,
+    resolvedInputs,
+    resolvedOutputs,
+    resolveOpts,
+  );
+
+  const resolvedScript = instanceScript
+    ? resolveScriptCommand(instanceScript, resolvedInputs, resolvedOutputs, resolveOpts)
+    : "";
+
+  const content = `## 节点上下文
+
+${systemPrompt || "(无)"}
+
+## 执行任务
+
+${taskBody || "(无)"}
+`;
+
+  try {
+    fs.mkdirSync(nodeIntermediateDir, { recursive: true });
+    // 备份由 snapshotPriorRoundIfNeeded 在 pre-process 入口统一处理；
+    // 本函数可能在单轮内被多次调用（pre-process + computeCacheMd5），
+    // 但 round 内内容相同，直接覆盖写即可，不会产生伪历史备份。
+    fs.writeFileSync(promptPath, content, "utf-8");
+  } catch (e) {
+    return { ok: false, error: e.message || "Failed to write prompt file" };
+  }
+
+  const relativePath = path.relative(workspaceRoot, promptPath);
+  return {
+    ok: true,
+    promptPath: relativePath.replace(/\\/g, "/"),
+    nodeContext: systemPrompt || "",
+    taskBody: taskBody || "",
+    script: resolvedScript || "",
+  };
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  if (args.length < 4) {
+    console.error(
+      JSON.stringify({
+        ok: false,
+        error: "Usage: node build-node-prompt.mjs <workspaceRoot> <flowName> <uuid> <instanceId>",
+      }),
+    );
+    process.exit(1);
+  }
+
+  const [root, flowName, uuid, instanceId] = args;
+  const workspaceRoot = path.resolve(root);
+  const result = buildNodePrompt(workspaceRoot, flowName, uuid, instanceId, undefined);
+  console.log(JSON.stringify(result));
+  if (!result.ok) process.exit(1);
+}
+
+const isMain = process.argv[1] && path.resolve(fileURLToPath(import.meta.url)) === path.resolve(process.argv[1]);
+if (isMain) main();