@synergenius/flow-weaver 0.33.2 → 0.44.0

package/dist/cli/flow-weaver-chunk-HQ3ZAN44.mjs

@@ -0,0 +1,367 @@
+import { createRequire as __createRequire } from "module";
+const require = __createRequire(import.meta.url);
+import {
+  safeWriteFile
+} from "./flow-weaver-chunk-NYZDQYFU.mjs";
+import {
+  buildDiagramGraph,
+  renderASCII,
+  renderASCIICompact
+} from "./flow-weaver-chunk-6ZUJ7LMX.mjs";
+import {
+  generateInPlace
+} from "./flow-weaver-chunk-A6M5K3W7.mjs";
+import {
+  parseWorkflow
+} from "./flow-weaver-chunk-W3YNK26P.mjs";
+import {
+  logger
+} from "./flow-weaver-chunk-RIWE7YTR.mjs";
+import {
+  validator
+} from "./flow-weaver-chunk-IJJ4JXTL.mjs";
+import {
+  getIncomingConnections,
+  getNode,
+  getOutgoingConnections
+} from "./flow-weaver-chunk-Z44JK332.mjs";
+import {
+  getErrorMessage
+} from "./flow-weaver-chunk-OMVWSNHJ.mjs";
+
+// src/cli/commands/describe.ts
+import * as fs from "fs";
+import * as path from "path";
+function buildNodeInfo(instance, nodeType) {
+  return {
+    id: instance.id,
+    type: instance.nodeType,
+    inputs: nodeType ? Object.keys(nodeType.inputs) : [],
+    outputs: nodeType ? Object.keys(nodeType.outputs) : []
+  };
+}
+function buildAdjacency(ast) {
+  const fromStart = [];
+  const toExit = /* @__PURE__ */ new Set();
+  const edges = /* @__PURE__ */ new Map();
+  ast.connections.forEach((conn) => {
+    if (conn.from.node === "Start") {
+      if (!fromStart.includes(conn.to.node)) {
+        fromStart.push(conn.to.node);
+      }
+    } else if (conn.to.node === "Exit") {
+      toExit.add(conn.from.node);
+    } else {
+      const targets = edges.get(conn.from.node) || [];
+      if (!targets.includes(conn.to.node)) {
+        targets.push(conn.to.node);
+      }
+      edges.set(conn.from.node, targets);
+    }
+  });
+  return { fromStart, toExit, edges };
+}
+function enumeratePaths(ast) {
+  const { fromStart, toExit, edges } = buildAdjacency(ast);
+  const paths = [];
+  function dfs(current, path2, visited) {
+    if (toExit.has(current)) {
+      paths.push([...path2, "Exit"]);
+    }
+    const targets = edges.get(current) || [];
+    for (const next of targets) {
+      if (!visited.has(next)) {
+        visited.add(next);
+        path2.push(next);
+        dfs(next, path2, visited);
+        path2.pop();
+        visited.delete(next);
+      }
+    }
+  }
+  fromStart.forEach((startNode) => {
+    const visited = /* @__PURE__ */ new Set([startNode]);
+    dfs(startNode, ["Start", startNode], visited);
+  });
+  return paths;
+}
+function buildGraph(ast) {
+  const { fromStart, toExit, edges } = buildAdjacency(ast);
+  const lines = [];
+  function dfs(current, path2, visited) {
+    if (toExit.has(current)) {
+      lines.push([...path2, "Exit"].join(" -> "));
+    }
+    const targets = edges.get(current) || [];
+    for (const next of targets) {
+      if (!visited.has(next)) {
+        visited.add(next);
+        path2.push(next);
+        dfs(next, path2, visited);
+        path2.pop();
+        visited.delete(next);
+      }
+    }
+    if (targets.length === 0 && !toExit.has(current)) {
+      lines.push(path2.join(" -> "));
+    }
+  }
+  fromStart.forEach((startNode) => {
+    const visited = /* @__PURE__ */ new Set([startNode]);
+    dfs(startNode, ["Start", startNode], visited);
+  });
+  return lines.join("\n");
+}
+function formatPaths(ast) {
+  const paths = enumeratePaths(ast);
+  if (paths.length === 0) return "(no complete Start-to-Exit paths found)";
+  return paths.map((p) => p.join(" -> ")).join("\n");
+}
+function generateMermaid(ast) {
+  const lines = ["graph LR"];
+  ast.instances.forEach((instance) => {
+    lines.push(`  ${instance.id}[${instance.id}: ${instance.nodeType}]`);
+  });
+  const seenEdges = /* @__PURE__ */ new Set();
+  ast.connections.forEach((conn) => {
+    const edgeKey = `${conn.from.node}->${conn.to.node}`;
+    if (!seenEdges.has(edgeKey)) {
+      seenEdges.add(edgeKey);
+      const from = conn.from.node === "Start" ? "Start((Start))" : conn.from.node;
+      const to = conn.to.node === "Exit" ? "Exit((Exit))" : conn.to.node;
+      lines.push(`  ${from} --> ${to}`);
+    }
+  });
+  return lines.join("\n");
+}
+function describeWorkflow(ast, options = {}) {
+  const { node: focusNodeId } = options;
+  const validation = validator.validate(ast);
+  const validationOutput = {
+    valid: validation.valid,
+    errors: validation.errors.map((e) => e.message),
+    warnings: validation.warnings.map((w) => w.message)
+  };
+  const nodeTypeMap = /* @__PURE__ */ new Map();
+  ast.nodeTypes.forEach((nt) => nodeTypeMap.set(nt.functionName, nt));
+  if (focusNodeId) {
+    const nodeInstance = getNode(ast, focusNodeId);
+    if (!nodeInstance) {
+      throw new Error(`Node not found: ${focusNodeId}`);
+    }
+    const nodeType = nodeTypeMap.get(nodeInstance.nodeType);
+    const incoming = getIncomingConnections(ast, focusNodeId).map((c) => ({
+      from: `${c.from.node}.${c.from.port}`,
+      to: `${c.to.node}.${c.to.port}`
+    }));
+    const outgoing = getOutgoingConnections(ast, focusNodeId).map((c) => ({
+      from: `${c.from.node}.${c.from.port}`,
+      to: `${c.to.node}.${c.to.port}`
+    }));
+    return {
+      focusNode: focusNodeId,
+      node: buildNodeInfo(nodeInstance, nodeType),
+      incoming,
+      outgoing,
+      validation: validationOutput
+    };
+  }
+  const nodes = ast.instances.map((instance) => {
+    const nodeType = nodeTypeMap.get(instance.nodeType);
+    return buildNodeInfo(instance, nodeType);
+  });
+  const connections = ast.connections.map((c) => ({
+    from: `${c.from.node}.${c.from.port}`,
+    to: `${c.to.node}.${c.to.port}`
+  }));
+  return {
+    name: ast.functionName,
+    description: ast.description || null,
+    nodes,
+    connections,
+    graph: buildGraph(ast),
+    validation: validationOutput
+  };
+}
+function formatTextOutput(ast, output) {
+  if ("focusNode" in output) {
+    const focused = output;
+    const lines2 = [];
+    lines2.push(`Node: ${focused.node.id} [${focused.node.type}]`);
+    lines2.push(`  Inputs:  ${focused.node.inputs.join(", ") || "(none)"}`);
+    lines2.push(`  Outputs: ${focused.node.outputs.join(", ") || "(none)"}`);
+    if (focused.incoming.length > 0) {
+      lines2.push("");
+      lines2.push("Incoming:");
+      focused.incoming.forEach((c) => lines2.push(`  ${c.from} -> ${c.to}`));
+    }
+    if (focused.outgoing.length > 0) {
+      lines2.push("");
+      lines2.push("Outgoing:");
+      focused.outgoing.forEach((c) => lines2.push(`  ${c.from} -> ${c.to}`));
+    }
+    return lines2.join("\n");
+  }
+  const desc = output;
+  const lines = [];
+  lines.push(`Workflow: ${desc.name}`);
+  if (desc.description) {
+    lines.push(`  ${desc.description}`);
+  }
+  const nodeTypeMap = /* @__PURE__ */ new Map();
+  ast.nodeTypes.forEach((nt) => nodeTypeMap.set(nt.functionName, nt));
+  lines.push("");
+  lines.push(`Nodes (${desc.nodes.length}):`);
+  const maxIdLen = Math.max(...desc.nodes.map((n) => n.id.length), 2);
+  const maxTypeLen = Math.max(...desc.nodes.map((n) => n.type.length), 2);
+  desc.nodes.forEach((node) => {
+    const id = node.id.padEnd(maxIdLen);
+    const type = `[${node.type}]`.padEnd(maxTypeLen + 2);
+    const nodeType = nodeTypeMap.get(node.type);
+    const isExpression = nodeType?.expression === true;
+    const scopeNames = nodeType?.scopes ?? (nodeType?.scope ? [nodeType.scope] : []);
+    const filterPorts = (ports, direction) => {
+      if (!isExpression || !nodeType) return ports;
+      return ports.filter((portName) => {
+        if (portName === "execute" || portName === "onSuccess" || portName === "onFailure") {
+          return false;
+        }
+        const portDef = direction === "input" ? nodeType.inputs[portName] : nodeType.outputs[portName];
+        return !(portDef?.isControlFlow || portDef?.dataType === "STEP");
+      });
+    };
+    if (scopeNames.length > 0 && nodeType) {
+      const regularInputs = [];
+      const regularOutputs = [];
+      const scopedPorts = {};
+      scopeNames.forEach((s) => {
+        scopedPorts[s] = { sends: [], receives: [], children: [] };
+      });
+      Object.entries(nodeType.inputs).forEach(([name, port]) => {
+        if (port.scope && scopedPorts[port.scope]) {
+          scopedPorts[port.scope].receives.push(name + (port.isControlFlow ? " (STEP)" : ""));
+        } else {
+          regularInputs.push(name);
+        }
+      });
+      Object.entries(nodeType.outputs).forEach(([name, port]) => {
+        if (port.scope && scopedPorts[port.scope]) {
+          scopedPorts[port.scope].sends.push(name + (port.isControlFlow ? " (STEP)" : ""));
+        } else {
+          regularOutputs.push(name);
+        }
+      });
+      if (ast.scopes) {
+        for (const [scopeKey, childIds] of Object.entries(ast.scopes)) {
+          const dotIdx = scopeKey.indexOf(".");
+          const scopeName = dotIdx >= 0 ? scopeKey.substring(dotIdx + 1) : scopeKey;
+          if (scopedPorts[scopeName]) {
+            scopedPorts[scopeName].children.push(...childIds);
+          }
+        }
+      }
+      const ins = regularInputs.length > 0 ? `IN: ${regularInputs.join(", ")}` : "";
+      const outs = regularOutputs.length > 0 ? `OUT: ${regularOutputs.join(", ")}` : "";
+      const ports = [ins, outs].filter(Boolean).join("  ");
+      lines.push(`  ${id}  ${type}  ${ports}`);
+      for (const [scopeName, info] of Object.entries(scopedPorts)) {
+        lines.push(`    Scope "${scopeName}":`);
+        if (info.sends.length > 0) {
+          lines.push(`      Sends to children: ${info.sends.join(", ")}`);
+        }
+        if (info.receives.length > 0) {
+          lines.push(`      Receives from children: ${info.receives.join(", ")}`);
+        }
+        if (info.children.length > 0) {
+          lines.push(`      Children: ${info.children.join(", ")}`);
+        }
+      }
+    } else {
+      const filteredInputs = filterPorts(node.inputs, "input");
+      const filteredOutputs = filterPorts(node.outputs, "output");
+      const ins = filteredInputs.length > 0 ? `IN: ${filteredInputs.join(", ")}` : "";
+      const outs = filteredOutputs.length > 0 ? `OUT: ${filteredOutputs.join(", ")}` : "";
+      const ports = [ins, outs].filter(Boolean).join("  ");
+      lines.push(`  ${id}  ${type}  ${ports}`);
+    }
+  });
+  if (desc.graph) {
+    lines.push("");
+    const paths = enumeratePaths(ast);
+    if (paths.length > 1) {
+      lines.push(`Paths (${paths.length}):`);
+      paths.forEach((p, i) => {
+        lines.push(`  Path ${i + 1}: ${p.join(" -> ")}`);
+      });
+    } else {
+      lines.push("Flow:");
+      desc.graph.split("\n").forEach((flowLine) => {
+        lines.push(`  ${flowLine}`);
+      });
+    }
+  }
+  lines.push("");
+  lines.push(
+    `Validation: ${desc.validation.errors.length} errors, ${desc.validation.warnings.length} warnings`
+  );
+  return lines.join("\n");
+}
+function formatDescribeOutput(ast, output, format) {
+  switch (format) {
+    case "text":
+      return formatTextOutput(ast, output);
+    case "mermaid":
+      return generateMermaid(ast);
+    case "paths":
+      return formatPaths(ast);
+    case "ascii":
+      return renderASCII(buildDiagramGraph(ast));
+    case "ascii-compact":
+      return renderASCIICompact(buildDiagramGraph(ast));
+    case "json":
+    default:
+      return JSON.stringify(output, null, 2);
+  }
+}
+async function describeCommand(input, options = {}) {
+  const { format = "json", node: focusNodeId, workflowName, compile = false } = options;
+  const filePath = path.resolve(input);
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`File not found: ${filePath}`);
+  }
+  try {
+    const parseResult = await parseWorkflow(filePath, { workflowName, projectDir: path.dirname(filePath) });
+    if (parseResult.errors.length > 0) {
+      throw new Error(`Parse errors:
+${parseResult.errors.map((err) => `  ${err}`).join("\n")}`);
+    }
+    const ast = parseResult.ast;
+    if (compile) {
+      const sourceCode = fs.readFileSync(filePath, "utf8");
+      const generated = generateInPlace(sourceCode, ast, { production: false });
+      if (generated.hasChanges) {
+        safeWriteFile(filePath, generated.code);
+        logger.info(`Updated runtime markers in ${path.basename(filePath)}`);
+      }
+    }
+    const output = describeWorkflow(ast, { node: focusNodeId });
+    console.log(formatDescribeOutput(ast, output, format));
+  } catch (error) {
+    if (error instanceof Error && error.message.startsWith("Node not found:")) {
+      throw error;
+    }
+    throw new Error(`Failed to describe workflow: ${getErrorMessage(error)}`, { cause: error });
+  }
+}
+
+export {
+  buildNodeInfo,
+  enumeratePaths,
+  buildGraph,
+  formatPaths,
+  generateMermaid,
+  describeWorkflow,
+  formatTextOutput,
+  formatDescribeOutput,
+  describeCommand
+};