@pikku/inspector 0.12.52 → 0.12.55

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

@@ -26,6 +26,7 @@ import {
   isWorkflowDoCall,
   isWorkflowExpectEventuallyCall,
   isScenarioStepCall,
+  isScenarioExpectationCall,
   getScenarioStepPhase,
   DYNAMIC_SCENARIO_STEP_TARGET,
   extractActorFromOptions,
@@ -82,9 +83,64 @@ export interface ExtractionResult {
   steps?: WorkflowStepMeta[]
   /** Workflow context (top-level variables) */
   context?: WorkflowContext
+  /**
+   * The flow asserts something through an expectation helper rather than a
+   * `then` step. Recorded separately because those helpers are inline steps and
+   * leave no phase behind, so PKU680 has no other way to see them.
+   */
+  asserts?: boolean
   reason?: string
 }
 
+/**
+ * A function the walk must not step into, because nothing here says it runs.
+ *
+ * A callback handed straight to a call — a fanout's `map`, an inline
+ * `workflow.do` step — executes as part of the body and counts. A function that
+ * is merely *declared* or assigned to a name does not: an assertion parked in an
+ * unused helper asserts nothing, and counting it would let a scenario silence
+ * PKU680 with dead code.
+ */
+function isUncalledFunction(node: ts.Node): boolean {
+  if (
+    !ts.isFunctionDeclaration(node) &&
+    !ts.isFunctionExpression(node) &&
+    !ts.isArrowFunction(node)
+  ) {
+    return false
+  }
+  if (ts.isFunctionDeclaration(node)) return true
+  const parent = node.parent
+  return !(
+    parent &&
+    ts.isCallExpression(parent) &&
+    parent.arguments.some((argument) => argument === node)
+  )
+}
+
+/**
+ * Whether the body calls one of the expectation helpers anywhere it runs.
+ *
+ * A whole-body walk rather than a check inside step extraction: the helpers
+ * produce no step of their own, so there is no extraction result to hang the
+ * answer off, and one nested inside a branch asserts just as much as one at the
+ * top level.
+ */
+function hasScenarioExpectation(body: ts.Node): boolean {
+  let found = false
+  const visit = (node: ts.Node): void => {
+    if (found) return
+    if (ts.isCallExpression(node) && isScenarioExpectationCall(node)) {
+      found = true
+      return
+    }
+    if (node !== body && isUncalledFunction(node)) return
+    ts.forEachChild(node, visit)
+  }
+  visit(body)
+  return found
+}
+
 /**
  * Extract DSL workflow metadata from a function declaration
  */
@@ -170,6 +226,7 @@ export function extractDSLWorkflow(
       steps,
       context:
         Object.keys(workflowContext).length > 0 ? workflowContext : undefined,
+      asserts: hasScenarioExpectation(arrowFunc.body) || undefined,
     }
   } catch (error) {
     return {

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

@@ -44,14 +44,14 @@ export function isWorkflowDoCall(
  */
 export const DYNAMIC_SCENARIO_STEP_TARGET = '<dynamic>'
 
-const SCENARIO_STEP_PHASES = ['step', 'given', 'when', 'then'] as const
+const SCENARIO_STEP_PHASES = ['given', 'when', 'then'] as const
 
 export type ScenarioStepPhaseName = (typeof SCENARIO_STEP_PHASES)[number]
 
 /**
- * Check if a call expression is scenario.step()/given()/when()/then() — a
- * declared `pikkuScenarioStep` invoked by name. `given`/`when`/`then` are pure
- * sugar over `step`: the phase only changes the prose a reporter renders.
+ * Check if a call expression is scenario.given()/when()/then() — a declared
+ * `pikkuScenarioStep` invoked by name. `given`/`when` are pure sugar for each
+ * other; `then` additionally makes the step's bindings witnesses.
  */
 export function isScenarioStepCall(node: ts.CallExpression): boolean {
   return getScenarioStepPhase(node) !== undefined
@@ -74,6 +74,35 @@ export function getScenarioStepPhase(
   return SCENARIO_STEP_PHASES.find((phase) => phase === propAccess.name.text)
 }
 
+/**
+ * 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.
+ */
+const SCENARIO_EXPECTATION_CALLS = [
+  'expectService',
+  'expectError',
+  'expectEventually',
+] as const
+
+/**
+ * Check if a call expression is one of the scenario expectation helpers —
+ * `scenario.expectService()`, `.expectError()` or `.expectEventually()`.
+ */
+export function isScenarioExpectationCall(node: ts.CallExpression): boolean {
+  return (
+    ts.isPropertyAccessExpression(node.expression) &&
+    SCENARIO_EXPECTATION_CALLS.some(
+      (name) =>
+        name === (node.expression as ts.PropertyAccessExpression).name.text
+    ) &&
+    isWorkflowWireIdentifier(node.expression.expression)
+  )
+}
+
 /**
  * Check if a call expression is workflow.expectEventually()
  */