@geenius/ai-workflow 0.1.0

package/packages/shared/src/engine.ts

@@ -0,0 +1,295 @@
+// @geenius-ai-workflow/shared — src/engine.ts
+
+/**
+ * Workflow execution engine — DAG-based step execution with variable passing.
+ */
+
+import type {
+    WorkflowDefinition,
+    WorkflowStepDef,
+    WorkflowRun,
+    StepResult,
+    RunStatus,
+    StepStatus,
+    LLMCallConfig,
+    TransformConfig,
+    ConditionConfig,
+    DelayConfig,
+} from './types'
+
+export interface WorkflowEngineOptions {
+    /** LLM call function for llm-call steps */
+    callLLM?: (systemPrompt: string, userPrompt: string, model?: string) => Promise<{
+        content: string; tokens?: number; costUsd?: number
+    }>
+    /** Webhook call function */
+    callWebhook?: (url: string, method: string, body?: string, headers?: Record<string, string>) => Promise<string>
+    /** Human approval callback */
+    onApprovalRequired?: (message: string, stepId: string) => Promise<boolean>
+    /** Step event callback */
+    onStepComplete?: (result: StepResult) => void
+    /** Custom step handlers */
+    customHandlers?: Record<string, (params: Record<string, unknown>, vars: Record<string, unknown>) => Promise<unknown>>
+}
+
+export class WorkflowEngine {
+    private options: WorkflowEngineOptions
+    private cancelled = false
+
+    constructor(options: WorkflowEngineOptions) {
+        this.options = options
+    }
+
+    cancel(): void {
+        this.cancelled = true
+    }
+
+    async execute(
+        definition: WorkflowDefinition,
+        input: Record<string, unknown> = {},
+    ): Promise<WorkflowRun> {
+        this.cancelled = false
+
+        const run: WorkflowRun = {
+            id: crypto.randomUUID?.() ?? String(Date.now()),
+            workflowId: definition.id,
+            workflowVersion: definition.version,
+            status: 'running',
+            input,
+            variables: { ...definition.variables, ...input },
+            stepResults: [],
+            currentStepIndex: 0,
+            triggeredBy: '',
+            startedAt: Date.now(),
+        }
+
+        // Topologically sort steps based on connections
+        const sortedSteps = this.topoSort(definition)
+
+        for (let i = 0; i < sortedSteps.length; i++) {
+            if (this.cancelled) {
+                run.status = 'cancelled'
+                break
+            }
+
+            run.currentStepIndex = i
+            const stepDef = sortedSteps[i]
+            const result = await this.executeStep(stepDef, run.variables, definition)
+
+            run.stepResults.push(result)
+            this.options.onStepComplete?.(result)
+
+            if (result.status === 'failed' && !stepDef.optional) {
+                run.status = 'failed'
+                run.error = result.error
+                break
+            }
+
+            // Store output in variables
+            if (result.output !== undefined && result.output !== null) {
+                const config = stepDef.config as { outputVar?: string }
+                if (config.outputVar) {
+                    run.variables[config.outputVar] = result.output
+                }
+            }
+
+            // Handle condition branching
+            if (stepDef.config.type === 'condition') {
+                const condConfig = stepDef.config as ConditionConfig
+                const condResult = result.output as boolean
+                const nextStepId = condResult ? condConfig.trueStepId : condConfig.falseStepId
+
+                // Skip to the target step
+                const targetIndex = sortedSteps.findIndex(s => s.id === nextStepId)
+                if (targetIndex > i) {
+                    // Mark skipped steps
+                    for (let j = i + 1; j < targetIndex; j++) {
+                        run.stepResults.push({
+                            stepId: sortedSteps[j].id,
+                            stepName: sortedSteps[j].name,
+                            type: sortedSteps[j].type,
+                            status: 'skipped',
+                            durationMs: 0,
+                            startedAt: Date.now(),
+                        })
+                    }
+                    i = targetIndex - 1 // Will be incremented by loop
+                }
+            }
+        }
+
+        if (run.status === 'running') {
+            run.status = 'completed'
+        }
+        run.completedAt = Date.now()
+
+        return run
+    }
+
+    private async executeStep(
+        stepDef: WorkflowStepDef,
+        variables: Record<string, unknown>,
+        _definition: WorkflowDefinition,
+    ): Promise<StepResult> {
+        const start = Date.now()
+        const baseResult: StepResult = {
+            stepId: stepDef.id,
+            stepName: stepDef.name,
+            type: stepDef.type,
+            status: 'running',
+            durationMs: 0,
+            startedAt: start,
+        }
+
+        let attempts = 0
+        const maxAttempts = stepDef.retries?.maxAttempts ?? 1
+
+        while (attempts < maxAttempts) {
+            attempts++
+            try {
+                const output = await this.runStepLogic(stepDef, variables)
+                return {
+                    ...baseResult,
+                    status: 'completed',
+                    output,
+                    durationMs: Date.now() - start,
+                    completedAt: Date.now(),
+                }
+            } catch (err) {
+                if (attempts >= maxAttempts) {
+                    return {
+                        ...baseResult,
+                        status: 'failed',
+                        error: err instanceof Error ? err.message : String(err),
+                        durationMs: Date.now() - start,
+                        completedAt: Date.now(),
+                    }
+                }
+                // Wait before retry
+                const backoff = stepDef.retries?.backoffMs ?? 1000
+                await new Promise(r => setTimeout(r, backoff * attempts))
+            }
+        }
+
+        return { ...baseResult, status: 'failed', error: 'Max retries exceeded', durationMs: Date.now() - start }
+    }
+
+    private async runStepLogic(
+        stepDef: WorkflowStepDef,
+        variables: Record<string, unknown>,
+    ): Promise<unknown> {
+        switch (stepDef.config.type) {
+            case 'llm-call': {
+                if (!this.options.callLLM) throw new Error('No LLM function provided')
+                const config = stepDef.config as LLMCallConfig
+                const userPrompt = this.interpolate(config.userPromptTemplate, variables)
+                const result = await this.options.callLLM(config.systemPrompt, userPrompt, config.model)
+                if (config.parseJson) {
+                    try { return JSON.parse(result.content) }
+                    catch { return result.content }
+                }
+                return result.content
+            }
+
+            case 'transform': {
+                const config = stepDef.config as TransformConfig
+                // Simple expression evaluation with variable access
+                const varEntries = config.inputVars.map(v => [v, variables[v]])
+                const fn = new Function(
+                    ...config.inputVars,
+                    `"use strict"; return (${config.expression})`
+                )
+                return fn(...varEntries.map(([_, v]) => v))
+            }
+
+            case 'condition': {
+                const config = stepDef.config as ConditionConfig
+                const fn = new Function(
+                    'vars',
+                    `"use strict"; with(vars) { return Boolean(${config.expression}) }`
+                )
+                return fn(variables)
+            }
+
+            case 'human-approval': {
+                if (!this.options.onApprovalRequired) {
+                    // Auto-approve if no handler
+                    return true
+                }
+                const config = stepDef.config
+                return this.options.onApprovalRequired(
+                    (config as { message: string }).message,
+                    stepDef.id,
+                )
+            }
+
+            case 'webhook': {
+                if (!this.options.callWebhook) throw new Error('No webhook function provided')
+                const config = stepDef.config as { url: string; method: string; bodyTemplate?: string; headers?: Record<string, string> }
+                const body = config.bodyTemplate ? this.interpolate(config.bodyTemplate, variables) : undefined
+                return this.options.callWebhook(config.url, config.method, body, config.headers)
+            }
+
+            case 'delay': {
+                const config = stepDef.config as DelayConfig
+                await new Promise(r => setTimeout(r, config.durationMs))
+                return null
+            }
+
+            case 'custom': {
+                const config = stepDef.config as { handler: string; params: Record<string, unknown> }
+                const handler = this.options.customHandlers?.[config.handler]
+                if (!handler) throw new Error(`No handler for custom step: ${config.handler}`)
+                return handler(config.params, variables)
+            }
+
+            default:
+                throw new Error(`Unsupported step type: ${stepDef.config.type}`)
+        }
+    }
+
+    /** Interpolate {{variable}} references in a string */
+    private interpolate(template: string, vars: Record<string, unknown>): string {
+        return template.replace(/\{\{(\w+)\}\}/g, (_, key) => {
+            const val = vars[key]
+            return val !== undefined ? String(val) : `{{${key}}}`
+        })
+    }
+
+    /** Topological sort of steps based on connections */
+    private topoSort(def: WorkflowDefinition): WorkflowStepDef[] {
+        const stepMap = new Map(def.steps.map(s => [s.id, s]))
+        const inDegree = new Map<string, number>()
+        const adjacency = new Map<string, string[]>()
+
+        for (const step of def.steps) {
+            inDegree.set(step.id, 0)
+            adjacency.set(step.id, [])
+        }
+
+        for (const conn of def.connections) {
+            adjacency.get(conn.fromStepId)?.push(conn.toStepId)
+            inDegree.set(conn.toStepId, (inDegree.get(conn.toStepId) ?? 0) + 1)
+        }
+
+        const queue: string[] = []
+        for (const [id, degree] of inDegree) {
+            if (degree === 0) queue.push(id)
+        }
+
+        const sorted: WorkflowStepDef[] = []
+        while (queue.length > 0) {
+            const id = queue.shift()!
+            const step = stepMap.get(id)
+            if (step) sorted.push(step)
+
+            for (const neighbor of adjacency.get(id) ?? []) {
+                const newDegree = (inDegree.get(neighbor) ?? 1) - 1
+                inDegree.set(neighbor, newDegree)
+                if (newDegree === 0) queue.push(neighbor)
+            }
+        }
+
+        return sorted
+    }
+}

