devglide 0.1.1

package/src/apps/workflow/services/workflow-store.ts

@@ -0,0 +1,424 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { z } from 'zod';
+import type { Workflow } from '../types.js';
+import { getActiveProject } from '../../../project-context.js';
+import { WORKFLOWS_DIR, INSTRUCTIONS_DIR } from '../../../packages/paths.js';
+import { JsonFileStore } from '../../../packages/json-file-store.js';
+
+// ── Zod schema for validating workflow JSON files from disk ──────────────────
+const workflowFileSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  version: z.number(),
+  nodes: z.array(z.object({
+    id: z.string(),
+    type: z.string(),
+    label: z.string(),
+    config: z.record(z.unknown()),
+    position: z.object({ x: z.number(), y: z.number() }),
+  }).passthrough()),
+  edges: z.array(z.object({
+    id: z.string(),
+    source: z.string(),
+    target: z.string(),
+  }).passthrough()),
+  variables: z.array(z.object({
+    name: z.string(),
+    type: z.enum(['string', 'number', 'boolean', 'json']),
+  }).passthrough()).default([]),
+  tags: z.array(z.string()).default([]),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+  description: z.string().optional(),
+  projectId: z.string().optional(),
+  enabled: z.boolean().optional(),
+  global: z.boolean().optional(),
+}).passthrough();
+
+interface WorkflowSummary {
+  id: string;
+  name: string;
+  description?: string;
+  version: number;
+  projectId?: string;
+  tags: string[];
+  nodeCount: number;
+  edgeCount: number;
+  updatedAt: string;
+  scope: 'project' | 'global';
+  enabled?: boolean;
+  global?: boolean;
+}
+
+/**
+ * Per-project and global workflow storage.
+ * One JSON file per workflow for git-friendly diffs.
+ */
+export class WorkflowStore extends JsonFileStore<Workflow> {
+  private static instance: WorkflowStore;
+  protected readonly baseDir = WORKFLOWS_DIR;
+
+  static getInstance(): WorkflowStore {
+    if (!WorkflowStore.instance) {
+      WorkflowStore.instance = new WorkflowStore();
+    }
+    return WorkflowStore.instance;
+  }
+
+  /** Override to add Zod validation on disk reads. */
+  protected override async readEntityFile(filePath: string): Promise<Workflow | null> {
+    try {
+      const raw = await fs.readFile(filePath, 'utf-8');
+      const parsed = JSON.parse(raw);
+      const result = workflowFileSchema.safeParse(parsed);
+      if (!result.success) {
+        console.warn(`[workflow-store] Invalid workflow file ${filePath}: ${result.error.issues[0]?.message}`);
+        return null;
+      }
+      return result.data as unknown as Workflow;
+    } catch {
+      return null;
+    }
+  }
+
+  async list(projectId?: string): Promise<WorkflowSummary[]> {
+    const seen = new Map<string, WorkflowSummary>();
+    const scopeId = projectId ?? getActiveProject()?.id;
+
+    // Project-scoped workflows take precedence over global
+    const projectDir = this.getProjectDir();
+    if (projectDir) {
+      for (const s of await this.scanDir(projectDir, 'project')) {
+        seen.set(s.id, s);
+      }
+    }
+
+    const globalDir = this.getGlobalDir();
+    for (const s of await this.scanDir(globalDir, 'global')) {
+      if (seen.has(s.id)) continue;
+      // In a project context, only include global-dir workflows that are either:
+      // - explicitly marked global, OR
+      // - belong to this project (projectId matches)
+      // Unscoped workflows (no projectId, not global) are legacy — skip in project context
+      if (scopeId && !s.global) {
+        if (!s.projectId || s.projectId !== scopeId) continue;
+      }
+      seen.set(s.id, s);
+    }
+
+    return [...seen.values()];
+  }
+
+  async listFull(projectId?: string): Promise<Workflow[]> {
+    const seen = new Map<string, Workflow>();
+    const scopeId = projectId ?? getActiveProject()?.id;
+
+    const projectDir = this.getProjectDir();
+    if (projectDir) {
+      for (const w of await this.scanDirFull(projectDir)) {
+        seen.set(w.id, w);
+      }
+    }
+
+    const globalDir = this.getGlobalDir();
+    for (const w of await this.scanDirFull(globalDir)) {
+      if (seen.has(w.id)) continue;
+      if (scopeId && !w.global) {
+        if (!w.projectId || w.projectId !== scopeId) continue;
+      }
+      seen.set(w.id, w);
+    }
+
+    return [...seen.values()];
+  }
+
+  async save(
+    input: Omit<Workflow, 'id' | 'createdAt' | 'updatedAt'> & { id?: string; scope?: 'project' | 'global'; enabled?: boolean },
+  ): Promise<Workflow> {
+    const lockKey = input.id ?? this.generateId();
+    return this.withLock(lockKey, async () => {
+      const now = new Date().toISOString();
+      const isUpdate = !!input.id;
+
+      let existing: Workflow | null = null;
+      let oldScope: 'project' | 'global' | undefined;
+      if (isUpdate) {
+        existing = await this.get(input.id!);
+        oldScope = await this.resolveExistingScope(input.id!);
+      }
+
+      const workflow: Workflow = {
+        id: input.id ?? lockKey,
+        name: input.name,
+        description: input.description,
+        version: input.version,
+        projectId: input.projectId ?? existing?.projectId ?? getActiveProject()?.id,
+        tags: input.tags,
+        enabled: input.enabled,
+        global: input.global,
+        nodes: input.nodes,
+        edges: input.edges,
+        variables: input.variables,
+        createdAt: existing?.createdAt ?? now,
+        updatedAt: now,
+      };
+
+      // When updating, preserve the original storage location; only new workflows use default scope
+      let scope = input.scope;
+      if (input.global === true) {
+        scope = 'global';
+      } else if (input.global === false && workflow.projectId) {
+        scope = 'project';
+      } else if (!scope && isUpdate) {
+        scope = oldScope;
+      }
+      scope = scope ?? (getActiveProject() ? 'project' : 'global');
+
+      await this.writeEntity(workflow, scope, workflow.projectId);
+
+      // If scope changed during update, clean up old file location
+      if (isUpdate && oldScope && oldScope !== scope) {
+        await this.removeFromScope(workflow.id, oldScope, existing?.projectId ?? getActiveProject()?.id);
+      }
+
+      await this.generateInstructionsFile(workflow.projectId);
+
+      return workflow;
+    });
+  }
+
+  override async delete(id: string): Promise<boolean> {
+    return this.withLock(id, async () => {
+      const existing = await this.get(id);
+      const projectDir = this.getProjectDir();
+      if (projectDir) {
+        try {
+          await fs.unlink(path.join(projectDir, `${id}.json`));
+          await this.generateInstructionsFile(existing?.projectId);
+          return true;
+        } catch {
+          // Not in project dir, try global
+        }
+      }
+
+      try {
+        await fs.unlink(path.join(this.getGlobalDir(), `${id}.json`));
+        await this.generateInstructionsFile(existing?.projectId);
+        return true;
+      } catch {
+        return false;
+      }
+    });
+  }
+
+  async exists(id: string): Promise<boolean> {
+    return (await this.get(id)) !== null;
+  }
+
+  async generateInstructionsFile(projectId?: string): Promise<void> {
+    const markdown = await this.buildInstructionsMarkdown(projectId);
+    const dirPath = INSTRUCTIONS_DIR;
+    await this.ensureDir(dirPath);
+    const filename = projectId || '_global';
+    await fs.writeFile(path.join(dirPath, `${filename}.md`), markdown);
+  }
+
+  async getCompiledInstructions(projectId?: string): Promise<string> {
+    return this.buildInstructionsMarkdown(projectId);
+  }
+
+  async match(prompt: string, projectId?: string): Promise<{ matches: Array<{ id: string; name: string; description?: string; tags: string[]; score: number; instructions: string }> }> {
+    const tokens = this.tokenize(prompt);
+    if (tokens.length === 0) return { matches: [] };
+
+    const workflows = await this.listFull(projectId);
+    const scored: Array<{ id: string; name: string; description?: string; tags: string[]; score: number; workflow: Workflow }> = [];
+
+    for (const w of workflows) {
+      if (w.enabled === false) continue;
+
+      const corpus = this.buildSearchCorpus(w);
+      const score = this.scoreMatch(tokens, corpus);
+      if (score > 0) {
+        scored.push({ id: w.id, name: w.name, description: w.description, tags: w.tags, score, workflow: w });
+      }
+    }
+
+    scored.sort((a, b) => b.score - a.score);
+
+    const matches = scored.map(({ id, name, description, tags, score, workflow }) => ({
+      id,
+      name,
+      description,
+      tags,
+      score,
+      instructions: this.buildSingleWorkflowMarkdown(workflow),
+    }));
+
+    return { matches };
+  }
+
+  private tokenize(text: string): string[] {
+    return text
+      .toLowerCase()
+      .replace(/[^a-z0-9\s-]/g, ' ')
+      .split(/\s+/)
+      .filter((t) => t.length > 2);
+  }
+
+  private buildSearchCorpus(w: Workflow): string {
+    const parts: string[] = [
+      w.name,
+      w.description ?? '',
+      ...w.tags,
+    ];
+
+    for (const node of w.nodes) {
+      parts.push(node.label);
+      const config = node.config as any;
+      if (config.triggerType) parts.push(config.triggerType);
+      if (config.gitEvent) parts.push(config.gitEvent);
+      if (config.operation) parts.push(config.operation);
+      if (config.instructions) parts.push(config.instructions);
+      if (config.command) parts.push(config.command);
+    }
+
+    return parts.join(' ').toLowerCase();
+  }
+
+  private scoreMatch(tokens: string[], corpus: string): number {
+    let score = 0;
+    for (const token of tokens) {
+      if (corpus.includes(token)) score++;
+    }
+    return score;
+  }
+
+  private buildSingleWorkflowMarkdown(workflow: Workflow): string {
+    const lines: string[] = [`## ${workflow.name}`];
+    if (workflow.description) lines.push('', workflow.description);
+
+    const steps = this.compileWorkflowSteps(workflow);
+    for (const step of steps) {
+      lines.push('', `### Step ${step.stepNumber}: ${step.label}`);
+      if (step.instructions) lines.push(step.instructions);
+      else if (step.instructionFile) lines.push(`See: ${step.instructionFile}`);
+    }
+
+    return lines.join('\n');
+  }
+
+  private async buildInstructionsMarkdown(projectId?: string): Promise<string> {
+    const workflows = await this.listFull(projectId);
+    const filtered = workflows.filter((w) => w.enabled !== false);
+
+    const lines: string[] = [
+      '# DevGlide Workflow Instructions',
+      '',
+      '> Auto-generated. Do not edit manually.',
+      `> Last updated: ${new Date().toISOString()}`,
+    ];
+
+    for (const workflow of filtered) {
+      lines.push('', `## ${workflow.name}`);
+      if (workflow.description) {
+        lines.push('', workflow.description);
+      }
+
+      const steps = this.compileWorkflowSteps(workflow);
+      for (const step of steps) {
+        lines.push('', `### Step ${step.stepNumber}: ${step.label}`);
+        if (step.instructions) {
+          lines.push(step.instructions);
+        } else if (step.instructionFile) {
+          lines.push(`See: ${step.instructionFile}`);
+        }
+      }
+
+      lines.push('', '---');
+    }
+
+    return lines.join('\n') + '\n';
+  }
+
+  private compileWorkflowSteps(workflow: Workflow): Array<{ stepNumber: number; label: string; instructions?: string; instructionFile?: string }> {
+    const adjacency = new Map<string, string[]>();
+    const incomingCount = new Map<string, number>();
+
+    for (const node of workflow.nodes) {
+      adjacency.set(node.id, []);
+      incomingCount.set(node.id, 0);
+    }
+
+    for (const edge of workflow.edges) {
+      adjacency.get(edge.source)?.push(edge.target);
+      incomingCount.set(edge.target, (incomingCount.get(edge.target) ?? 0) + 1);
+    }
+
+    // Start nodes: no incoming edges
+    const queue: string[] = [];
+    for (const node of workflow.nodes) {
+      if ((incomingCount.get(node.id) ?? 0) === 0) {
+        queue.push(node.id);
+      }
+    }
+
+    const ordered: string[] = [];
+
+    while (queue.length > 0) {
+      const nodeId = queue.shift()!;
+      ordered.push(nodeId);
+
+      for (const neighbor of adjacency.get(nodeId) ?? []) {
+        const count = (incomingCount.get(neighbor) ?? 1) - 1;
+        incomingCount.set(neighbor, count);
+        if (count === 0) {
+          queue.push(neighbor);
+        }
+      }
+    }
+
+    const nodeMap = new Map(workflow.nodes.map((n) => [n.id, n]));
+    const steps: Array<{ stepNumber: number; label: string; instructions?: string; instructionFile?: string }> = [];
+    let stepNumber = 1;
+
+    for (const nodeId of ordered) {
+      const node = nodeMap.get(nodeId);
+      if (!node) continue;
+      const config = node.config as any;
+      steps.push({
+        stepNumber: stepNumber++,
+        label: node.label,
+        instructions: config.instructions,
+        instructionFile: config.instructionFile,
+      });
+    }
+
+    return steps;
+  }
+
+  private async scanDir(dir: string, scope: 'project' | 'global'): Promise<WorkflowSummary[]> {
+    const summaries: WorkflowSummary[] = [];
+    const workflows = await this.scanDirFull(dir);
+
+    for (const workflow of workflows) {
+      summaries.push({
+        id: workflow.id,
+        name: workflow.name,
+        description: workflow.description,
+        version: workflow.version,
+        projectId: workflow.projectId,
+        tags: workflow.tags,
+        nodeCount: workflow.nodes.length,
+        edgeCount: workflow.edges.length,
+        updatedAt: workflow.updatedAt,
+        scope,
+        enabled: workflow.enabled,
+        global: workflow.global,
+      });
+    }
+
+    return summaries;
+  }
+}

