@swarmclawai/swarmclaw 1.3.5 → 1.4.0

package/src/features/protocols/builder/protocol-builder-store.ts

@@ -0,0 +1,233 @@
+import { create } from 'zustand'
+import { devtools } from 'zustand/middleware'
+import type { Node, Edge } from '@xyflow/react'
+import type { ProtocolTemplate, ProtocolStepKind, ProtocolBranchCase, ProtocolRepeatConfig, ProtocolParallelConfig, ProtocolJoinConfig, ProtocolForEachConfig, ProtocolSubflowConfig, ProtocolSwarmConfig, ProtocolRunStepStatus } from '@/types'
+
+export interface BuilderNodeData extends Record<string, unknown> {
+  label: string
+  kind: ProtocolStepKind
+  instructions?: string | null
+  turnLimit?: number | null
+  completionCriteria?: string | null
+  taskConfig?: { agentId?: string; title: string; description: string } | null
+  delegationConfig?: { agentId: string; message: string } | null
+  repeat?: ProtocolRepeatConfig | null
+  parallel?: ProtocolParallelConfig | null
+  join?: ProtocolJoinConfig | null
+  forEach?: ProtocolForEachConfig | null
+  subflow?: ProtocolSubflowConfig | null
+  swarm?: ProtocolSwarmConfig | null
+  branchCases?: ProtocolBranchCase[]
+  defaultNextStepId?: string | null
+  outputKey?: string | null
+  dependsOnStepIds?: string[]
+  runtimeStatus?: ProtocolRunStepStatus | null
+}
+
+export interface BuilderEdgeData extends Record<string, unknown> {
+  edgeType: 'default' | 'branch' | 'loop'
+  branchCaseId?: string | null
+  label?: string | null
+  isLoopback?: boolean
+}
+
+export interface ValidationError {
+  nodeId?: string
+  edgeId?: string
+  message: string
+}
+
+export interface ValidationWarning {
+  nodeId?: string
+  message: string
+}
+
+export type BuilderNode = Node<BuilderNodeData>
+export type BuilderEdge = Edge<BuilderEdgeData>
+
+interface UndoSnapshot {
+  nodes: BuilderNode[]
+  edges: BuilderEdge[]
+}
+
+const MAX_UNDO_HISTORY = 50
+
+export interface ProtocolBuilderState {
+  nodes: BuilderNode[]
+  edges: BuilderEdge[]
+  selectedNodeId: string | null
+  selectedEdgeId: string | null
+  isPaletteOpen: boolean
+  isInspectorOpen: boolean
+  currentTemplate: ProtocolTemplate | null
+  isDirty: boolean
+  validationErrors: ValidationError[]
+  validationWarnings: ValidationWarning[]
+  undoStack: UndoSnapshot[]
+  redoStack: UndoSnapshot[]
+  activeRunId: string | null
+
+  setNodes: (nodes: BuilderNode[]) => void
+  setEdges: (edges: BuilderEdge[]) => void
+  selectNode: (nodeId: string | null) => void
+  selectEdge: (edgeId: string | null) => void
+  updateNodeData: (nodeId: string, data: Partial<BuilderNodeData>) => void
+  updateEdgeData: (edgeId: string, data: Partial<BuilderEdgeData>) => void
+  addNode: (node: BuilderNode) => void
+  deleteNode: (nodeId: string) => void
+  addEdge: (edge: BuilderEdge) => void
+  deleteEdge: (edgeId: string) => void
+  loadTemplate: (template: ProtocolTemplate, nodes: BuilderNode[], edges: BuilderEdge[]) => void
+  setValidation: (errors: ValidationError[], warnings: ValidationWarning[]) => void
+  setActiveRun: (runId: string | null) => void
+  setDirty: (dirty: boolean) => void
+  pushUndo: () => void
+  undo: () => void
+  redo: () => void
+  setPaletteOpen: (open: boolean) => void
+  setInspectorOpen: (open: boolean) => void
+  reset: () => void
+}
+
+const initialState = {
+  nodes: [] as BuilderNode[],
+  edges: [] as BuilderEdge[],
+  selectedNodeId: null,
+  selectedEdgeId: null,
+  isPaletteOpen: true,
+  isInspectorOpen: true,
+  currentTemplate: null,
+  isDirty: false,
+  validationErrors: [] as ValidationError[],
+  validationWarnings: [] as ValidationWarning[],
+  undoStack: [] as UndoSnapshot[],
+  redoStack: [] as UndoSnapshot[],
+  activeRunId: null,
+}
+
+export const useProtocolBuilderStore = create<ProtocolBuilderState>()(
+  devtools(
+    (set, get) => ({
+      ...initialState,
+
+      setNodes: (nodes) => set({ nodes, isDirty: true }),
+      setEdges: (edges) => set({ edges, isDirty: true }),
+
+      selectNode: (nodeId) =>
+        set({ selectedNodeId: nodeId, selectedEdgeId: null }),
+
+      selectEdge: (edgeId) =>
+        set({ selectedEdgeId: edgeId, selectedNodeId: null }),
+
+      updateNodeData: (nodeId, data) => {
+        const { nodes } = get()
+        set({
+          nodes: nodes.map((n) =>
+            n.id === nodeId ? { ...n, data: { ...n.data, ...data } } : n,
+          ),
+          isDirty: true,
+        })
+      },
+
+      updateEdgeData: (edgeId, data) => {
+        const { edges } = get()
+        set({
+          edges: edges.map((e) =>
+            e.id === edgeId ? { ...e, data: { ...e.data, ...data } as BuilderEdgeData } : e,
+          ),
+          isDirty: true,
+        })
+      },
+
+      addNode: (node) => {
+        const { nodes } = get()
+        set({ nodes: [...nodes, node], isDirty: true })
+      },
+
+      deleteNode: (nodeId) => {
+        const { nodes, edges } = get()
+        set({
+          nodes: nodes.filter((n) => n.id !== nodeId),
+          edges: edges.filter((e) => e.source !== nodeId && e.target !== nodeId),
+          selectedNodeId: null,
+          isDirty: true,
+        })
+      },
+
+      addEdge: (edge) => {
+        const { edges } = get()
+        set({ edges: [...edges, edge], isDirty: true })
+      },
+
+      deleteEdge: (edgeId) => {
+        const { edges } = get()
+        set({
+          edges: edges.filter((e) => e.id !== edgeId),
+          selectedEdgeId: null,
+          isDirty: true,
+        })
+      },
+
+      loadTemplate: (template, nodes, edges) =>
+        set({
+          currentTemplate: template,
+          nodes,
+          edges,
+          isDirty: false,
+          validationErrors: [],
+          validationWarnings: [],
+          undoStack: [],
+          redoStack: [],
+          selectedNodeId: null,
+          selectedEdgeId: null,
+        }),
+
+      setValidation: (errors, warnings) =>
+        set({ validationErrors: errors, validationWarnings: warnings }),
+
+      setActiveRun: (runId) => set({ activeRunId: runId }),
+      setDirty: (dirty) => set({ isDirty: dirty }),
+
+      pushUndo: () => {
+        const { nodes, edges, undoStack } = get()
+        const snapshot: UndoSnapshot = { nodes: [...nodes], edges: [...edges] }
+        const trimmed = undoStack.length >= MAX_UNDO_HISTORY
+          ? undoStack.slice(1)
+          : undoStack
+        set({ undoStack: [...trimmed, snapshot], redoStack: [] })
+      },
+
+      undo: () => {
+        const { undoStack, nodes, edges } = get()
+        if (undoStack.length === 0) return
+        const prev = undoStack[undoStack.length - 1]
+        set({
+          nodes: prev.nodes,
+          edges: prev.edges,
+          undoStack: undoStack.slice(0, -1),
+          redoStack: [{ nodes, edges }, ...get().redoStack],
+          isDirty: true,
+        })
+      },
+
+      redo: () => {
+        const { redoStack, nodes, edges } = get()
+        if (redoStack.length === 0) return
+        const next = redoStack[0]
+        set({
+          nodes: next.nodes,
+          edges: next.edges,
+          redoStack: redoStack.slice(1),
+          undoStack: [...get().undoStack, { nodes, edges }],
+          isDirty: true,
+        })
+      },
+
+      setPaletteOpen: (open) => set({ isPaletteOpen: open }),
+      setInspectorOpen: (open) => set({ isInspectorOpen: open }),
+
+      reset: () => set(initialState),
+    }),
+    { name: 'protocol-builder' },
+  ),
+)