package/packages/shared/src/index.ts

@@ -0,0 +1,43 @@
+// @geenius-ai-workflow/shared — src/index.ts
+
+// Config
+export { configureWorkflow, defaultWorkflowConfig } from './config'
+export type { ConfigureWorkflowOptions } from './config'
+
+// Types
+export type {
+    WorkflowStatus, RunStatus, StepStatus, StepType,
+    WorkflowDefinition, WorkflowStepDef, StepConfig,
+    LLMCallConfig, TransformConfig, ConditionConfig, HumanApprovalConfig,
+    WebhookConfig, DelayConfig, ParallelConfig, LoopConfig, SubWorkflowConfig, CustomStepConfig,
+    StepConnection, WorkflowVariable, WorkflowRun, StepResult, WorkflowBuilderState,
+} from './types'
+
+// Engine
+export { WorkflowEngine } from './engine'
+export type { WorkflowEngineOptions } from './engine'
+
+// Step factories
+export { llmStep, transformStep, conditionStep, approvalStep, webhookStep, delayStep, connect, linearWorkflow } from './steps'
+
+// Validators
+export {
+    workflowDefinitionSchema, workflowStepDefSchema, stepConfigSchema, stepConnectionSchema,
+    workflowRunSchema, stepResultSchema, workflowVariableSchema,
+    validateWorkflow, validateRun, validateConnectionIntegrity,
+} from './validators'
+
+// Templates
+export { WORKFLOW_TEMPLATES, getTemplate, getTemplatesByCategory } from './templates'
+export type { WorkflowTemplate } from './templates'
+
+// Utilities
+export {
+    interpolate, extractVariables, findMissingVariables,
+    topoSort, detectCycle, findPaths, findEntryNodes, findExitNodes,
+    estimateTokens, estimateStepTokens, estimateStepCost, estimateWorkflowCost, calculateRunCost, formatCost, MODEL_RATES,
+} from './utils'
+export type { DAGNode, DAGEdge } from './utils'
+
+// Convex schemas
+export { workflowTables, workflowsTable, workflowRunsTable, workflowStepResultsTable } from './convex/index'