package/src/apps/workflow/services/workflow-validator.test.ts

@@ -0,0 +1,103 @@
+import { describe, it, expect, vi } from 'vitest';
+import type { WorkflowNode, WorkflowEdge } from '../types.js';
+
+// Mock the node registry before importing the validator
+vi.mock('../engine/node-registry.js', () => ({
+  getRegisteredTypes: () => ['trigger', 'action:shell', 'action:kanban', 'decision', 'loop'],
+}));
+
+const { validateWorkflowGraph } = await import('./workflow-validator.js');
+
+function makeNode(id: string, type: string, label?: string): WorkflowNode {
+  return { id, type: type as WorkflowNode['type'], label: label ?? id, config: {} as WorkflowNode['config'], position: { x: 0, y: 0 } };
+}
+
+function makeEdge(source: string, target: string): WorkflowEdge {
+  return { id: `${source}-${target}`, source, target };
+}
+
+describe('validateWorkflowGraph', () => {
+  it('passes a valid linear graph', () => {
+    const nodes = [
+      makeNode('t1', 'trigger'),
+      makeNode('a1', 'action:shell'),
+    ];
+    const edges = [makeEdge('t1', 'a1')];
+    const result = validateWorkflowGraph(nodes, edges);
+    expect(result.valid).toBe(true);
+    expect(result.errors).toHaveLength(0);
+  });
+
+  it('requires at least one trigger node', () => {
+    const nodes = [makeNode('a1', 'action:shell')];
+    const result = validateWorkflowGraph(nodes, []);
+    expect(result.valid).toBe(false);
+    expect(result.errors).toContain('Workflow must have at least one trigger node');
+  });
+
+  it('rejects unknown node types', () => {
+    const nodes = [
+      makeNode('t1', 'trigger'),
+      makeNode('x1', 'action:unknown', 'MyNode'),
+    ];
+    const edges = [makeEdge('t1', 'x1')];
+    const result = validateWorkflowGraph(nodes, edges);
+    expect(result.valid).toBe(false);
+    expect(result.errors[0]).toContain('unknown type');
+  });
+
+  it('detects dangling edge references', () => {
+    const nodes = [makeNode('t1', 'trigger')];
+    const edges = [makeEdge('t1', 'nonexistent')];
+    const result = validateWorkflowGraph(nodes, edges);
+    expect(result.valid).toBe(false);
+    expect(result.errors[0]).toContain('non-existent target');
+  });
+
+  it('detects disconnected nodes', () => {
+    const nodes = [
+      makeNode('t1', 'trigger'),
+      makeNode('a1', 'action:shell', 'Orphan'),
+    ];
+    const result = validateWorkflowGraph(nodes, []);
+    expect(result.valid).toBe(false);
+    expect(result.errors.some((e) => e.includes('disconnected'))).toBe(true);
+  });
+
+  it('detects cycles', () => {
+    const nodes = [
+      makeNode('t1', 'trigger'),
+      makeNode('a1', 'action:shell'),
+      makeNode('a2', 'action:shell'),
+    ];
+    const edges = [
+      makeEdge('t1', 'a1'),
+      makeEdge('a1', 'a2'),
+      makeEdge('a2', 'a1'), // cycle
+    ];
+    const result = validateWorkflowGraph(nodes, edges);
+    expect(result.valid).toBe(false);
+    expect(result.errors).toContain('Workflow graph contains a cycle');
+  });
+
+  it('detects decision nodes without ports', () => {
+    const nodes = [
+      makeNode('t1', 'trigger'),
+      makeNode('d1', 'decision', 'MyDecision'),
+    ];
+    const edges = [makeEdge('t1', 'd1')];
+    const result = validateWorkflowGraph(nodes, edges);
+    expect(result.valid).toBe(false);
+    expect(result.errors.some((e) => e.includes('must have at least one port'))).toBe(true);
+  });
+
+  it('allows sub-workflow nodes without registry check', () => {
+    const nodes = [
+      makeNode('t1', 'trigger'),
+      makeNode('sw1', 'sub-workflow'),
+    ];
+    const edges = [makeEdge('t1', 'sw1')];
+    const result = validateWorkflowGraph(nodes, edges);
+    expect(result.valid).toBe(true);
+  });
+});

