@pikku/inspector 0.11.1 → 0.12.0

package/src/{workflow/extract-simple-workflow.ts → utils/workflow/dsl/extract-dsl-workflow.ts}

@@ -6,19 +6,29 @@ import {
   ParallelGroupStepMeta,
   FanoutStepMeta,
   ReturnStepMeta,
+  CancelStepMeta,
+  SetStepMeta,
+  SwitchStepMeta,
+  SwitchCaseMeta,
+  FilterStepMeta,
+  ArrayPredicateStepMeta,
   InputSource,
   OutputBinding,
+  Condition,
+  WorkflowContext,
+  ContextVariable,
 } from '@pikku/core/workflow'
-import {
-  extractStringLiteral,
-  extractNumberLiteral,
-} from '../utils/extract-node-value.js'
 import {
   isWorkflowDoCall,
   isWorkflowSleepCall,
+  isThrowCancelException,
+  extractCancelReason,
   isParallelFanout,
   isParallelGroup,
   isSequentialFanout,
+  isArrayFilter,
+  isArraySome,
+  isArrayEvery,
   extractForOfVariable,
   isArrayType,
   getSourceText,
@@ -29,6 +39,10 @@ import {
   formatValidationErrors,
   ValidationError,
 } from './validation.js'
+import {
+  extractStringLiteral,
+  extractNumberLiteral,
+} from '../../extract-node-value.js'
 
 /**
  * Extraction context to track state during AST traversal
@@ -40,6 +54,30 @@ interface ExtractionContext {
   conditionalVars: Set<string>
   inputParamName: string
   errors: ValidationError[]
+  /** Loop variables in scope (for fanout item variables) */
+  loopVars: Set<string>
+  /** Context variables (top-level let/const with simple values) */
+  contextVars: Map<string, { type: string; default: unknown }>
+  /** Track nesting depth to detect block-scoped vars */
+  depth: number
+}
+
+/**
+ * Extract full source path from an expression (e.g., data.memberEmails)
+ */
+function extractSourcePath(expr: ts.Expression): string | null {
+  if (ts.isIdentifier(expr)) {
+    return expr.text
+  }
+
+  if (ts.isPropertyAccessExpression(expr)) {
+    const base = extractSourcePath(expr.expression)
+    if (base) {
+      return `${base}.${expr.name.text}`
+    }
+  }
+
+  return null
 }
 
 /**
@@ -48,6 +86,8 @@ interface ExtractionContext {
 export interface ExtractionResult {
   status: 'ok' | 'error'
   steps?: WorkflowStepMeta[]
+  /** Workflow context (top-level variables) */
+  context?: WorkflowContext
   reason?: string
   simple?: boolean
 }
