import { Workflow } from 'ai-workflows'

const workflow = Workflow($ => {
  $.on.Customer.created(async (customer, $) => {
    await $.send('Email.welcome', { to: customer.email })
  })

  $.every.Monday.at9am(async ($) => {
    $.log('Weekly standup reminder')
  })
})

await workflow.start()

Workflow($ => {
  $.on.Order.placed(async (order, $) => {
    $.log('Processing order', order.id)
    await $.send('Inventory.reserve', { items: order.items })
    await $.send('Payment.charge', { amount: order.total })
  })

  $.on.Payment.completed(async (payment, $) => {
    await $.send('Order.fulfill', { orderId: payment.orderId })
  })

  $.on.Payment.failed(async (payment, $) => {
    await $.send('Customer.notify', {
      message: 'Payment failed',
      orderId: payment.orderId
    })
  })
})

Workflow($ => {
  // Simple intervals
  $.every.hour(async ($) => {
    $.log('Hourly health check')
  })

  // Day + time combinations
  $.every.Monday.at9am(async ($) => {
    const report = await $.do('Analytics.weeklyReport', {})
    await $.send('Slack.post', { channel: '#metrics', report })
  })

  $.every.weekday.at8am(async ($) => {
    $.log('Good morning! Time to standup.')
  })

  // Precise intervals
  $.every.minutes(30)(async ($) => {
    await $.send('Cache.refresh', {})
  })
})

import { CascadeExecutor } from 'ai-workflows'

const processRefund = new CascadeExecutor({
  cascadeName: 'refund-processor',

  tiers: {
    // Tier 1: Deterministic rules (fastest, cheapest)
    code: {
      name: 'rule-based-refund',
      execute: async (request) => {
        if (request.amount < 50 && request.reason === 'defective') {
          return { approved: true, method: 'original-payment' }
        }
        throw new Error('Rules inconclusive')
      }
    },

    // Tier 2: AI analysis for complex cases
    generative: {
      name: 'ai-refund-analysis',
      execute: async (request, ctx) => {
        const analysis = await analyzeRefundRequest(request)
        if (analysis.confidence > 0.9) {
          return { approved: analysis.shouldApprove, reason: analysis.explanation }
        }
        throw new Error('Confidence too low')
      }
    },

    // Tier 3: Agent with tool access
    agentic: {
      name: 'refund-agent',
      execute: async (request, ctx) => {
        return await refundAgent.process(request)
      }
    },

    // Tier 4: Human review for edge cases
    human: {
      name: 'human-review',
      execute: async (request) => {
        return await createHumanTask({
          type: 'refund-review',
          data: request,
          assignTo: 'support-team'
        })
      }
    }
  },

  // Default timeouts per tier
  useDefaultTimeouts: true,  // code: 5s, generative: 30s, agentic: 5m, human: 24h
})

const result = await processRefund.execute(refundRequest)
console.log(`Resolved by ${result.tier} tier in ${result.metrics.totalDuration}ms`)

import { DependencyGraph, getExecutionLevels } from 'ai-workflows'

const graph = new DependencyGraph()

// Steps with no dependencies run first (level 0)
graph.addNode('fetch-user')
graph.addNode('fetch-products')

// Dependent steps run after their dependencies complete
graph.addNode('validate-cart', { dependsOn: ['fetch-user', 'fetch-products'] })
graph.addNode('calculate-shipping', { dependsOn: 'fetch-products' })
graph.addNode('apply-discounts', { dependsOn: 'validate-cart' })
graph.addNode('process-payment', { dependsOn: ['apply-discounts', 'calculate-shipping'] })

// Automatic cycle detection
try {
  graph.addNode('bad-step', { dependsOn: 'process-payment' })
  graph.addEdge('bad-step', 'fetch-user')  // Would create a cycle!
} catch (e) {
  console.log('Caught circular dependency:', e.cyclePath)
}

import { topologicalSort, getExecutionLevels } from 'ai-workflows'

const steps = [
  { id: 'A', dependencies: [] },
  { id: 'B', dependencies: ['A'] },
  { id: 'C', dependencies: ['A'] },
  { id: 'D', dependencies: ['B', 'C'] },
]

// Linear execution order
const { order } = topologicalSort(steps)
// => ['A', 'B', 'C', 'D']

// Parallel execution groups
const levels = getExecutionLevels(steps)
// => [
//   { level: 0, nodes: ['A'] },        // Run first
//   { level: 1, nodes: ['B', 'C'] },   // Run in parallel
//   { level: 2, nodes: ['D'] }         // Run after B and C complete
// ]

import { waitForAll, waitForAny, Barrier, withConcurrencyLimit } from 'ai-workflows'

// Wait for all parallel tasks
const results = await waitForAll([
  fetchUserData(userId),
  fetchOrderHistory(userId),
  fetchRecommendations(userId),
], { timeout: 5000 })

// Wait for N of M (e.g., 2 of 3 replicas)
const { completed, pending } = await waitForAny(2, [
  writeToReplica1(data),
  writeToReplica2(data),
  writeToReplica3(data),
])

// Manual barrier for complex coordination
const barrier = new Barrier(3, {
  timeout: 10000,
  onProgress: ({ arrived, expected, percentage }) => {
    console.log(`${arrived}/${expected} (${percentage}%)`)
  }
})

// In parallel handlers...
barrier.arrive(resultFromWorker1)
barrier.arrive(resultFromWorker2)
barrier.arrive(resultFromWorker3)

// Wait for all to arrive
const allResults = await barrier.wait()

const urls = [/* 100 URLs */]

// Process 5 at a time
const results = await withConcurrencyLimit(
  urls.map(url => () => fetch(url)),
  5,  // max concurrent
  { collectErrors: true }  // don't fail fast
)

import { on, every, send } from 'ai-workflows'

// Register handlers
on.Customer.created(async (customer, $) => {
  await $.send('Email.welcome', { to: customer.email })
})

every.hour(async ($) => {
  $.log('Background task running')
})

// Emit events from anywhere
await send('Customer.created', { name: 'Alice', email: 'alice@example.com' })

import { setCronConverter } from 'ai-workflows'

setCronConverter(async (description) => {
  // Use your AI service to convert natural language to cron
  const response = await ai.complete(`Convert to cron: "${description}"`)
  return response.cron
})

// Now you can use natural language
$.every('first Monday of the month at 9am', handler)
$.every('every 15 minutes during business hours', handler)

const executor = new CascadeExecutor({
  tiers: { /* ... */ },

  // Custom timeouts per tier (milliseconds)
  timeouts: {
    code: 2000,        // 2 seconds
    generative: 15000, // 15 seconds
    agentic: 60000,    // 1 minute
    human: 3600000,    // 1 hour
  },

  // Or use defaults
  useDefaultTimeouts: true,  // code: 5s, generative: 30s, agentic: 5m, human: 24h

  // Total cascade timeout
  totalTimeout: 300000,  // 5 minutes max for entire cascade
})

const executor = new CascadeExecutor({
  tiers: { /* ... */ },

  retryConfig: {
    code: { maxRetries: 2, baseDelay: 100 },
    generative: { maxRetries: 3, baseDelay: 1000, multiplier: 2 },
    agentic: { maxRetries: 1, baseDelay: 5000 },
  }
})

import { createTestContext } from 'ai-workflows'

const $ = createTestContext()

// Call your handler
await orderHandler({ id: '123', total: 99.99 }, $)

// Assert on emitted events
expect($.emittedEvents).toContainEqual({
  event: 'Payment.charge',
  data: { amount: 99.99 },
})