package/src/apps/workflow/services/workflow-validator.ts

@@ -0,0 +1,98 @@
+import type { WorkflowNode, WorkflowEdge } from '../types.js';
+import { getRegisteredTypes } from '../engine/node-registry.js';
+
+export interface ValidationResult {
+  valid: boolean;
+  errors: string[];
+}
+
+/**
+ * Validate a workflow graph for structural correctness:
+ * - Trigger node presence
+ * - Node type validity
+ * - Edge reference integrity
+ * - Decision node port requirements
+ * - Disconnected node detection
+ * - Cycle detection via DFS
+ */
+export function validateWorkflowGraph(nodes: WorkflowNode[], edges: WorkflowEdge[]): ValidationResult {
+  const errors: string[] = [];
+  const nodeIds = new Set(nodes.map((n) => n.id));
+  const registeredTypes = new Set(getRegisteredTypes());
+
+  // Must have at least one trigger
+  const triggerNodes = nodes.filter((n) => n.type === 'trigger');
+  if (triggerNodes.length === 0) {
+    errors.push('Workflow must have at least one trigger node');
+  }
+
+  // Node type validation
+  for (const node of nodes) {
+    if (node.type !== 'trigger' && node.type !== 'sub-workflow' && !registeredTypes.has(node.type)) {
+      errors.push(`Node "${node.label}" (${node.id}) has unknown type "${node.type}"`);
+    }
+  }
+
+  // Edge reference integrity
+  for (const edge of edges) {
+    if (!nodeIds.has(edge.source)) {
+      errors.push(`Edge "${edge.id}" references non-existent source node "${edge.source}"`);
+    }
+    if (!nodeIds.has(edge.target)) {
+      errors.push(`Edge "${edge.id}" references non-existent target node "${edge.target}"`);
+    }
+  }
+
+  // Decision node port requirements
+  for (const node of nodes) {
+    if (node.type === 'decision') {
+      const config = node.config as any;
+      if (!config.ports || !Array.isArray(config.ports) || config.ports.length === 0) {
+        errors.push(`Decision node "${node.label}" (${node.id}) must have at least one port`);
+      }
+    }
+  }
+
+  // Disconnected node detection
+  for (const node of nodes) {
+    if (node.type === 'trigger') continue;
+    const hasIncoming = edges.some((e) => e.target === node.id);
+    const hasOutgoing = edges.some((e) => e.source === node.id);
+    if (!hasIncoming && !hasOutgoing) {
+      errors.push(`Node "${node.label}" (${node.id}) is disconnected from the graph`);
+    }
+  }
+
+  // Cycle detection via DFS (three-color algorithm)
+  const adjacency = new Map<string, string[]>();
+  for (const node of nodes) adjacency.set(node.id, []);
+  for (const edge of edges) adjacency.get(edge.source)?.push(edge.target);
+
+  const WHITE = 0, GRAY = 1, BLACK = 2;
+  const colors = new Map<string, number>();
+  for (const node of nodes) colors.set(node.id, WHITE);
+
+  let hasCycle = false;
+
+  function dfs(nodeId: string): void {
+    if (hasCycle) return;
+    colors.set(nodeId, GRAY);
+    for (const neighbor of adjacency.get(nodeId) ?? []) {
+      const color = colors.get(neighbor);
+      if (color === GRAY) { hasCycle = true; return; }
+      if (color === WHITE) dfs(neighbor);
+    }
+    colors.set(nodeId, BLACK);
+  }
+
+  for (const node of nodes) {
+    if (colors.get(node.id) === WHITE) {
+      dfs(node.id);
+      if (hasCycle) break;
+    }
+  }
+
+  if (hasCycle) errors.push('Workflow graph contains a cycle');
+
+  return { valid: errors.length === 0, errors };
+}