@@ -55,7 +95,7 @@ export interface ExtractionResult {
 /**
  * Extract simple workflow metadata from a function declaration
  */
-export function extractSimpleWorkflow(
+export function extractDSLWorkflow(
   funcNode: ts.Node,
   checker: ts.TypeChecker
 ): ExtractionResult {
@@ -88,6 +128,9 @@ export function extractSimpleWorkflow(
       conditionalVars: new Set(),
       inputParamName,
       errors: [],
+      loopVars: new Set(),
+      contextVars: new Map(),
+      depth: 0,
     }
 
     // Validate no disallowed patterns
@@ -122,9 +165,20 @@ export function extractSimpleWorkflow(
       }
     }
 
+    // Build workflow context from extracted context variables
+    const workflowContext: WorkflowContext = {}
+    for (const [name, info] of context.contextVars) {
+      workflowContext[name] = {
+        type: info.type as ContextVariable['type'],
+        default: info.default,
+      }
+    }
+
     return {
       status: 'ok',
       steps,
+      context:
+        Object.keys(workflowContext).length > 0 ? workflowContext : undefined,
       simple: true,
     }
   } catch (error) {
@@ -140,7 +194,7 @@ export function extractSimpleWorkflow(
  * Find the workflow function (async arrow function)
  */
 function findWorkflowFunction(node: ts.Node): ts.ArrowFunction | null {
-  // Handle pikkuSimpleWorkflowFunc(async () => {}) or pikkuWorkflowFunc(async () => {})
+  // Handle pikkuWorkflowFunc(async () => {}) or pikkuWorkflowComplexFunc(async () => {})
   if (ts.isCallExpression(node)) {
     const arg = node.arguments[0]
     if (arg && ts.isArrowFunction(arg)) {
@@ -162,7 +216,7 @@ function findWorkflowFunction(node: ts.Node): ts.ArrowFunction | null {
     }
   }
 
-  // Handle pikkuSimpleWorkflowFunc({ func: async () => {} })
+  // Handle pikkuWorkflowFunc({ func: async () => {} })
   if (ts.isObjectLiteralExpression(node)) {
     for (const prop of node.properties) {
       if (
@@ -201,7 +255,8 @@ function extractInputParamName(arrowFunc: ts.ArrowFunction): string | null {
  */
 function extractSteps(
   body: ts.Node,
-  context: ExtractionContext
+  context: ExtractionContext,
+  incrementDepth = false
 ): WorkflowStepMeta[] {
   const steps: WorkflowStepMeta[] = []
 
@@ -209,6 +264,11 @@ function extractSteps(
     return steps
   }
 
+  // Increment depth when entering a nested block
+  if (incrementDepth) {
+    context.depth++
+  }
+
   for (const statement of body.statements) {
     const extracted = extractStep(statement, context)
     if (extracted) {
@@ -216,6 +276,11 @@ function extractSteps(
     }
   }
 
+  // Restore depth
+  if (incrementDepth) {
+    context.depth--
+  }
+
   return steps
 }
 
@@ -241,6 +306,11 @@ function extractStep(
     return extractBranch(statement, context)
   }
 
+  // Switch statement
+  if (ts.isSwitchStatement(statement)) {
+    return extractSwitch(statement, context)
+  }
+
   // For-of statement (sequential fanout)
   if (ts.isForOfStatement(statement)) {
     return extractSequentialFanout(statement, context)
@@ -251,6 +321,11 @@ function extractStep(
     return extractReturn(statement, context)
   }
 
+  // Throw statement (for WorkflowCancelledException)
+  if (ts.isThrowStatement(statement)) {
+    return extractThrowCancel(statement, context)
+  }
+
   return null
 }
 
@@ -274,10 +349,28 @@ function extractVariableDeclaration(
   const varName = decl.name.text
   const init = decl.initializer
 
+  // Check for block-scoped variable declarations (not allowed)
+  if (context.depth > 0) {
+    context.errors.push({
+      message: `Variable declaration '${varName}' inside block is not supported in DSL workflows. Move all let/const declarations to the top level.`,
+      node: statement,
+    })
+    return null
+  }
+
   if (!init) {
     return null
   }
 
+  // Check for simple literal/expression context variable (let x = 'value')
+  const literalValue = extractLiteralValue(init)
+  if (literalValue !== undefined) {
+    const tsType = context.checker.getTypeAtLocation(decl)
+    const typeStr = inferSimpleType(tsType, context.checker)
+    context.contextVars.set(varName, { type: typeStr, default: literalValue })
+    return null // No step emitted, just register the context var
+  }
+
   // Check for await workflow.do(...)
   if (ts.isAwaitExpression(init) && ts.isCallExpression(init.expression)) {
     const call = init.expression
@@ -315,6 +408,30 @@ function extractVariableDeclaration(
     }
   }
 
+  // Check for array.filter(...)
+  if (ts.isCallExpression(init)) {
+    if (isArrayFilter(init)) {
+      const filterStep = extractArrayFilter(init, context, varName)
+      if (filterStep) {
+        const type = context.checker.getTypeAtLocation(decl)
+        context.outputVars.set(varName, { type, node: decl })
+        if (isArrayType(type, context.checker)) {
+          context.arrayVars.add(varName)
+        }
+        return filterStep
+      }
+    }
+
+    if (isArraySome(init) || isArrayEvery(init)) {
+      const predicateStep = extractArrayPredicate(init, context, varName)
+      if (predicateStep) {
+        const type = context.checker.getTypeAtLocation(decl)
+        context.outputVars.set(varName, { type, node: decl })
+        return predicateStep
+      }
+    }
+  }
+
   return null
 }
 
@@ -327,7 +444,7 @@ function extractExpressionStatement(
 ): WorkflowStepMeta | null {
   let expr = statement.expression
 
-  // Handle assignment: owner = await workflow.do(...)
+  // Handle assignment: x = value or x = await workflow.do(...)
   let outputVar: string | undefined
   if (
     ts.isBinaryExpression(expr) &&
@@ -336,6 +453,24 @@ function extractExpressionStatement(
     // Extract variable name from left side
     if (ts.isIdentifier(expr.left)) {
       outputVar = expr.left.text
+
+      // Check if this is an assignment to a context variable (set step)
+      if (context.contextVars.has(outputVar)) {
+        const literalValue = extractLiteralValue(expr.right)
+        if (literalValue !== undefined) {
+          return {
+            type: 'set',
+            variable: outputVar,
+            value: literalValue,
+          } as SetStepMeta
+        }
+        // Non-literal assignment to context var - use expression as string
+        return {
+          type: 'set',
+          variable: outputVar,
+          value: getSourceText(expr.right),
+        } as SetStepMeta
+      }
     }
     // Use right side as the expression to extract from
     expr = expr.right
@@ -510,32 +645,102 @@ function extractSleepStep(
 }
 
 /**
- * Extract branch step from if statement
+ * Extract cancel step from throw WorkflowCancelledException statement
+ */
+function extractThrowCancel(
+  statement: ts.ThrowStatement,
+  context: ExtractionContext
+): CancelStepMeta | null {
+  if (!isThrowCancelException(statement)) {
+    return null
+  }
+
+  const reason = extractCancelReason(statement, context.checker)
+  return {
+    type: 'cancel',
+    reason,
+  }
+}
+
+/**
+ * Parse a condition expression into a Condition structure
+ */
+function parseCondition(expr: ts.Expression): Condition {
+  // Handle binary expressions (&&, ||)
+  if (ts.isBinaryExpression(expr)) {
+    const operator = expr.operatorToken.kind
+
+    // AND operator (&&)
+    if (operator === ts.SyntaxKind.AmpersandAmpersandToken) {
+      return {
+        type: 'and',
+        conditions: [parseCondition(expr.left), parseCondition(expr.right)],
+      }
+    }
+
+    // OR operator (||)
+    if (operator === ts.SyntaxKind.BarBarToken) {
+      return {
+        type: 'or',
+        conditions: [parseCondition(expr.left), parseCondition(expr.right)],
+      }
+    }
+  }
+
+  // Handle parenthesized expressions - unwrap and parse inner
+  if (ts.isParenthesizedExpression(expr)) {
+    return parseCondition(expr.expression)
+  }
+
+  // Simple condition (comparison, function call, variable, etc.)
+  return {
+    type: 'simple',
+    expression: getSourceText(expr),
+  }
+}
+
+/**
+ * Extract branch step from if statement (supports if/else-if/else chains)
  */
 function extractBranch(
   statement: ts.IfStatement,
   context: ExtractionContext
 ): BranchStepMeta | null {
-  const condition = getSourceText(statement.expression)
-
-  // Handle both block statements and single statements
-  const thenSteps = ts.isBlock(statement.thenStatement)
-    ? extractSteps(statement.thenStatement, context)
-    : extractStepsFromStatement(statement.thenStatement, context)
-
-  const elseSteps = statement.elseStatement
-    ? ts.isBlock(statement.elseStatement)
-      ? extractSteps(statement.elseStatement, context)
-      : extractStepsFromStatement(statement.elseStatement, context)
-    : undefined
+  const branches: BranchStepMeta['branches'] = []
+  let elseSteps: BranchStepMeta['elseSteps']
+
+  // Walk the if/else-if chain
+  let current: ts.IfStatement | undefined = statement
+  while (current) {
+    const condition = parseCondition(current.expression)
+    const steps = ts.isBlock(current.thenStatement)
+      ? extractSteps(current.thenStatement, context, true)
+      : extractStepsFromStatement(current.thenStatement, context)
+
+    branches.push({ condition, steps })
+
+    // Check for else-if or else
+    if (current.elseStatement) {
+      if (ts.isIfStatement(current.elseStatement)) {
+        // else-if: continue the chain
+        current = current.elseStatement
+      } else {
+        // else: extract the final else block and stop
+        elseSteps = ts.isBlock(current.elseStatement)
+          ? extractSteps(current.elseStatement, context, true)
+          : extractStepsFromStatement(current.elseStatement, context)
+        current = undefined
+      }
+    } else {
+      // No else clause
+      current = undefined
+    }
+  }
 
   return {
     type: 'branch',
-    condition,
-    branches: {
-      then: thenSteps,
-      else: elseSteps,
-    },
+    branches,
+    elseSteps,
   }
 }
 
@@ -546,10 +751,198 @@ function extractStepsFromStatement(
   statement: ts.Statement,
   context: ExtractionContext
 ): WorkflowStepMeta[] {
+  // Increment depth for single-statement blocks (if without braces)
+  context.depth++
   const step = extractStep(statement, context)
+  context.depth--
   return step ? [step] : []
 }
 
+/**
+ * Extract switch statement
+ */
+function extractSwitch(
+  statement: ts.SwitchStatement,
+  context: ExtractionContext
+): SwitchStepMeta | null {
+  const expression = getSourceText(statement.expression)
+  const cases: SwitchCaseMeta[] = []
+  let defaultSteps: WorkflowStepMeta[] | undefined
+
+  for (const clause of statement.caseBlock.clauses) {
+    if (ts.isCaseClause(clause)) {
+      const caseValue = extractCaseValue(clause.expression)
+      const steps = extractCaseSteps(clause.statements, context)
+
+      cases.push({
+        value: caseValue.value,
+        expression: caseValue.expression,
+        steps,
+      })
+    } else if (ts.isDefaultClause(clause)) {
+      defaultSteps = extractCaseSteps(clause.statements, context)
+    }
+  }
+
+  return {
+    type: 'switch',
+    expression,
+    cases,
+    defaultSteps,
+  }
+}
+
+/**
+ * Extract case value from expression
+ */
+function extractCaseValue(expr: ts.Expression): {
+  value?: string | number | boolean | null
+  expression?: string
+} {
+  if (ts.isStringLiteral(expr)) {
+    return { value: expr.text }
+  }
+  if (ts.isNumericLiteral(expr)) {
+    return { value: Number(expr.text) }
+  }
+  if (expr.kind === ts.SyntaxKind.TrueKeyword) {
+    return { value: true }
+  }
+  if (expr.kind === ts.SyntaxKind.FalseKeyword) {
+    return { value: false }
+  }
+  if (expr.kind === ts.SyntaxKind.NullKeyword) {
+    return { value: null }
+  }
+
+  return { expression: getSourceText(expr) }
+}
+
+/**
+ * Extract steps from case statements, stopping at break
+ */
+function extractCaseSteps(
+  statements: ts.NodeArray<ts.Statement>,
+  context: ExtractionContext
+): WorkflowStepMeta[] {
+  const steps: WorkflowStepMeta[] = []
+
+  // Increment depth for case blocks
+  context.depth++
+
+  for (const statement of statements) {
+    if (ts.isBreakStatement(statement)) {
+      break
+    }
+
+    const step = extractStep(statement, context)
+    if (step) {
+      steps.push(step)
+    }
+  }
+
+  // Restore depth
+  context.depth--
+
+  return steps
+}
+
+/**
+ * Extract array filter operation
+ */
+function extractArrayFilter(
+  call: ts.CallExpression,
+  context: ExtractionContext,
+  outputVar?: string
+): FilterStepMeta | null {
+  if (!ts.isPropertyAccessExpression(call.expression)) {
+    return null
+  }
+
+  const sourceExpr = call.expression.expression
+  const sourceVar = extractSourcePath(sourceExpr)
+
+  if (!sourceVar) {
+    return null
+  }
+
+  const filterFn = call.arguments[0]
+  if (!filterFn || !ts.isArrowFunction(filterFn)) {
+    return null
+  }
+
+  const itemParam = filterFn.parameters[0]
+  if (!itemParam || !ts.isIdentifier(itemParam.name)) {
+    return null
+  }
+
+  const itemVar = itemParam.name.text
+
+  let condition: Condition
+  if (ts.isBlock(filterFn.body)) {
+    return null
+  } else {
+    condition = parseCondition(filterFn.body)
+  }
+
+  return {
+    type: 'filter',
+    sourceVar,
+    itemVar,
+    condition,
+    outputVar,
+  }
+}
+
+/**
+ * Extract array predicate operation (some/every)
+ */
+function extractArrayPredicate(
+  call: ts.CallExpression,
+  context: ExtractionContext,
+  outputVar?: string
+): ArrayPredicateStepMeta | null {
+  if (!ts.isPropertyAccessExpression(call.expression)) {
+    return null
+  }
+
+  const mode = call.expression.name.text as 'some' | 'every'
+  const sourceExpr = call.expression.expression
+  const sourceVar = extractSourcePath(sourceExpr)
+
+  if (!sourceVar) {
+    return null
+  }
+
+  const predicateFn = call.arguments[0]
+  if (!predicateFn || !ts.isArrowFunction(predicateFn)) {
+    return null
+  }
+
+  const itemParam = predicateFn.parameters[0]
+  if (!itemParam || !ts.isIdentifier(itemParam.name)) {
+    return null
+  }
+
+  const itemVar = itemParam.name.text
+
+  let condition: Condition
+  if (ts.isBlock(predicateFn.body)) {
+    return null
+  } else {
+    condition = parseCondition(predicateFn.body)
+  }
+
+  return {
+    type: 'arrayPredicate',
+    mode,
+    sourceVar,
+    itemVar,
+    condition,
+    outputVar,
+  }
+}
+
 /**
  * Extract parallel fanout from Promise.all(array.map(...))
  */
@@ -568,16 +961,7 @@ function extractParallelFanout(
 
   // Extract source array
   const sourceExpr = mapCall.expression.expression
-  let sourceVar: string | null = null
-
-  if (ts.isIdentifier(sourceExpr)) {
-    sourceVar = sourceExpr.text
-  } else if (
-    ts.isPropertyAccessExpression(sourceExpr) &&
-    ts.isIdentifier(sourceExpr.expression)
-  ) {
-    sourceVar = sourceExpr.expression.text
-  }
+  const sourceVar = extractSourcePath(sourceExpr)
 
   if (!sourceVar) {
     return null
@@ -610,7 +994,16 @@ function extractParallelFanout(
   } else if (ts.isBlock(mapFn.body)) {
     // Look for workflow.do in block
     for (const stmt of mapFn.body.statements) {
-      if (ts.isReturnStatement(stmt) && stmt.expression) {
+      if (ts.isExpressionStatement(stmt)) {
+        // Handle: await workflow.do(...)
+        if (
+          ts.isAwaitExpression(stmt.expression) &&
+          ts.isCallExpression(stmt.expression.expression)
+        ) {
+          doCall = stmt.expression.expression
+          break
+        }
+      } else if (ts.isReturnStatement(stmt) && stmt.expression) {
         if (ts.isCallExpression(stmt.expression)) {
           doCall = stmt.expression
           break
@@ -629,10 +1022,11 @@ function extractParallelFanout(
     return null
   }
 
-  // Create a temporary context for the child step
+  // Create a temporary context for the child step with the loop variable
   const childContext: ExtractionContext = {
     ...context,
     outputVars: new Map(context.outputVars),
+    loopVars: new Set([...context.loopVars, itemVar]),
   }
 
   const childStep = extractRpcStep(doCall, childContext)
@@ -709,8 +1103,43 @@ function extractSequentialFanout(
   let childStep: RpcStepMeta | null = null
   let timeBetween: string | undefined = undefined
 
+  // Create a child context with the loop variable added
+  const childContext: ExtractionContext = {
+    ...context,
+    outputVars: new Map(context.outputVars),
+    loopVars: new Set([...context.loopVars, itemVar]),
+  }
+
+  let workflowDoCount = 0
+
   for (const stmt of statement.statement.statements) {
-    // Look for workflow.do
+    // Look for workflow.do in VariableStatement (const x = await workflow.do(...))
+    if (ts.isVariableStatement(stmt)) {
+      const declList = stmt.declarationList
+      if (declList.declarations.length === 1) {
+        const decl = declList.declarations[0]
+        const init = decl.initializer
+        if (
+          init &&
+          ts.isAwaitExpression(init) &&
+          ts.isCallExpression(init.expression)
+        ) {
+          const call = init.expression
+          if (isWorkflowDoCall(call, context.checker)) {
+            workflowDoCount++
+            const varName = ts.isIdentifier(decl.name)
+              ? decl.name.text
+              : undefined
+            const step = extractRpcStep(call, childContext, varName)
+            if (step) {
+              childStep = step
+            }
+          }
+        }
+      }
+    }
+
+    // Look for workflow.do in ExpressionStatement (await workflow.do(...))
     if (ts.isExpressionStatement(stmt)) {
       const expr = stmt.expression
 
@@ -718,7 +1147,8 @@ function extractSequentialFanout(
         const call = expr.expression
 
         if (isWorkflowDoCall(call, context.checker)) {
-          const step = extractRpcStep(call, context)
+          workflowDoCount++
+          const step = extractRpcStep(call, childContext)
           if (step) {
             childStep = step
           }
@@ -785,6 +1215,15 @@ function extractSequentialFanout(
     return null
   }
 
+  // If there are multiple workflow.do calls, the loop is too complex for DSL
+  if (workflowDoCount > 1) {
+    context.errors.push({
+      message: `For-of loop has ${workflowDoCount} workflow.do calls but DSL only supports 1. Use pikkuWorkflowComplexFunc for complex loops.`,
+      node: statement,
+    })
+    return null
+  }
+
   return {
     type: 'fanout',
     stepName: childStep.stepName,
@@ -796,6 +1235,66 @@ function extractSequentialFanout(
   }
 }
 
+/**
+ * Extract a single output binding from an expression
+ */
+function extractOutputBinding(
+  expr: ts.Expression,
+  context: ExtractionContext
+): OutputBinding | null {
+  // Check for property access (e.g., org.id, payment.status)
+  if (ts.isPropertyAccessExpression(expr)) {
+    const objName = ts.isIdentifier(expr.expression)
+      ? expr.expression.text
+      : null
+    const propPath = expr.name.text
+
+    if (objName && context.outputVars.has(objName)) {
+      return { from: 'outputVar', name: objName, path: propPath }
+    }
+    if (objName && context.contextVars.has(objName)) {
+      return { from: 'stateVar', name: objName, path: propPath }
+    }
+    if (objName === context.inputParamName) {
+      return { from: 'input', path: propPath }
+    }
+  }
+
+  // Check for identifier (simple variable reference)
+  if (ts.isIdentifier(expr)) {
+    const varName = expr.text
+    if (context.outputVars.has(varName)) {
+      return { from: 'outputVar', name: varName }
+    }
+    if (context.contextVars.has(varName)) {
+      return { from: 'stateVar', name: varName }
+    }
+    if (varName === context.inputParamName) {
+      return { from: 'input', path: varName }
+    }
+  }
+
+  // Check for literals
+  if (ts.isStringLiteral(expr)) {
+    return { from: 'literal', value: expr.text }
+  }
+  if (ts.isNumericLiteral(expr)) {
+    return { from: 'literal', value: Number(expr.text) }
+  }
+  if (expr.kind === ts.SyntaxKind.TrueKeyword) {
+    return { from: 'literal', value: true }
+  }
+  if (expr.kind === ts.SyntaxKind.FalseKeyword) {
+    return { from: 'literal', value: false }
+  }
+  if (expr.kind === ts.SyntaxKind.NullKeyword) {
+    return { from: 'literal', value: null }
+  }
+
+  // For any other expression (comparisons, method calls, etc.), capture as expression
+  return { from: 'expression', expression: getSourceText(expr) }
+}
+
 /**
  * Extract return step
  */
@@ -826,48 +1325,17 @@ function extractReturn(
       let binding: OutputBinding | null = null
 
       if (ts.isShorthandPropertyAssignment(prop)) {
-        // { orgId } - must be an output variable
+        // { orgId } - must be an output variable, context variable, or input
         const varName = prop.name.text
         if (context.outputVars.has(varName)) {
           binding = { from: 'outputVar', name: varName }
+        } else if (context.contextVars.has(varName)) {
+          binding = { from: 'stateVar', name: varName }
+        } else {
+          binding = { from: 'input', path: varName }
         }
       } else if (ts.isPropertyAssignment(prop)) {
-        const init = prop.initializer
-
-        // Check for property access (e.g., org.id, owner?.id)
-        if (ts.isPropertyAccessExpression(init)) {
-          const objName = ts.isIdentifier(init.expression)
-            ? init.expression.text
-            : null
-          const propPath = init.name.text
-
-          if (objName && context.outputVars.has(objName)) {
-            binding = { from: 'outputVar', name: objName, path: propPath }
-          }
-        }
-
-        // Check for optional chaining (e.g., owner?.id)
-        if (
-          init.kind === ts.SyntaxKind.PropertyAccessExpression ||
-          init.kind === ts.SyntaxKind.NonNullExpression
-        ) {
-          const text = init.getText()
-          const match = text.match(/^(\w+)\??\.(\w+)$/)
-          if (match) {
-            const [, objName, propPath] = match
-            if (context.outputVars.has(objName)) {
-              binding = { from: 'outputVar', name: objName, path: propPath }
-            }
-          }
-        }
-
-        // Check for identifier (simple variable reference)
-        if (ts.isIdentifier(init)) {
-          const varName = init.text
-          if (context.outputVars.has(varName)) {
-            binding = { from: 'outputVar', name: varName }
-          }
-        }
+        binding = extractOutputBinding(prop.initializer, context)
       }
 
       if (binding) {
@@ -892,7 +1360,19 @@ function extractReturn(
 function extractInputSources(
   node: ts.Node,
   context: ExtractionContext
-): Record<string, InputSource> | undefined {
+): Record<string, InputSource> | 'passthrough' | undefined {
+  // Handle when data is passed directly (e.g., workflow.do('step', 'rpc', data))
+  if (ts.isIdentifier(node)) {
+    if (node.text === context.inputParamName) {
+      // The entire input data is being passed through
+      return 'passthrough'
+    }
+    // Check if it's an output variable being passed directly
+    if (context.outputVars.has(node.text)) {
+      return 'passthrough'
+    }
+  }
+
   if (!ts.isObjectLiteralExpression(node)) {
     return undefined
   }
@@ -912,9 +1392,11 @@ function extractInputSources(
       let source: InputSource | null = null
 
       if (ts.isShorthandPropertyAssignment(prop)) {
-        // { email } - could be from input or output var
+        // { email } - could be from loop var, output var, or input
         const varName = prop.name.text
-        if (context.outputVars.has(varName)) {
+        if (context.loopVars.has(varName)) {
+          source = { from: 'item', path: varName }
+        } else if (context.outputVars.has(varName)) {
           source = { from: 'outputVar', name: varName }
         } else {
           source = { from: 'input', path: varName }
@@ -944,6 +1426,26 @@ function extractInputSources(
   return Object.keys(inputs).length > 0 ? inputs : undefined
 }
 
+function inputSourceToInlineValue(source: InputSource): unknown {
+  switch (source.from) {
+    case 'literal':
+      return source.value
+    case 'input':
+      return { $ref: 'trigger', path: source.path }
+    case 'outputVar':
+      return { $ref: source.name, path: source.path }
+    case 'item':
+      return { $ref: '$item', path: source.path }
+    case 'template':
+      return {
+        $template: {
+          parts: source.parts,
+          expressions: source.expressions.map(inputSourceToInlineValue),
+        },
+      }
+  }
+}
+
 /**
  * Extract a single input source
  */
@@ -973,6 +1475,11 @@ function extractInputSource(
   if (ts.isIdentifier(node)) {
     const varName = node.text
 
+    // Check if it's a loop variable (from fanout)
+    if (context.loopVars.has(varName)) {
+      return { from: 'item', path: varName }
+    }
+
     if (context.outputVars.has(varName)) {
       return { from: 'outputVar', name: varName }
     }
@@ -1011,8 +1518,8 @@ function extractInputSource(
       if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
         const propName = prop.name.text
         const propSource = extractInputSource(prop.initializer, context)
-        if (propSource && propSource.from === 'literal') {
-          obj[propName] = propSource.value
+        if (propSource) {
+          obj[propName] = inputSourceToInlineValue(propSource)
         }
       }
     }
@@ -1024,12 +1531,98 @@ function extractInputSource(
     const arr: unknown[] = []
     for (const elem of node.elements) {
       const elemSource = extractInputSource(elem, context)
-      if (elemSource && elemSource.from === 'literal') {
-        arr.push(elemSource.value)
+      if (elemSource) {
+        arr.push(inputSourceToInlineValue(elemSource))
       }
     }
     return { from: 'literal', value: arr }
   }
 
+  // No substitution template literal: `hello`
+  if (ts.isNoSubstitutionTemplateLiteral(node)) {
+    return { from: 'literal', value: node.text }
+  }
+
+  // Template expression with substitutions: `hello ${name}`
+  if (ts.isTemplateExpression(node)) {
+    const parts: string[] = [node.head.text]
+    const expressions: InputSource[] = []
+
+    for (const span of node.templateSpans) {
+      // Extract each expression
+      const exprSource = extractInputSource(span.expression, context)
+      if (exprSource) {
+        expressions.push(exprSource)
+      } else {
+        // Fallback: use source text as literal
+        expressions.push({
+          from: 'literal',
+          value: getSourceText(span.expression),
+        })
+      }
+      parts.push(span.literal.text)
+    }
+
+    return { from: 'template', parts, expressions }
+  }
+
   return null
 }
+
+/**
+ * Extract a literal value from an expression
+ */
+function extractLiteralValue(expr: ts.Expression): unknown | undefined {
+  if (ts.isStringLiteral(expr)) {
+    return expr.text
+  }
+  if (ts.isNumericLiteral(expr)) {
+    return Number(expr.text)
+  }
+  if (expr.kind === ts.SyntaxKind.TrueKeyword) {
+    return true
+  }
+  if (expr.kind === ts.SyntaxKind.FalseKeyword) {
+    return false
+  }
+  if (expr.kind === ts.SyntaxKind.NullKeyword) {
+    return null
+  }
+  // Array literal
+  if (ts.isArrayLiteralExpression(expr)) {
+    const values: unknown[] = []
+    for (const el of expr.elements) {
+      const v = extractLiteralValue(el)
+      if (v === undefined) return undefined
+      values.push(v)
+    }
+    return values
+  }
+  // Object literal (simple keys with literal values)
+  if (ts.isObjectLiteralExpression(expr)) {
+    const obj: Record<string, unknown> = {}
+    for (const prop of expr.properties) {
+      if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
+        const v = extractLiteralValue(prop.initializer)
+        if (v === undefined) return undefined
+        obj[prop.name.text] = v
+      } else {
+        return undefined
+      }
+    }
+    return obj
+  }
+  return undefined
+}
+
+/**
+ * Infer a simple type string from a TypeScript type
+ */
+function inferSimpleType(type: ts.Type, checker: ts.TypeChecker): string {
+  const typeStr = checker.typeToString(type)
+  if (typeStr === 'string') return 'string'
+  if (typeStr === 'number') return 'number'
+  if (typeStr === 'boolean') return 'boolean'
+  if (typeStr.endsWith('[]') || typeStr.startsWith('Array<')) return 'array'
+  return 'object'
+}