package/packages/shared/src/steps.ts

@@ -0,0 +1,68 @@
+// @geenius-ai-workflow/shared — src/steps.ts
+
+/**
+ * Built-in step factory helpers for easy workflow construction.
+ */
+
+import type { WorkflowStepDef, LLMCallConfig, TransformConfig, ConditionConfig, HumanApprovalConfig, WebhookConfig, DelayConfig } from './types'
+
+let stepCounter = 0
+function nextId(): string {
+    return `step_${++stepCounter}_${Date.now()}`
+}
+
+/** Create an LLM call step */
+export function llmStep(name: string, config: Omit<LLMCallConfig, 'type'>): WorkflowStepDef {
+    return { id: nextId(), name, type: 'llm-call', config: { type: 'llm-call', ...config } }
+}
+
+/** Create a data transform step */
+export function transformStep(name: string, config: Omit<TransformConfig, 'type'>): WorkflowStepDef {
+    return { id: nextId(), name, type: 'transform', config: { type: 'transform', ...config } }
+}
+
+/** Create a condition (if/else) step */
+export function conditionStep(name: string, config: Omit<ConditionConfig, 'type'>): WorkflowStepDef {
+    return { id: nextId(), name, type: 'condition', config: { type: 'condition', ...config } }
+}
+
+/** Create a human approval gate */
+export function approvalStep(name: string, config: Omit<HumanApprovalConfig, 'type'>): WorkflowStepDef {
+    return { id: nextId(), name, type: 'human-approval', config: { type: 'human-approval', ...config } }
+}
+
+/** Create a webhook call step */
+export function webhookStep(name: string, config: Omit<WebhookConfig, 'type'>): WorkflowStepDef {
+    return { id: nextId(), name, type: 'webhook', config: { type: 'webhook', ...config } }
+}
+
+/** Create a delay step */
+export function delayStep(name: string, durationMs: number): WorkflowStepDef {
+    return { id: nextId(), name, type: 'delay', config: { type: 'delay', durationMs } }
+}
+
+/**
+ * Connect two steps (create a DAG edge).
+ */
+export function connect(fromStepId: string, toStepId: string, label?: string) {
+    return { fromStepId, toStepId, label }
+}
+
+/**
+ * Build a linear workflow from an ordered list of steps.
+ */
+export function linearWorkflow(
+    name: string,
+    steps: WorkflowStepDef[],
+): { steps: WorkflowStepDef[]; connections: Array<{ fromStepId: string; toStepId: string }> } {
+    const connections = []
+    for (let i = 0; i < steps.length - 1; i++) {
+        connections.push({ fromStepId: steps[i].id, toStepId: steps[i + 1].id })
+    }
+    return { steps, connections }
+}
+
+/** Reset the step counter (for testing) */
+export function resetStepCounter(): void {
+    stepCounter = 0
+}