package/src/features/protocols/builder/utils/node-position-layout.ts

@@ -0,0 +1,41 @@
+import dagre from 'dagre'
+import type { Node, Edge } from '@xyflow/react'
+import type { BuilderNodeData, BuilderEdgeData } from '../protocol-builder-store'
+
+const NODE_WIDTH = 180
+const NODE_HEIGHT = 80
+const RANK_SEP = 100
+const NODE_SEP = 60
+
+export function getNodeLayout(
+  nodes: Node<BuilderNodeData>[],
+  edges: Edge<BuilderEdgeData>[],
+): Node<BuilderNodeData>[] {
+  if (nodes.length === 0) return nodes
+
+  const g = new dagre.graphlib.Graph()
+  g.setGraph({ rankdir: 'TB', ranksep: RANK_SEP, nodesep: NODE_SEP })
+  g.setDefaultEdgeLabel(() => ({}))
+
+  for (const node of nodes) {
+    g.setNode(node.id, { width: NODE_WIDTH, height: NODE_HEIGHT })
+  }
+
+  for (const edge of edges) {
+    g.setEdge(edge.source, edge.target)
+  }
+
+  dagre.layout(g)
+
+  return nodes.map((node) => {
+    const pos = g.node(node.id)
+    if (!pos) return node
+    return {
+      ...node,
+      position: {
+        x: pos.x - NODE_WIDTH / 2,
+        y: pos.y - NODE_HEIGHT / 2,
+      },
+    }
+  })
+}

