@pikku/inspector 0.12.56 → 0.12.59

package/src/utils/workflow/dsl/extract-approval-policy.test.ts

@@ -0,0 +1,68 @@
+import { describe, test } from 'node:test'
+import assert from 'node:assert/strict'
+import * as ts from 'typescript'
+import { extractDSLWorkflow } from './extract-dsl-workflow.js'
+import type { ApprovalStepMeta } from '@pikku/core/workflow'
+
+const checker = {
+  getSymbolAtLocation: () => undefined,
+  getAliasedSymbol: () => undefined,
+  getShorthandAssignmentValueSymbol: () => undefined,
+  getTypeAtLocation: () => undefined,
+} as unknown as ts.TypeChecker
+
+/** Extracts the single approval step from a workflow body. */
+const approvalStepFor = (options: string): ApprovalStepMeta => {
+  const file = ts.createSourceFile(
+    'wf.ts',
+    `const wf = pikkuWorkflowFunc({
+      func: async (services, data, { workflow }) => {
+        await workflow.approval('Release funds', ${options})
+      },
+    })`,
+    ts.ScriptTarget.Latest,
+    true
+  )
+
+  let node: ts.Node | undefined
+  const visit = (n: ts.Node) => {
+    if (ts.isCallExpression(n) && n.expression.getText() === 'pikkuWorkflowFunc') {
+      node = n
+    }
+    ts.forEachChild(n, visit)
+  }
+  visit(file)
+  assert.ok(node, 'failed to find the workflow definition')
+
+  const result = extractDSLWorkflow(node, checker)
+  assert.equal(result.status, 'ok', JSON.stringify(result))
+  const step = result.steps?.find(
+    (s): s is ApprovalStepMeta => s.type === 'approval'
+  )
+  assert.ok(step, 'no approval step was extracted')
+  return step
+}
+
+describe('an approval gate carries its policy into the graph', () => {
+  test('approvers and approverScope survive extraction', () => {
+    const step = approvalStepFor(
+      `{ schema: DecisionSchema, approvers: 'not-initiator', approverScope: 'payments:approve' }`
+    )
+    assert.equal(step.approvers, 'not-initiator')
+    assert.equal(step.approverScope, 'payments:approve')
+  })
+
+  test('expiry still survives alongside them', () => {
+    const step = approvalStepFor(
+      `{ schema: DecisionSchema, expiry: '3d', approvers: 'owner' }`
+    )
+    assert.equal(step.expiry, '3d')
+    assert.equal(step.approvers, 'owner')
+  })
+
+  test('a gate declaring no policy records none', () => {
+    const step = approvalStepFor(`{ schema: DecisionSchema }`)
+    assert.equal(step.approvers, undefined)
+    assert.equal(step.approverScope, undefined)
+  })
+})

package/src/utils/workflow/dsl/extract-dsl-workflow.ts

@@ -15,13 +15,13 @@ import type {
   SwitchCaseMeta,
   FilterStepMeta,
   ArrayPredicateStepMeta,
-  ScenarioStepMeta,
   InputSource,
   OutputBinding,
   Condition,
   WorkflowContext,
   ContextVariable,
 } from '@pikku/core/workflow'
+import type { ScenarioStepMeta } from '@pikku/core/scenario'
 import {
   isWorkflowDoCall,
   isWorkflowExpectEventuallyCall,
@@ -1051,14 +1051,15 @@ function extractApprovalStep(
       step.outputVar = outputVar
     }
     // The `schema` option is a runtime value validated inside the workflow body,
-    // so it is deliberately not serialized here — only `expiry`, which the graph
-    // and planned-step ladder need in order to describe the gate.
+    // so it is deliberately not serialized here — only the literal options the
+    // graph and planned-step ladder need in order to describe the gate.
     const options = args[1]
     if (options && ts.isObjectLiteralExpression(options)) {
       for (const prop of options.properties) {
+        if (!ts.isPropertyAssignment(prop)) continue
+        const name = prop.name.getText()
         if (
-          ts.isPropertyAssignment(prop) &&
-          prop.name.getText() === 'expiry' &&
+          name === 'expiry' &&
           (ts.isStringLiteral(prop.initializer) ||
             ts.isNumericLiteral(prop.initializer))
         ) {
@@ -1066,6 +1067,13 @@ function extractApprovalStep(
             ? Number(prop.initializer.text)
             : prop.initializer.text
         }
+        if (name === 'approvers' && ts.isStringLiteral(prop.initializer)) {
+          step.approvers = prop.initializer
+            .text as ApprovalStepMeta['approvers']
+        }
+        if (name === 'approverScope' && ts.isStringLiteral(prop.initializer)) {
+          step.approverScope = prop.initializer.text
+        }
       }
     }
     return step

package/src/utils/workflow/dsl/patterns.ts

@@ -77,20 +77,23 @@ export function getScenarioStepPhase(
 /**
  * The expectation helpers that assert without being a `then`.
  *
- * `expectService` and `expectError` are inline steps rather than scenario
- * steps, so they carry no phase and never reach the step meta — but each one is
- * a witness: a recorded service call, or a refusal. PKU680 has to see them, or
- * a scenario whose only assertion is one of these reads as asserting nothing.
+ * `expectService`, `expectError` and `expectScore` are inline steps rather than
+ * scenario steps, so they carry no phase and never reach the step meta — but
+ * each one is a witness: a recorded service call, a refusal, or a graded run.
+ * PKU680 has to see them, or a scenario whose only assertion is one of these
+ * reads as asserting nothing.
  */
 const SCENARIO_EXPECTATION_CALLS = [
   'expectService',
   'expectError',
   'expectEventually',
+  'expectScore',
 ] as const
 
 /**
  * Check if a call expression is one of the scenario expectation helpers —
- * `scenario.expectService()`, `.expectError()` or `.expectEventually()`.
+ * `scenario.expectService()`, `.expectError()`, `.expectEventually()` or
+ * `.expectScore()`.
  */
 export function isScenarioExpectationCall(node: ts.CallExpression): boolean {
   return (

package/src/utils/workflow/graph/workflow-graph.types.ts

@@ -113,10 +113,10 @@ export type FlowType =
 // Import and re-export context types from core
 import type {
   ContextVariable,
-  ScenarioStepPhase,
   WorkflowContext,
   WorkflowPlannedStep,
 } from '@pikku/core/workflow'
+import type { ScenarioStepPhase } from '@pikku/core/scenario'
 
 export type { ContextVariable, WorkflowContext }
 

package/src/visit.ts

@@ -34,6 +34,7 @@ import { addVariable } from './add/add-variable.js'
 import { addWorkflowGraph } from './add/add-workflow-graph.js'
 import { addFeature } from './add/add-feature.js'
 import { addAIAgent } from './add/add-ai-agent.js'
+import { addAIScorer } from './add/add-ai-scorer.js'
 import { addApprovalDescription } from './add/add-approval-description.js'
 
 export const visitSetup = (
@@ -172,6 +173,7 @@ export const visitRoutes = (
   addWorkflowGraph(logger, node, checker, state, nextOptions)
   addFeature(logger, node, checker, state, nextOptions)
   addAIAgent(logger, node, checker, state, nextOptions)
+  addAIScorer(logger, node, checker, state, nextOptions)
 
   ts.forEachChild(node, (child) =>
     visitRoutes(logger, checker, child, state, nextOptions)