package/packages/shared/src/templates.ts

@@ -0,0 +1,172 @@
+// @geenius-ai-workflow/shared — src/templates.ts
+/**
+ * Pre-built workflow templates for common AI/business patterns.
+ */
+import type { WorkflowDefinition, WorkflowStepDef, StepConnection } from './types'
+
+export interface WorkflowTemplate {
+  id: string
+  name: string
+  description: string
+  category: 'content' | 'data' | 'approval' | 'research' | 'devops'
+  tags: string[]
+  /** Factory that creates a fresh WorkflowDefinition from this template */
+  create: (createdBy: string) => WorkflowDefinition
+}
+
+function uid(): string { return `step_tpl_${Date.now()}_${Math.random().toString(36).slice(2, 8)}` }
+function wfId(): string { return `wf_${Date.now()}_${Math.random().toString(36).slice(2, 8)}` }
+
+// ============================================================================
+// 1. Content Pipeline
+// ============================================================================
+
+const contentPipeline: WorkflowTemplate = {
+  id: 'tpl-content-pipeline',
+  name: 'Content Pipeline',
+  description: 'Generate, review, and publish content with AI refinement and human approval.',
+  category: 'content',
+  tags: ['content', 'blog', 'marketing'],
+  create: (createdBy) => {
+    const draft = uid(), refine = uid(), approve = uid(), publish = uid()
+    const steps: WorkflowStepDef[] = [
+      { id: draft, name: 'Generate Draft', type: 'llm-call', config: { type: 'llm-call', systemPrompt: 'You are a content writer.', userPromptTemplate: 'Write a blog post about {{topic}}. Tone: {{tone}}.', outputVar: 'draft' }, position: { x: 100, y: 200 } },
+      { id: refine, name: 'Refine Content', type: 'llm-call', config: { type: 'llm-call', systemPrompt: 'You are an editor. Improve clarity, grammar, and engagement.', userPromptTemplate: 'Polish this draft:\n\n{{draft}}', outputVar: 'polished' }, position: { x: 350, y: 200 } },
+      { id: approve, name: 'Human Review', type: 'human-approval', config: { type: 'human-approval', message: 'Please review the polished content before publishing.' }, position: { x: 600, y: 200 } },
+      { id: publish, name: 'Format for Publishing', type: 'transform', config: { type: 'transform', expression: '({ title: polished.split("\\n")[0], body: polished, publishedAt: Date.now() })', inputVars: ['polished'], outputVar: 'publishData' }, position: { x: 850, y: 200 } },
+    ]
+    const connections: StepConnection[] = [
+      { fromStepId: draft, toStepId: refine },
+      { fromStepId: refine, toStepId: approve },
+      { fromStepId: approve, toStepId: publish },
+    ]
+    return { id: wfId(), name: 'Content Pipeline', description: 'AI-powered content generation with editorial review.', version: 1, status: 'draft', steps, connections, inputSchema: [{ name: 'topic', type: 'string', required: true }, { name: 'tone', type: 'string', required: false, default: 'professional' }], tags: ['content'], createdBy, createdAt: Date.now(), updatedAt: Date.now() }
+  },
+}
+
+// ============================================================================
+// 2. Data Enrichment
+// ============================================================================
+
+const dataEnrichment: WorkflowTemplate = {
+  id: 'tpl-data-enrichment',
+  name: 'Data Enrichment',
+  description: 'Fetch external data, enrich with AI analysis, and transform for downstream use.',
+  category: 'data',
+  tags: ['data', 'analytics', 'enrichment'],
+  create: (createdBy) => {
+    const fetch_ = uid(), analyze = uid(), transform = uid()
+    const steps: WorkflowStepDef[] = [
+      { id: fetch_, name: 'Fetch Data', type: 'webhook', config: { type: 'webhook', url: '{{dataSourceUrl}}', method: 'GET', outputVar: 'rawData' }, position: { x: 100, y: 200 } },
+      { id: analyze, name: 'AI Analysis', type: 'llm-call', config: { type: 'llm-call', systemPrompt: 'You are a data analyst. Analyze the data and extract key insights.', userPromptTemplate: 'Analyze this dataset and return a JSON summary with key metrics:\n\n{{rawData}}', parseJson: true, outputVar: 'analysis' }, position: { x: 400, y: 200 } },
+      { id: transform, name: 'Transform Output', type: 'transform', config: { type: 'transform', expression: '({ ...analysis, enrichedAt: Date.now(), source: dataSourceUrl })', inputVars: ['analysis', 'dataSourceUrl'], outputVar: 'enrichedData' }, position: { x: 700, y: 200 } },
+    ]
+    const connections: StepConnection[] = [
+      { fromStepId: fetch_, toStepId: analyze },
+      { fromStepId: analyze, toStepId: transform },
+    ]
+    return { id: wfId(), name: 'Data Enrichment', version: 1, status: 'draft', steps, connections, inputSchema: [{ name: 'dataSourceUrl', type: 'string', required: true }], tags: ['data'], createdBy, createdAt: Date.now(), updatedAt: Date.now() }
+  },
+}
+
+// ============================================================================
+// 3. Approval Chain
+// ============================================================================
+
+const approvalChain: WorkflowTemplate = {
+  id: 'tpl-approval-chain',
+  name: 'Approval Chain',
+  description: 'Multi-level approval workflow with conditional escalation.',
+  category: 'approval',
+  tags: ['approval', 'governance', 'compliance'],
+  create: (createdBy) => {
+    const checkRisk = uid(), lowApproval = uid(), highApproval = uid(), finalize = uid()
+    const steps: WorkflowStepDef[] = [
+      { id: checkRisk, name: 'Assess Risk Level', type: 'llm-call', config: { type: 'llm-call', systemPrompt: 'Assess the risk level of this request. Respond with JSON: {"riskLevel": "low"|"medium"|"high", "reason": "..."}', userPromptTemplate: '{{request}}', parseJson: true, outputVar: 'riskAssessment' }, position: { x: 100, y: 200 } },
+      { id: lowApproval, name: 'Manager Approval', type: 'human-approval', config: { type: 'human-approval', message: 'Low/medium risk: Manager approval needed for: {{request}}' }, position: { x: 400, y: 100 } },
+      { id: highApproval, name: 'Executive Approval', type: 'human-approval', config: { type: 'human-approval', message: 'High risk: Executive approval required for: {{request}}' }, position: { x: 400, y: 300 } },
+      { id: finalize, name: 'Record Decision', type: 'transform', config: { type: 'transform', expression: '({ approved: true, approvedAt: Date.now(), riskLevel: riskAssessment.riskLevel })', inputVars: ['riskAssessment'], outputVar: 'decision' }, position: { x: 700, y: 200 } },
+    ]
+    const connections: StepConnection[] = [
+      { fromStepId: checkRisk, toStepId: lowApproval, condition: 'riskAssessment.riskLevel !== "high"' },
+      { fromStepId: checkRisk, toStepId: highApproval, condition: 'riskAssessment.riskLevel === "high"' },
+      { fromStepId: lowApproval, toStepId: finalize },
+      { fromStepId: highApproval, toStepId: finalize },
+    ]
+    return { id: wfId(), name: 'Approval Chain', version: 1, status: 'draft', steps, connections, inputSchema: [{ name: 'request', type: 'string', required: true }], tags: ['approval'], createdBy, createdAt: Date.now(), updatedAt: Date.now() }
+  },
+}
+
+// ============================================================================
+// 4. Research Pipeline
+// ============================================================================
+
+const researchPipeline: WorkflowTemplate = {
+  id: 'tpl-research',
+  name: 'Research Pipeline',
+  description: 'Multi-source research with AI synthesis and summary generation.',
+  category: 'research',
+  tags: ['research', 'analysis', 'summary'],
+  create: (createdBy) => {
+    const research = uid(), synthesize = uid(), summarize = uid()
+    const steps: WorkflowStepDef[] = [
+      { id: research, name: 'Deep Research', type: 'llm-call', config: { type: 'llm-call', systemPrompt: 'You are a research assistant. Provide comprehensive, well-sourced research on the given topic.', userPromptTemplate: 'Research the following topic in depth: {{topic}}\n\nFocus areas: {{focusAreas}}', outputVar: 'researchOutput' }, position: { x: 100, y: 200 } },
+      { id: synthesize, name: 'Synthesize Findings', type: 'llm-call', config: { type: 'llm-call', systemPrompt: 'You are a synthesis expert. Combine research findings into structured insights with citations.', userPromptTemplate: 'Synthesize these research findings into key themes and actionable insights:\n\n{{researchOutput}}', parseJson: true, outputVar: 'synthesis' }, position: { x: 400, y: 200 } },
+      { id: summarize, name: 'Executive Summary', type: 'llm-call', config: { type: 'llm-call', systemPrompt: 'Write a concise executive summary (3-5 paragraphs) suitable for senior leadership.', userPromptTemplate: 'Create an executive summary from:\n\n{{synthesis}}', outputVar: 'executiveSummary' }, position: { x: 700, y: 200 } },
+    ]
+    const connections: StepConnection[] = [
+      { fromStepId: research, toStepId: synthesize },
+      { fromStepId: synthesize, toStepId: summarize },
+    ]
+    return { id: wfId(), name: 'Research Pipeline', version: 1, status: 'draft', steps, connections, inputSchema: [{ name: 'topic', type: 'string', required: true }, { name: 'focusAreas', type: 'string', required: false, default: 'general overview' }], tags: ['research'], createdBy, createdAt: Date.now(), updatedAt: Date.now() }
+  },
+}
+
+// ============================================================================
+// 5. Code Review Pipeline
+// ============================================================================
+
+const codeReviewPipeline: WorkflowTemplate = {
+  id: 'tpl-code-review',
+  name: 'Code Review Pipeline',
+  description: 'Automated code review with AI analysis, security check, and human approval.',
+  category: 'devops',
+  tags: ['code', 'review', 'security', 'devops'],
+  create: (createdBy) => {
+    const analyze = uid(), security = uid(), approve = uid(), report = uid()
+    const steps: WorkflowStepDef[] = [
+      { id: analyze, name: 'AI Code Review', type: 'llm-call', config: { type: 'llm-call', systemPrompt: 'You are a senior code reviewer. Analyze the code for bugs, performance issues, and best practices. Return JSON: {"issues": [], "suggestions": [], "quality": 1-10}', userPromptTemplate: 'Review this code:\n\n```{{language}}\n{{code}}\n```', parseJson: true, outputVar: 'codeReview' }, position: { x: 100, y: 200 } },
+      { id: security, name: 'Security Scan', type: 'llm-call', config: { type: 'llm-call', systemPrompt: 'You are a security auditor. Check for vulnerabilities (XSS, SQL injection, secrets exposure, etc). Return JSON: {"vulnerabilities": [], "riskLevel": "low"|"medium"|"high"}', userPromptTemplate: 'Security audit for:\n\n```{{language}}\n{{code}}\n```', parseJson: true, outputVar: 'securityReport' }, position: { x: 100, y: 400 } },
+      { id: approve, name: 'Developer Approval', type: 'human-approval', config: { type: 'human-approval', message: 'Review the AI code analysis and security scan before merging.' }, position: { x: 450, y: 300 } },
+      { id: report, name: 'Generate Report', type: 'transform', config: { type: 'transform', expression: '({ codeQuality: codeReview.quality, issues: codeReview.issues.length, vulnerabilities: securityReport.vulnerabilities.length, riskLevel: securityReport.riskLevel, reviewedAt: Date.now() })', inputVars: ['codeReview', 'securityReport'], outputVar: 'finalReport' }, position: { x: 700, y: 300 } },
+    ]
+    const connections: StepConnection[] = [
+      { fromStepId: analyze, toStepId: approve },
+      { fromStepId: security, toStepId: approve },
+      { fromStepId: approve, toStepId: report },
+    ]
+    return { id: wfId(), name: 'Code Review Pipeline', version: 1, status: 'draft', steps, connections, inputSchema: [{ name: 'code', type: 'string', required: true }, { name: 'language', type: 'string', required: false, default: 'typescript' }], tags: ['devops', 'review'], createdBy, createdAt: Date.now(), updatedAt: Date.now() }
+  },
+}
+
+// ============================================================================
+// Template Registry
+// ============================================================================
+
+export const WORKFLOW_TEMPLATES: WorkflowTemplate[] = [
+  contentPipeline,
+  dataEnrichment,
+  approvalChain,
+  researchPipeline,
+  codeReviewPipeline,
+]
+
+/** Look up a template by ID */
+export function getTemplate(id: string): WorkflowTemplate | undefined {
+  return WORKFLOW_TEMPLATES.find(t => t.id === id)
+}
+
+/** Filter templates by category */
+export function getTemplatesByCategory(category: WorkflowTemplate['category']): WorkflowTemplate[] {
+  return WORKFLOW_TEMPLATES.filter(t => t.category === category)
+}