feat: configure control flows tasks

Signed-off-by: Simon Emms <simon@simonemms.com>

Author: mrsimonemms

src/lib/i18n/messages/en.json

@@ -37,11 +37,22 @@
     "branches": "Branches",
     "removeBranch": "Remove branch {{label}}",
     "addBranch": "+ Add branch",
+    "switch": {
+      "branches": "Branches",
+      "branchName": "Branch name",
+      "condition": "Condition (when)",
+      "targetWorkflow": "Target workflow",
+      "addBranch": "+ Add branch",
+      "addDefaultBranch": "+ Add default branch",
+      "defaultBranch": "Default branch",
+      "errorDuplicateName": "Duplicate branch name",
+      "errorEmptyCondition": "Condition is required",
+      "errorNoTarget": "Target workflow is required"
+    },
     "sections": "Sections",
     "enterTryBody": "Enter try body",
     "enterCatchBlock": "Enter catch block",
     "addCatchBlock": "+ Add catch block",
-    "enterLoopBody": "Enter loop body",
     "comingSoon": "Full editing UI coming soon.",
     "moveUp": "↑ Move up",
     "moveUpLabel": "Move task up",
@@ -72,15 +83,21 @@
       "days": "Days"
     },
     "fork": {
+      "branches": "Branches",
+      "addBranch": "+ Add branch",
+      "renameBranch": "Rename branch {{label}}",
+      "deleteBranch": "Delete branch {{label}}",
+      "errorDuplicateName": "Duplicate branch name",
       "compete": "Compete mode",
       "competeHint": "First branch to finish wins"
     },
     "loop": {
-      "title": "Loop configuration",
-      "in": "Collection",
-      "each": "Item variable",
-      "at": "Index variable",
-      "while": "Break condition"
+      "configuration": "Loop configuration",
+      "collection": "Collection",
+      "itemVariable": "Item variable",
+      "indexVariable": "Index variable",
+      "breakCondition": "Break condition",
+      "enterBody": "Enter loop body"
     },
     "callGrpc": {
       "title": "Call gRPC",
@@ -349,7 +366,7 @@
     "switch": "Switch",
     "fork": "Fork",
     "try": "Try / Catch",
-    "loop": "Loop"
+    "loop": "For Loop"
   },
   "sidebar": {
     "document": "Document",
@@ -372,7 +389,20 @@
   "canvas": {
     "ariaLabel": "Workflow canvas",
     "tryBody": "try body",
-    "catchBlock": "catch block",
-    "loopBody": "body"
+    "catchBlock": "catch block"
+  },
+  "node": {
+    "loop": {
+      "for": "for",
+      "body": "body",
+      "bodyEmpty": "body (empty)",
+      "bodyCount": "body ({{count}} tasks)"
+    }
+  },
+  "validation": {
+    "loop": {
+      "collectionRequired": "Collection is required",
+      "invalidIdentifier": "Must be a valid identifier (letters, digits, underscores; cannot start with a digit)"
+    }
   }
 }

src/lib/tasks/actions.ts

@@ -461,6 +461,32 @@ export function renameSwitchBranch(
   };
 }
 
+export function updateSwitchBranchCondition(
+  node: SwitchNode,
+  branchId: string,
+  condition: string | undefined,
+): SwitchNode {
+  return {
+    ...node,
+    branches: node.branches.map((b) =>
+      b.id === branchId ? { ...b, condition } : b,
+    ),
+  };
+}
+
+export function updateSwitchBranchTarget(
+  node: SwitchNode,
+  branchId: string,
+  thenWorkflowName: string | undefined,
+): SwitchNode {
+  return {
+    ...node,
+    branches: node.branches.map((b) =>
+      b.id === branchId ? { ...b, thenWorkflowName } : b,
+    ),
+  };
+}
+
 // ---------------------------------------------------------------------------
 // ForkNode
 // ---------------------------------------------------------------------------
