@geenius/ai-workflow 0.1.0 → 0.4.0

package/packages/shared/src/__tests__/ai-workflow.test.ts

@@ -1,217 +0,0 @@
-// @geenius-ai-workflow/shared — src/__tests__/ai-workflow.test.ts
-import { describe, it, expect } from 'vitest'
-import { WorkflowEngine } from '../engine'
-import { llmStep, transformStep, conditionStep, linearWorkflow, delayStep } from '../steps'
-import { interpolate, extractVariables, detectCycle, topoSort } from '../utils'
-import { validateWorkflow } from '../validators'
-import { WORKFLOW_TEMPLATES, getTemplate } from '../templates'
-
-// ─── WorkflowEngine ───────────────────────────────────────────────────────────
-
-describe('WorkflowEngine', () => {
-    it('executes a linear workflow', async () => {
-        const engine = new WorkflowEngine({
-            callLLM: async () => ({ content: 'AI Result' }),
-        })
-
-        const { steps, connections } = linearWorkflow('Test', [
-            llmStep('Step 1', { systemPrompt: 'Sys', userPromptTemplate: 'User', outputVar: 'out1' }),
-            transformStep('Step 2', { expression: 'out1.toUpperCase()', inputVars: ['out1'], outputVar: 'out2' }),
-        ])
-
-        const run = await engine.execute({
-            id: 'test', name: 'Test', version: 1, status: 'active',
-            steps, connections, createdBy: 'test', createdAt: 0, updatedAt: 0,
-        }, {})
-
-        expect(run.status).toBe('completed')
-        expect(run.variables.out1).toBe('AI Result')
-        expect(run.variables.out2).toBe('AI RESULT')
-        expect(run.stepResults).toHaveLength(2)
-    })
-
-    it('handles conditional branching (false path)', async () => {
-        const engine = new WorkflowEngine({
-            callLLM: async () => ({ content: 'Small' }),
-        })
-
-        const step1 = llmStep('Check', { systemPrompt: '...', userPromptTemplate: '...', outputVar: 'val' })
-        // Create branch steps first so we have their IDs
-        const bigStep = transformStep('Big Result', { expression: '"BIG"', inputVars: [], outputVar: 'res' })
-        const smallStep = transformStep('Small Result', { expression: '"SMALL"', inputVars: [], outputVar: 'res' })
-        const cond = conditionStep('Branch', {
-            expression: 'val === "Big"',
-            trueStepId: bigStep.id,
-            falseStepId: smallStep.id,
-        })
-
-        const run = await engine.execute({
-            id: 'test', name: 'Test', version: 1, status: 'active',
-            steps: [step1, cond, bigStep, smallStep],
-            connections: [
-                { fromStepId: step1.id, toStepId: cond.id },
-                { fromStepId: cond.id, toStepId: bigStep.id, label: 'true' },
-                { fromStepId: cond.id, toStepId: smallStep.id, label: 'false' },
-            ],
-            createdBy: 'test', createdAt: 0, updatedAt: 0,
-        }, {})
-
-        expect(run.status).toBe('completed')
-        expect(run.variables.res).toBe('SMALL')
-        expect(run.stepResults.find(s => s.stepId === bigStep.id)?.status).toBe('skipped')
-    })
-
-    it('fails with invalid workflow (no steps)', async () => {
-        const engine = new WorkflowEngine({
-            callLLM: async () => ({ content: 'x' }),
-        })
-
-        const run = await engine.execute({
-            id: 'empty', name: 'Empty', version: 1, status: 'active',
-            steps: [], connections: [], createdBy: 'test', createdAt: 0, updatedAt: 0,
-        }, {})
-
-        // An empty workflow completes immediately with no steps executed
-        expect(run.stepResults).toHaveLength(0)
-    })
-})
-
-// ─── Step Factories ──────────────────────────────────────────────────────────
-
-describe('Step factories', () => {
-    it('llmStep creates a step with llm-call type', () => {
-        const step = llmStep('My LLM', { systemPrompt: 'sys', userPromptTemplate: 'user', outputVar: 'result' })
-        expect(step.type).toBe('llm-call')
-        expect(step.name).toBe('My LLM')
-        expect(typeof step.id).toBe('string')
-    })
-
-    it('transformStep creates a step with transform type', () => {
-        const step = transformStep('My Transform', { expression: 'x + 1', inputVars: ['x'], outputVar: 'y' })
-        expect(step.type).toBe('transform')
-    })
-
-    it('delayStep creates a step with delay type', () => {
-        const step = delayStep('Wait', 1000)
-        expect(step.type).toBe('delay')
-    })
-
-    it('linearWorkflow creates sequential connections', () => {
-        const s1 = llmStep('A', { systemPrompt: '', userPromptTemplate: '', outputVar: 'a' })
-        const s2 = llmStep('B', { systemPrompt: '', userPromptTemplate: '', outputVar: 'b' })
-        const { steps, connections } = linearWorkflow('Flow', [s1, s2])
-        expect(steps).toHaveLength(2)
-        expect(connections).toHaveLength(1)
-        expect(connections[0].fromStepId).toBe(s1.id)
-        expect(connections[0].toStepId).toBe(s2.id)
-    })
-})
-
-// ─── Interpolation ───────────────────────────────────────────────────────────
-
-describe('interpolate', () => {
-    it('replaces {{var}} placeholders', () => {
-        const result = interpolate('Hello {{name}}!', { name: 'World' })
-        expect(result).toBe('Hello World!')
-    })
-
-    it('supports dot-path access', () => {
-        const result = interpolate('{{user.name}}', { user: { name: 'Mehdi' } })
-        expect(result).toBe('Mehdi')
-    })
-
-    it('leaves missing vars as empty string', () => {
-        const result = interpolate('{{missing}}', {})
-        expect(result).not.toContain('{{missing}}')
-    })
-
-    it('extractVariables finds all placeholders', () => {
-        const vars = extractVariables('Hello {{name}}, you have {{count}} messages')
-        expect(vars).toContain('name')
-        expect(vars).toContain('count')
-        expect(vars).toHaveLength(2)
-    })
-})
-
-// ─── DAG utilities ───────────────────────────────────────────────────────────
-
-describe('DAG utilities', () => {
-    it('detectCycle returns null for a valid DAG', () => {
-        const nodeIds = ['a', 'b', 'c']
-        const edges = [{ from: 'a', to: 'b' }, { from: 'b', to: 'c' }]
-        expect(detectCycle(nodeIds, edges)).toBeNull()
-    })
-
-    it('detectCycle detects a cycle', () => {
-        const nodeIds = ['a', 'b', 'c']
-        const edges = [{ from: 'a', to: 'b' }, { from: 'b', to: 'c' }, { from: 'c', to: 'a' }]
-        expect(detectCycle(nodeIds, edges)).not.toBeNull()
-    })
-
-    it('topoSort returns valid topological order', () => {
-        const nodeIds = ['a', 'b', 'c']
-        const edges = [{ from: 'a', to: 'b' }, { from: 'b', to: 'c' }]
-        const order = topoSort(nodeIds, edges)
-        expect(order.indexOf('a')).toBeLessThan(order.indexOf('b'))
-        expect(order.indexOf('b')).toBeLessThan(order.indexOf('c'))
-    })
-
-    it('topoSort throws on cyclic graph', () => {
-        const nodeIds = ['a', 'b', 'c']
-        const edges = [{ from: 'a', to: 'b' }, { from: 'b', to: 'c' }, { from: 'c', to: 'a' }]
-        expect(() => topoSort(nodeIds, edges)).toThrow()
-    })
-})
-
-// ─── Validators ──────────────────────────────────────────────────────────────
-
-describe('validateWorkflow', () => {
-    it('validates a workflow with a valid step', () => {
-        const step = llmStep('My Step', { systemPrompt: 'sys', userPromptTemplate: 'user', outputVar: 'result' })
-        const wf = {
-            id: 'test',
-            name: 'Test Workflow',
-            version: 1,
-            status: 'active' as const,
-            steps: [step],
-            connections: [],
-            createdBy: 'user',
-            createdAt: Date.now(),
-            updatedAt: Date.now(),
-        }
-        const result = validateWorkflow(wf)
-        expect(result.success).toBe(true)
-    })
-
-    it('rejects a workflow with no steps', () => {
-        const wf = {
-            id: 'empty',
-            name: 'Empty Workflow',
-            version: 1,
-            status: 'active' as const,
-            steps: [],
-            connections: [],
-            createdBy: 'user',
-            createdAt: Date.now(),
-            updatedAt: Date.now(),
-        }
-        const result = validateWorkflow(wf)
-        expect(result.success).toBe(false)
-    })
-})
-
-// ─── Templates ───────────────────────────────────────────────────────────────
-
-describe('WORKFLOW_TEMPLATES', () => {
-    it('is a non-empty array', () => {
-        expect(Array.isArray(WORKFLOW_TEMPLATES)).toBe(true)
-        expect(WORKFLOW_TEMPLATES.length).toBeGreaterThan(0)
-    })
-
-    it('getTemplate returns a template by id', () => {
-        const first = WORKFLOW_TEMPLATES[0]
-        const found = getTemplate(first.id)
-        expect(found).toBeDefined()
-        expect(found?.id).toBe(first.id)
-    })
-})