package/src/apps/workflow/src/index.ts

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { createWorkflowMcpServer } from "../mcp.js";
+import { runStdio } from "@devglide/mcp-utils";
+
+// ── Stdio MCP mode ──────────────────────────────────────────────────────────
+if (process.argv.includes("--stdio")) {
+  const server = createWorkflowMcpServer();
+  await runStdio(server);
+  console.error("Devglide Workflow MCP server running on stdio");
+}

package/src/apps/workflow/templates/ci-pipeline.json

@@ -0,0 +1,18 @@
+{
+  "name": "CI Pipeline",
+  "description": "Lint, test, and build pipeline",
+  "version": 1,
+  "tags": ["ci", "pipeline"],
+  "variables": [],
+  "nodes": [
+    { "id": "trigger-1", "type": "trigger", "label": "Manual Trigger", "config": { "nodeType": "trigger", "triggerType": "manual" }, "position": { "x": 400, "y": 0 } },
+    { "id": "lint-1", "type": "action:shell", "label": "Lint", "config": { "nodeType": "action:shell", "command": "npm run lint", "captureOutput": true }, "position": { "x": 400, "y": 150 } },
+    { "id": "test-1", "type": "action:shell", "label": "Test", "config": { "nodeType": "action:shell", "command": "npm test", "captureOutput": true }, "position": { "x": 400, "y": 300 } },
+    { "id": "build-1", "type": "action:shell", "label": "Build", "config": { "nodeType": "action:shell", "command": "npm run build", "captureOutput": true }, "position": { "x": 400, "y": 450 } }
+  ],
+  "edges": [
+    { "id": "e1", "source": "trigger-1", "target": "lint-1" },
+    { "id": "e2", "source": "lint-1", "target": "test-1" },
+    { "id": "e3", "source": "test-1", "target": "build-1" }
+  ]
+}