package/src/features/protocols/builder/utils/nodes-to-template.test.ts

@@ -0,0 +1,179 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import type { ProtocolTemplate, ProtocolStepDefinition } from '@/types'
+import { templateToNodes } from './template-to-nodes'
+import { nodesToTemplate } from './nodes-to-template'
+
+function makeTemplate(overrides: Partial<ProtocolTemplate> = {}): ProtocolTemplate {
+  return {
+    id: 'tpl-1',
+    name: 'Test Template',
+    description: 'A test template',
+    builtIn: false,
+    defaultPhases: [],
+    ...overrides,
+  }
+}
+
+function makeStep(overrides: Partial<ProtocolStepDefinition> = {}): ProtocolStepDefinition {
+  return {
+    id: 'step-1',
+    kind: 'present',
+    label: 'Step One',
+    ...overrides,
+  }
+}
+
+// --- Round-trip: templateToNodes → nodesToTemplate ---
+
+describe('nodesToTemplate — round-trip', () => {
+  it('round-trips a simple 3-step template: preserves step count and entryStepId', () => {
+    const steps: ProtocolStepDefinition[] = [
+      makeStep({ id: 'step-1', label: 'Step One', nextStepId: 'step-2' }),
+      makeStep({ id: 'step-2', label: 'Step Two', kind: 'decide', nextStepId: 'step-3' }),
+      makeStep({ id: 'step-3', label: 'Step Three', kind: 'summarize' }),
+    ]
+    const template = makeTemplate({ steps, entryStepId: 'step-1' })
+    const { nodes, edges } = templateToNodes(template)
+    const result = nodesToTemplate(nodes, edges, template)
+
+    assert.strictEqual(result.steps!.length, 3)
+    assert.deepStrictEqual(result.steps!.map((s) => s.id), ['step-1', 'step-2', 'step-3'])
+    assert.strictEqual(result.entryStepId, 'step-1')
+  })
+
+  it('preserves nextStepId from default edges', () => {
+    const steps: ProtocolStepDefinition[] = [
+      makeStep({ id: 'step-a', nextStepId: 'step-b' }),
+      makeStep({ id: 'step-b', nextStepId: 'step-c' }),
+      makeStep({ id: 'step-c' }),
+    ]
+    const template = makeTemplate({ steps })
+    const { nodes, edges } = templateToNodes(template)
+    const result = nodesToTemplate(nodes, edges, template)
+
+    const stepA = result.steps!.find((s) => s.id === 'step-a')
+    const stepB = result.steps!.find((s) => s.id === 'step-b')
+    const stepC = result.steps!.find((s) => s.id === 'step-c')
+
+    assert.strictEqual(stepA?.nextStepId, 'step-b')
+    assert.strictEqual(stepB?.nextStepId, 'step-c')
+    assert.strictEqual(stepC?.nextStepId, undefined)
+  })
+
+  it('preserves step data fields: instructions, turnLimit, completionCriteria, outputKey', () => {
+    const steps: ProtocolStepDefinition[] = [
+      makeStep({
+        id: 'step-rich',
+        kind: 'decide',
+        label: 'Rich Step',
+        instructions: 'Evaluate carefully',
+        turnLimit: 5,
+        completionCriteria: 'Decision made',
+        outputKey: 'decision_result',
+        dependsOnStepIds: ['step-prev'],
+      }),
+    ]
+    const template = makeTemplate({ steps })
+    const { nodes, edges } = templateToNodes(template)
+    const result = nodesToTemplate(nodes, edges, template)
+
+    const step = result.steps![0]
+    assert.strictEqual(step.id, 'step-rich')
+    assert.strictEqual(step.kind, 'decide')
+    assert.strictEqual(step.label, 'Rich Step')
+    assert.strictEqual(step.instructions, 'Evaluate carefully')
+    assert.strictEqual(step.turnLimit, 5)
+    assert.strictEqual(step.completionCriteria, 'Decision made')
+    assert.strictEqual(step.outputKey, 'decision_result')
+    assert.deepStrictEqual(step.dependsOnStepIds, ['step-prev'])
+  })
+
+  it('preserves branchCases and defaultNextStepId', () => {
+    const steps: ProtocolStepDefinition[] = [
+      makeStep({
+        id: 'branch-step',
+        kind: 'branch',
+        label: 'Branch',
+        branchCases: [
+          { id: 'case-yes', label: 'Yes', nextStepId: 'step-yes' },
+          { id: 'case-no', label: 'No', nextStepId: 'step-no' },
+        ],
+        defaultNextStepId: 'step-default',
+      }),
+      makeStep({ id: 'step-yes', label: 'Yes Path' }),
+      makeStep({ id: 'step-no', label: 'No Path' }),
+      makeStep({ id: 'step-default', label: 'Default Path' }),
+    ]
+    const template = makeTemplate({ steps })
+    const { nodes, edges } = templateToNodes(template)
+    const result = nodesToTemplate(nodes, edges, template)
+
+    const branch = result.steps!.find((s) => s.id === 'branch-step')
+    assert.strictEqual(branch?.branchCases!.length, 2)
+    assert.strictEqual(branch?.branchCases![0].id, 'case-yes')
+    assert.strictEqual(branch?.branchCases![0].nextStepId, 'step-yes')
+    assert.strictEqual(branch?.branchCases![1].id, 'case-no')
+    assert.strictEqual(branch?.branchCases![1].nextStepId, 'step-no')
+    assert.strictEqual(branch?.defaultNextStepId, 'step-default')
+  })
+
+  it('sets entryStepId from the first node', () => {
+    const steps: ProtocolStepDefinition[] = [
+      makeStep({ id: 'first-step', label: 'First' }),
+      makeStep({ id: 'second-step', label: 'Second' }),
+    ]
+    const template = makeTemplate({ steps, entryStepId: 'first-step' })
+    const { nodes, edges } = templateToNodes(template)
+    const result = nodesToTemplate(nodes, edges, template)
+
+    assert.strictEqual(result.entryStepId, nodes[0].id)
+    assert.strictEqual(result.entryStepId, 'first-step')
+  })
+})
+
+// --- Direct nodesToTemplate tests (no round-trip) ---
+
+describe('nodesToTemplate — direct construction', () => {
+  it('preserves all originalTemplate fields except steps and entryStepId', () => {
+    const template = makeTemplate({
+      id: 'custom-id',
+      name: 'Custom Name',
+      description: 'Custom description',
+      builtIn: true,
+      tags: ['tag-a', 'tag-b'],
+      singleAgentAllowed: true,
+      steps: [makeStep({ id: 'step-x' })],
+    })
+    const { nodes, edges } = templateToNodes(template)
+    const result = nodesToTemplate(nodes, edges, template)
+
+    assert.strictEqual(result.id, 'custom-id')
+    assert.strictEqual(result.name, 'Custom Name')
+    assert.strictEqual(result.description, 'Custom description')
+    assert.strictEqual(result.builtIn, true)
+    assert.deepStrictEqual(result.tags, ['tag-a', 'tag-b'])
+    assert.strictEqual(result.singleAgentAllowed, true)
+  })
+
+  it('handles an empty nodes array without throwing', () => {
+    const template = makeTemplate({ steps: [makeStep({ id: 'step-1' })], entryStepId: 'step-1' })
+    const result = nodesToTemplate([], [], template)
+
+    assert.strictEqual(result.steps!.length, 0)
+    // entryStepId falls back to originalTemplate.entryStepId when nodes is empty
+    assert.strictEqual(result.entryStepId, 'step-1')
+  })
+
+  it('does not include nextStepId on steps with no outgoing default edge', () => {
+    const steps: ProtocolStepDefinition[] = [
+      makeStep({ id: 'lone-step', label: 'Lone Step' }),
+    ]
+    const template = makeTemplate({ steps })
+    const { nodes, edges } = templateToNodes(template)
+    const result = nodesToTemplate(nodes, edges, template)
+
+    const step = result.steps![0]
+    assert.strictEqual(step.nextStepId, undefined)
+  })
+})