package/packages/shared/src/config.ts

@@ -1,49 +0,0 @@
-/**
- * @fileoverview Configuration factory for Geenius AI Workflow
- */
-
-export interface ConfigureWorkflowOptions {
-  maxSteps?: number
-  maxExecutionTimeMs?: number
-  maxRetries?: number
-  defaultTimeout?: number
-  enableLogging?: boolean
-  enableMetrics?: boolean
-}
-
-/**
- * Configure the workflow system with execution options
- * @param options Configuration options for workflows
- * @returns WorkflowConfig object ready for use
- * @example
- * ```ts
- * const config = configureWorkflow({
- *   maxSteps: 50,
- *   maxExecutionTimeMs: 3600000,
- *   maxRetries: 3,
- *   enableMetrics: true,
- * })
- * ```
- */
-export function configureWorkflow(options: ConfigureWorkflowOptions = {}) {
-  return {
-    maxSteps: options.maxSteps ?? 100,
-    maxExecutionTimeMs: options.maxExecutionTimeMs ?? 3600000, // 1 hour
-    maxRetries: options.maxRetries ?? 3,
-    defaultTimeout: options.defaultTimeout ?? 30000, // 30 seconds
-    enableLogging: options.enableLogging ?? true,
-    enableMetrics: options.enableMetrics ?? false,
-  }
-}
-
-/**
- * Default workflow configuration
- */
-export const defaultWorkflowConfig = {
-  maxSteps: 100,
-  maxExecutionTimeMs: 3600000,
-  maxRetries: 3,
-  defaultTimeout: 30000,
-  enableLogging: true,
-  enableMetrics: false,
-}