@@ -477,11 +503,22 @@ export function createForkNode(name: string): ForkNode {
   };
 }
 
-export function addForkBranch(node: ForkNode, label: string): ForkNode {
+/**
+ * Returns the next available branch label of the form `branch-N`, starting
+ * from 1 and incrementing until a name not already in use is found.
+ */
+export function nextForkBranchLabel(branches: ForkBranch[]): string {
+  const existing = new Set(branches.map((b) => b.label));
+  let n = 1;
+  while (existing.has(`branch-${n}`)) n++;
+  return `branch-${n}`;
+}
+
+export function addForkBranch(node: ForkNode): ForkNode {
   const zid = newId();
   const branch: ForkBranch = {
     id: zid,
-    label,
+    label: nextForkBranchLabel(node.branches),
     graph: emptyFlowGraph(),
     metadata: { [ZIGFLOW_ID_KEY]: zid },
   };
@@ -593,7 +630,7 @@ export function insertNode(
 // Resolve the FlowGraph at the given GraphPath. Throws on invalid paths.
 //
 // Segment consumption rules per node type:
-//   loop   → 1 segment  (nodeId → bodyGraph)
+//   loop   → 2 segments (nodeId + 'body' → bodyGraph)
 //   switch → 2 segments (nodeId + branchId → branch.graph)
 //   fork   → 2 segments (nodeId + branchId → branch.graph)
 //   try    → 2 segments (nodeId + 'tryGraph'|'catchGraph' → section)
@@ -615,13 +652,7 @@ export function getGraphAtPath(file: WorkflowFile, path: GraphPath): FlowGraph {
       throw new Error(`Node ${nodeId} is a task and has no sub-graph`);
     }
 
-    if (node.type === 'loop') {
-      graph = node.bodyGraph;
-      i += 1;
-      continue;
-    }
-
-    // switch, fork, try — consume one additional segment for the sub-graph id
+    // switch, fork, try, loop — consume one additional segment for the sub-graph id
     i += 1;
     if (i >= path.segments.length) {
       throw new Error(
@@ -630,6 +661,17 @@ export function getGraphAtPath(file: WorkflowFile, path: GraphPath): FlowGraph {
     }
     const subId = path.segments[i]!;
 
+    if (node.type === 'loop') {
+      if (subId !== 'body') {
+        throw new Error(
+          `Expected "body" after loop node ${nodeId}, got "${subId}"`,
+        );
+      }
+      graph = node.bodyGraph;
+      i += 1;
+      continue;
+    }
+
     if (node.type === 'switch') {
       const branch = node.branches.find((b) => b.id === subId);
       if (!branch) {
@@ -693,17 +735,7 @@ function applyTransformAt(
   const node = graph.nodes[nodeId];
   if (!node) throw new Error(`Node ${nodeId} not found at segment ${i}`);
 
-  if (node.type === 'loop') {
-    const newBody = applyTransformAt(
-      node.bodyGraph,
-      segments,
-      i + 1,
-      transform,
-    );
-    return replaceNode(graph, { ...node, bodyGraph: newBody });
-  }
-
-  // switch, fork, try — next segment identifies which sub-graph to descend into
+  // switch, fork, try, loop — next segment identifies which sub-graph to descend into
   const subIndex = i + 1;
   if (subIndex >= segments.length) {
     throw new Error(
@@ -756,6 +788,17 @@ function applyTransformAt(
     }
   }
 
+  if (node.type === 'loop') {
+    // subId is the 'body' literal — descend into bodyGraph.
+    const newBody = applyTransformAt(
+      node.bodyGraph,
+      segments,
+      subIndex + 1,
+      transform,
+    );
+    return replaceNode(graph, { ...node, bodyGraph: newBody });
+  }
+
   throw new Error(
     `Node ${nodeId} (type: ${node.type}) cannot be navigated into`,
   );

src/lib/tasks/registry.ts

@@ -20,6 +20,7 @@
 // Factories use crypto.randomUUID() directly to avoid importing from actions.ts.
 import type {
   FlowGraph,
+  ForkBranch,
   ForkNode,
   LoopNode,
   Node,
@@ -217,12 +218,19 @@ export const TASK_REGISTRY: readonly TaskDefinition[] = [
     description: 'Run branches in parallel',
     create: (): ForkNode => {
       const nid = id();
+      const bid = id();
+      const defaultBranch: ForkBranch = {
+        id: bid,
+        label: 'branch-1',
+        graph: emptyGraph(),
+        metadata: { [ZIGFLOW_ID_KEY]: bid },
+      };
       return {
         id: nid,
         type: 'fork',
         name: 'fork',
         compete: false,
-        branches: [],
+        branches: [defaultBranch],
         metadata: { [ZIGFLOW_ID_KEY]: nid },
       };
     },
@@ -254,7 +262,9 @@ export const TASK_REGISTRY: readonly TaskDefinition[] = [
         id: nid,
         type: 'loop',
         name: 'loop',
-        in: '$.',
+        in: '${ $input.items }',
+        each: 'item',
+        at: 'index',
         bodyGraph: emptyGraph(),
         metadata: { [ZIGFLOW_ID_KEY]: nid },
       };

src/lib/tasks/validation.ts

@@ -211,19 +211,30 @@ function validateSwitchNode(
 function validateForkNode(node: ForkNode, path: string[]): ValidationError[] {
   const errors: ValidationError[] = [];
 
-  if (node.branches.length < 2) {
+  if (node.branches.length < 1) {
     errors.push({
       path,
-      message: 'Fork node must have at least two branches',
+      message: 'Fork node must have at least one branch',
     });
   }
 
+  const labelCounts = new Map<string, number>();
+  for (const b of node.branches) {
+    const l = b.label.trim();
+    labelCounts.set(l, (labelCounts.get(l) ?? 0) + 1);
+  }
+
   for (const branch of node.branches) {
     if (!branch.label.trim()) {
       errors.push({
         path: [...path, 'branches', branch.id],
         message: 'Branch label is required',
       });
+    } else if ((labelCounts.get(branch.label.trim()) ?? 0) > 1) {
+      errors.push({
+        path: [...path, 'branches', branch.id],
+        message: 'Branch label must be unique',
+      });
     }
     errors.push(
       ...validateFlowGraph(branch.graph, [

src/lib/ui/Canvas.svelte

@@ -98,7 +98,10 @@
         ROW_HEADER + rows * ROW_HEIGHT + ROW_PADDING,
       );
     }
-    // loop: header(28) + body row(22) + padding(8) = 58 ≈ 60
+    // loop: header(28) + expression line(22) + body row(22) + padding(8) = 80
+    if (node.type === 'loop') {
+      return ROW_HEADER + ROW_HEIGHT + ROW_HEIGHT + ROW_PADDING;
+    }
     return NODE_HEIGHT_TASK;
   }
 
@@ -133,6 +136,8 @@
     nodeType: string;
     typeLabel: string;
     navRows?: NavRow[];
+    // Loop nodes only: the collection expression shown under the header.
+    loopExpression?: string;
   };
 
   type SFNode = {
@@ -177,7 +182,12 @@
       return rows;
     }
     if (node.type === 'loop') {
-      return [{ id: 'body', label: t('canvas.loopBody'), kind: 'enter' }];
+      const count = Object.keys(node.bodyGraph.nodes).length;
+      const label =
+        count === 0
+          ? t('node.loop.bodyEmpty')
+          : t('node.loop.bodyCount', { count });
+      return [{ id: 'body', label, kind: 'enter' }];
     }
     return [];
   }
@@ -188,6 +198,7 @@
       nodeType: node.type,
       typeLabel: nodeTypeLabel(node.type),
       navRows: node.type !== 'task' ? buildNavRows(node) : undefined,
+      loopExpression: node.type === 'loop' ? node.in : undefined,
     };
   }