package/src/features/protocols/builder/utils/nodes-to-template.ts

@@ -0,0 +1,49 @@
+import type { Node, Edge } from '@xyflow/react'
+import type { ProtocolTemplate, ProtocolStepDefinition } from '@/types'
+import type { BuilderNodeData, BuilderEdgeData } from '../protocol-builder-store'
+
+export function nodesToTemplate(
+  nodes: Node<BuilderNodeData>[],
+  edges: Edge<BuilderEdgeData>[],
+  originalTemplate: ProtocolTemplate,
+): ProtocolTemplate {
+  const steps: ProtocolStepDefinition[] = nodes.map((node) => {
+    const step: ProtocolStepDefinition = {
+      id: node.id,
+      kind: node.data.kind,
+      label: node.data.label,
+    }
+
+    if (node.data.instructions) step.instructions = node.data.instructions
+    if (node.data.turnLimit) step.turnLimit = node.data.turnLimit
+    if (node.data.completionCriteria) step.completionCriteria = node.data.completionCriteria
+    if (node.data.taskConfig) step.taskConfig = node.data.taskConfig
+    if (node.data.delegationConfig) step.delegationConfig = node.data.delegationConfig
+    if (node.data.repeat) step.repeat = node.data.repeat
+    if (node.data.parallel) step.parallel = node.data.parallel
+    if (node.data.join) step.join = node.data.join
+    if (node.data.forEach) step.forEach = node.data.forEach
+    if (node.data.subflow) step.subflow = node.data.subflow
+    if (node.data.swarm) step.swarm = node.data.swarm
+    if (node.data.branchCases?.length) step.branchCases = node.data.branchCases
+    if (node.data.defaultNextStepId) step.defaultNextStepId = node.data.defaultNextStepId
+    if (node.data.outputKey) step.outputKey = node.data.outputKey
+    if (node.data.dependsOnStepIds?.length) step.dependsOnStepIds = node.data.dependsOnStepIds
+
+    // Derive nextStepId from default edges
+    const defaultEdge = edges.find(
+      (e) => e.source === node.id && e.data?.edgeType === 'default',
+    )
+    if (defaultEdge) {
+      step.nextStepId = defaultEdge.target
+    }
+
+    return step
+  })
+
+  return {
+    ...originalTemplate,
+    steps,
+    entryStepId: nodes[0]?.id || originalTemplate.entryStepId,
+  }
+}