package/packages/shared/src/convex/index.ts

@@ -1,2 +0,0 @@
-// @geenius-ai-workflow/shared — src/convex/index.ts
-export { workflowTables, workflowsTable, workflowRunsTable, workflowStepResultsTable } from './schemas'

package/packages/shared/src/convex/schemas.ts

@@ -1,42 +0,0 @@
-// @geenius-ai-workflow/shared — src/convex/schemas.ts
-export const workflowsTable = {
-    name: { type: 'string' as const },
-    description: { type: 'string' as const, optional: true as const },
-    version: { type: 'number' as const },
-    status: { type: 'string' as const },
-    definitionJson: { type: 'string' as const },
-    createdBy: { type: 'string' as const },
-    tags: { type: 'string' as const, optional: true as const },
-    createdAt: { type: 'number' as const },
-    updatedAt: { type: 'number' as const },
-}
-
-export const workflowRunsTable = {
-    workflowId: { type: 'string' as const },
-    workflowVersion: { type: 'number' as const },
-    status: { type: 'string' as const },
-    inputJson: { type: 'string' as const },
-    variablesJson: { type: 'string' as const },
-    currentStepIndex: { type: 'number' as const },
-    error: { type: 'string' as const, optional: true as const },
-    triggeredBy: { type: 'string' as const },
-    startedAt: { type: 'number' as const },
-    completedAt: { type: 'number' as const, optional: true as const },
-}
-
-export const workflowStepResultsTable = {
-    runId: { type: 'string' as const },
-    stepId: { type: 'string' as const },
-    stepName: { type: 'string' as const },
-    type: { type: 'string' as const },
-    status: { type: 'string' as const },
-    outputJson: { type: 'string' as const, optional: true as const },
-    error: { type: 'string' as const, optional: true as const },
-    durationMs: { type: 'number' as const },
-    tokens: { type: 'number' as const, optional: true as const },
-    costUsd: { type: 'number' as const, optional: true as const },
-    startedAt: { type: 'number' as const },
-    completedAt: { type: 'number' as const, optional: true as const },
-}
-
-export const workflowTables = { workflows: workflowsTable, workflowRuns: workflowRunsTable, workflowStepResults: workflowStepResultsTable }

package/packages/shared/src/engine.test.ts

@@ -1 +0,0 @@
-// This file has been superseded by src/__tests__/ai-workflow.test.ts — please use that file instead.

package/packages/shared/src/engine.ts

@@ -1,295 +0,0 @@
-// @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

@@ -1,43 +0,0 @@
-// @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'