package/src/apps/workflow/templates/code-review.json

@@ -0,0 +1,22 @@
+{
+  "name": "Code Review",
+  "description": "Auto-review: run tests, check diff, log results",
+  "version": 1,
+  "tags": ["git", "review"],
+  "variables": [],
+  "nodes": [
+    { "id": "trigger-1", "type": "trigger", "label": "Git Push", "config": { "nodeType": "trigger", "triggerType": "git-event", "gitEvent": "push" }, "position": { "x": 400, "y": 0 } },
+    { "id": "diff-1", "type": "action:git", "label": "Get Diff", "config": { "nodeType": "action:git", "operation": "diff" }, "position": { "x": 400, "y": 150 } },
+    { "id": "test-1", "type": "action:shell", "label": "Run Tests", "config": { "nodeType": "action:shell", "command": "npm test", "captureOutput": true }, "position": { "x": 400, "y": 300 } },
+    { "id": "decision-1", "type": "decision", "label": "Tests Passed?", "config": { "nodeType": "decision", "conditionType": "exit-code", "ports": [{ "id": "yes", "label": "Passed" }, { "id": "no", "label": "Failed" }] }, "position": { "x": 400, "y": 450 } },
+    { "id": "log-pass", "type": "action:log", "label": "Log Success", "config": { "nodeType": "action:log", "operation": "write", "message": "Code review passed: all tests green" }, "position": { "x": 250, "y": 600 } },
+    { "id": "log-fail", "type": "action:log", "label": "Log Failure", "config": { "nodeType": "action:log", "operation": "write", "message": "Code review failed: tests did not pass" }, "position": { "x": 550, "y": 600 } }
+  ],
+  "edges": [
+    { "id": "e1", "source": "trigger-1", "target": "diff-1" },
+    { "id": "e2", "source": "diff-1", "target": "test-1" },
+    { "id": "e3", "source": "test-1", "target": "decision-1" },
+    { "id": "e4", "source": "decision-1", "target": "log-pass", "sourcePort": "yes" },
+    { "id": "e5", "source": "decision-1", "target": "log-fail", "sourcePort": "no" }
+  ]
+}