@codeyam/codeyam-cli 0.1.0-staging.15d0f46 → 0.1.0-staging.1669d45

package/analyzer-template/packages/ai/src/lib/generateEntityScenarios.ts

@@ -5,11 +5,10 @@ import generateEntityScenariosGenerator from './promptGenerators/generateEntityS
 import {
   Analysis,
   Entity,
+  ExecutionFlow,
   PlaywrightInstruction,
-  ReadonlyAnalysisMap,
   Scenario,
 } from '~codeyam/types';
-// import findMatchingAttribute from './findMatchingAttribute';
 import { awsLog } from '~codeyam/utils';
 import { sanitizePlaywrightInstructions } from './validatePlaywrightInstructions';
 import { AI, DEFAULT_LARGER_MODEL, parseJsonSafe } from '~codeyam/ai';
@@ -18,31 +17,21 @@ export interface ScenarioResult {
   name: string;
   testName: string;
   description: string;
-  // New format: { dataStructurePath: { localVariable, instruction } }
-  // Old format (deprecated): { path: instruction_string }
-  keyAttributeInstructions: {
-    [key: string]:
-      | string
-      | {
-          localVariable: string;
-          instruction: string;
-        };
-  };
-  codeSnippet: string;
-  fix: string;
-  fixSnippet: string;
-  likelihood: number;
-  likelihoodDescription: string;
-  severity: number;
-  severityDescription: string;
-  dataMapping: { [key: string]: string };
+  /** IDs of execution flows this scenario covers */
+  coveredFlows: string[];
+  codeSnippet?: string;
+  fix?: string;
+  fixSnippet?: string;
+  likelihood?: number;
+  likelihoodDescription?: string;
+  severity?: number;
+  severityDescription?: string;
   playwrightInstructions?: PlaywrightInstruction[];
 }
 
 interface GenerateEntityScenariosArgs {
   entity: Pick<Entity, 'projectId' | 'filePath' | 'name' | 'code' | 'metadata'>;
-  keyAttributes: Analysis['metadata']['keyAttributes'];
-  dependentAnalyses?: ReadonlyAnalysisMap;
+  executionFlows?: ExecutionFlow[];
   analysis: Analysis;
   error?: boolean;
   model?: AI.Model;
@@ -52,7 +41,7 @@ const DEFAULT_SCENARIO_NAME = 'Default Scenario';
 
 export default async function generateEntityScenarios({
   entity,
-  keyAttributes,
+  executionFlows,
   analysis,
   error,
   model,
@@ -62,9 +51,33 @@ export default async function generateEntityScenarios({
     entityName: entity.name,
   });
 
+  // If no execution flows are available (and not generating error scenarios),
+  // return only the Default Scenario without calling LLM
+  if (!error && (!executionFlows || executionFlows.length === 0)) {
+    console.log(
+      `CodeYam: No execution flows available for ${entity.filePath} ${entity.name}, creating Default Scenario only`,
+    );
+    const defaultScenario: Scenario = {
+      projectId: entity.projectId,
+      analysisId: analysis.id,
+      name: DEFAULT_SCENARIO_NAME,
+      description: 'Default component rendering with standard data',
+      metadata: {
+        testName: 'it("renders the component with default data")',
+        error: false,
+        coveredFlows: [],
+        playwrightInstructions: [],
+      },
+    };
+    return {
+      scenarios: [defaultScenario],
+      llmCall: null,
+    };
+  }
+
   const prompt = generateEntityScenariosGenerator({
     entity,
-    keyAttributes,
+    executionFlows,
     error,
   });
 
@@ -93,14 +106,14 @@ export default async function generateEntityScenarios({
         filePath: entity.filePath,
         code: entity.code,
       },
-      keyAttributes,
+      executionFlows,
       analysis: {
         id: analysis.id,
         metadata: {
           isolatedDataStructure: {
             equivalentSignatureVariables:
               entity.metadata.isolatedDataStructure
-                .equivalentSignatureVariables,
+                ?.equivalentSignatureVariables,
           },
         },
       },
@@ -159,23 +172,7 @@ export default async function generateEntityScenarios({
           likelihoodDescription: scenarioInfo.likelihoodDescription,
           severity: scenarioInfo.severity,
           severityDescription: scenarioInfo.severityDescription,
-          dataMapping: scenarioInfo.dataMapping,
-          keyAttributeInstructions: scenarioInfo.keyAttributeInstructions,
-          // Object.keys(
-          //   scenarioInfo.keyAttributeInstructions,
-          // ).reduce((acc, key) => {
-          //   const attributesList = keyAttributes.map(
-          //     (attr) => attr.internalPath,
-          //   );
-          //   const matchingKey = findMatchingAttribute(
-          //     key,
-          //     attributesList,
-          //     entity.metadata.isolatedDataStructure
-          //       .equivalentSignatureVariables,
-          //   );
-          //   acc[matchingKey] = scenarioInfo.keyAttributeInstructions[key];
-          //   return acc;
-          // }, {}),
+          coveredFlows: scenarioInfo.coveredFlows || [],
           playwrightInstructions: sanitizePlaywrightInstructions(
             scenarioInfo.playwrightInstructions || [],
             entity.name,
@@ -197,7 +194,7 @@ function generateSystemMessage(
 ): string {
   const scenarioCountText = scenarioCount
     ? `Generate exactly ${scenarioCount} scenario${scenarioCount > 1 ? 's' : ''}.`
-    : 'Generate 1-4 scenarios.';
+    : 'Generate 3-6 scenarios MAXIMUM. Do NOT exceed 6 scenarios.';
 
   const contextSection = context
     ? `## Business Context
@@ -208,35 +205,136 @@ Focus scenarios on demonstrating this specific behavior change.
 `
     : '';
 
-  return `You are a test scenario designer. Generate data scenarios that demonstrate a function's behavior.
+  return `You are a test scenario designer. Generate data scenarios that demonstrate a function's behavior by covering its execution flows.
 
 ${contextSection}${scenarioCountText}
 
-## Default Scenario Rules
-The FIRST scenario MUST be named exactly "${DEFAULT_SCENARIO_NAME}" (case-sensitive).
-- Fill ALL key attributes using values from their \`validValueOptions\` list
-- If "children" is an argument, populate it (otherwise output may be blank)
-- Ignore error-related attributes (set to null)
-- NEVER include \`playwrightInstructions\` - we need a screenshot BEFORE any user interaction
-- Do NOT add playwrightInstructions even if the component has forms/buttons - default shows initial state only
-
-## Other Scenarios
-- Each produces DISTINCT output (visual: different screenshot; backend: different return/side-effect)
-- Only specify attributes that DIFFER from default
-- May include \`playwrightInstructions\` for user interactions (clicks, form fills)
-
-## keyAttributeInstructions Format
-Use \`dataStructurePath\` as key, include both variable name and instruction:
+## Your Primary Goal: Cover ALL Execution Flows EFFICIENTLY
+
+You are given \`executionFlows\` - all the distinct outcomes/behaviors this component can produce. Each flow has:
+- \`id\`: Unique identifier
+- \`name\`: Human-readable name (e.g., "Modal visible", "Loading state")
+- \`description\`: What the user sees or what behavior occurs
+- \`requiredValues\`: Attribute values needed to produce this outcome
+- \`impact\`: Visual/behavioral importance ("high", "medium", "low")
+- \`blocksOtherFlows\`: If true, this outcome hides other content (modals, overlays)
+- \`isError\`: If true, this represents an error/exception scenario
+- \`exclusiveGroup\`: If set, flows with the same group are MUTUALLY EXCLUSIVE (only one can be active)
+
+**Your job**: Create the MINIMUM number of scenarios that cover ALL execution flows.
+
+## CRITICAL: Understanding Exclusive Groups
+
+Flows with the same \`exclusiveGroup\` are MUTUALLY EXCLUSIVE - only ONE can be active at a time.
+
+**Example exclusive groups:**
+- \`"status-badge"\`: loading, success, error, pending - only ONE badge shows
+- \`"active-tab"\`: users, settings, profile - only ONE tab is visible
+- \`"modal"\`: settings-modal, confirm-modal - only ONE modal at a time
+
+5. **Maximize visual diversity**: For attributes that control what content is displayed (rather than just styling), vary values across scenarios so screenshots show meaningfully different views:
+   - Don't use the same display-controlling value in every scenario
+   - Ensure at least one scenario shows the primary content view
+   - Other scenarios can demonstrate alternative display states
+
+**Key insight**: You don't need a separate scenario for each flow in an exclusive group!
+- Pick the PRIMARY/DEFAULT option for the Default Scenario
+- Only create additional scenarios for IMPORTANT alternative states (e.g., error states, loading states)
+- Skip scenarios for minor variations within a group
+
+## Scenario Strategy
+
+### 1. Default Scenario (REQUIRED - must be first, named exactly "${DEFAULT_SCENARIO_NAME}")
+- For each exclusive group, pick the PRIMARY/HAPPY-PATH option:
+  - Status: "success" or "ready" (not loading, not error)
+  - Tabs: The main/first tab
+  - View modes: The default view
+- Combine as many NON-BLOCKING, NON-ERROR, NON-EXCLUSIVE-CONFLICT flows as possible
+- AVOID flows with \`blocksOtherFlows: true\`
+- NEVER include \`playwrightInstructions\`
+
+### 2. Blocking Flow Scenarios (ONE per blocking flow)
+Each flow with \`blocksOtherFlows: true\` gets its OWN scenario.
+- Modals, overlays, drawers hide other content
+- Don't combine blocking flows
+
+### 3. Important Alternative States (SELECTIVE)
+Only create scenarios for IMPORTANT alternatives within exclusive groups:
+- ✅ Loading state (if exists) - important UX state
+- ✅ Error state (if exists) - important UX state
+- ✅ Empty state (if exists) - important UX state
+- ❌ Each individual tab - NOT needed (tabs are just navigation)
+- ❌ Each status badge variant - just pick the important ones
+
+### 4. CRITICAL: Skip Low-Value Scenarios
+Do NOT create separate scenarios for:
+- **Different tabs** - Tabs are just navigation. The Default Scenario covers the main tab. SKIP others.
+- **Status badge variants** - Only need: Default (success/ready) + Loading + Error. SKIP queued, pending, etc.
+- **Banner variants** - Pick ONE important banner if any. SKIP creating a scenario for each banner type.
+- **Minor variations** - If two flows show essentially the same UI with small differences, combine them or skip one.
+
+**Remember**: Including a flow in the Default Scenario COUNTS as covering it. You don't need a dedicated scenario for each flow.
+
+## Combining Flows
+
+Flows can combine if:
+1. They have DIFFERENT \`exclusiveGroup\` values (or no exclusiveGroup)
+2. Their \`requiredValues\` don't conflict on the same attribute
+
+Flows CANNOT combine if:
+1. They have the SAME \`exclusiveGroup\` - they're mutually exclusive
+2. Their \`requiredValues\` conflict (same attribute, different required value)
+
+When combining flows, the scenario's mock data must satisfy ALL the requiredValues from ALL covered flows.
+
+## Output Format
+
 \`\`\`json
 {
-  "useDiffModal().diffView": {
-    "localVariable": "diffView",
-    "instruction": "Set to 'split' mode"
-  }
+  "dataScenarios": [
+    {
+      "name": "${DEFAULT_SCENARIO_NAME}",
+      "testName": "it(\\"displays primary content with all features visible\\")",
+      "description": "Main content view: success status, main tab selected, user logged in",
+      "coveredFlows": ["status-success", "tab-main", "user-authenticated", "content-loaded"]
+    },
+    {
+      "name": "Loading State",
+      "testName": "it(\\"shows loading spinner while fetching data\\")",
+      "description": "Data is being loaded, loading badge visible",
+      "coveredFlows": ["status-loading", "tab-main"]
+    },
+    {
+      "name": "Empty State",
+      "testName": "it(\\"shows empty message when no items\\")",
+      "description": "No items to display, empty state UI shown",
+      "coveredFlows": ["status-success", "tab-main", "empty-list"]
+    },
+    {
+      "name": "Settings Modal",
+      "testName": "it(\\"displays settings modal overlay\\")",
+      "description": "Settings modal is open and visible",
+      "coveredFlows": ["modal-settings"]
+    }
+  ]
 }
 \`\`\`
 
-## playwrightInstructions (optional, non-default only)
+**Note:** This example has ~20 flows but only 4 scenarios because:
+- Exclusive groups (status, tabs) only need ONE representative in Default Scenario
+- We don't create scenarios for every tab - they're just navigation
+- Only important states (loading, empty, modal) get dedicated scenarios
+
+## Field Descriptions
+
+- **name**: Human-readable scenario name (letters, numbers, spaces only - no special characters)
+- **testName**: Jest-style test description, e.g. \`it("displays error when email invalid")\`
+- **description**: What the user sees or what behavior occurs in this scenario
+- **coveredFlows**: Array of execution flow IDs this scenario covers (from the executionFlows list)
+- **playwrightInstructions**: (optional) User interactions needed to reach this state
+
+## playwrightInstructions Format (when needed)
+
 \`\`\`json
 {
   "playwrightInstructions": [
@@ -247,45 +345,27 @@ Use \`dataStructurePath\` as key, include both variable name and instruction:
 \`\`\`
 Note: selectorArgs values must be JSON strings, not JavaScript regex literals.
 
-Use when: data only appears after user action (button click, form submit), or key attribute isn't in data structure.
-
 ## Rules
-- Relative dates OK in instructions: "today", "tomorrow", "last month"
-- React elements: use simple elements (\`<div>\`, \`<span>\`) - no custom JSX
-- No external library references - plain JS/TS values only
-- Scenario names: letters, numbers, spaces only (no special characters)
-- testName: Jest style with specific expectations, e.g. \`it("displays error when email invalid")\`
-- All values must be valid JSON (strings, numbers, booleans, arrays, objects) - no JavaScript literals like regex
 
-## Response Format
-\`\`\`json
-{
-  "dataScenarios": [
-    {
-      "name": "${DEFAULT_SCENARIO_NAME}",
-      "testName": "it(\"displays notifications with unread indicator\")",
-      "description": "Default state with 3 unread and 2 read notifications",
-      "keyAttributeInstructions": {
-        "useNotifications().notifications[]": { "localVariable": "notifications[]", "instruction": "Create 5 notifications" },
-        "useNotifications().notifications[].read": { "localVariable": "notifications[].read", "instruction": "false for 3, true for 2" }
-      }
-    },
-    {
-      "name": "Empty state",
-      "testName": "it(\"shows placeholder when no notifications\")",
-      "description": "User has no notifications",
-      "keyAttributeInstructions": {
-        "useNotifications().notifications[]": { "localVariable": "notifications[]", "instruction": "Empty array" }
-      }
-    }
-  ]
-}
-\`\`\`
+1. **HARD LIMIT: 3-6 scenarios only** - If you generate more than 6 scenarios, you're doing it wrong. Aim for the minimum that covers important states.
+2. **${DEFAULT_SCENARIO_NAME}** must be first and named exactly that (case-sensitive)
+3. **Exclusive groups**: Pick ONE flow per group for Default Scenario. DON'T create scenarios for each option.
+4. **Blocking flows** (blocksOtherFlows: true) get dedicated scenarios
+5. **Only 2-3 additional scenarios**: Loading State, Empty State, maybe one Error or Modal
+6. **DO NOT cover every flow** - Many flows are fine being represented only in the Default Scenario
+7. Scenario names: letters, numbers, spaces only (no special characters)
+8. All values must be valid JSON
+
+**Example for a component with 27 flows:**
+- Default Scenario (covers 10+ flows including: success status, main tab, content loaded, etc.)
+- Loading State (covers loading flow)
+- Empty State (covers empty flow)
+- Modal Open (if there's an important modal)
+- Error State (if there's a critical error state)
+= 4-5 scenarios total, NOT 27
 `;
 }
 
-const SYSTEM_MESSAGE = generateSystemMessage();
-
 const ERROR_SYSTEM_MESSAGE = `You are a security/reliability analyst. Identify data inputs that will cause UNCAUGHT ERRORS in this function.
 
 ## What Qualifies as an Error Scenario
@@ -320,19 +400,17 @@ Note: In JS/TS, any non-zero value satisfies a boolean check—this won't error.
 {
   "errorDataScenarios": [
     {
-      "dataMapping": { "notifications array": "arguments - notifications" },
       "name": "Non-utf8 message encoding",
-      "codeSnippet": "const encoded = encodeURIComponent(message);",
+      "testName": "it(\\"throws on non-utf8 characters\\")",
       "description": "encodeURIComponent throws on non-utf8 characters",
+      "codeSnippet": "const encoded = encodeURIComponent(message);",
       "fix": "Wrap in try/catch",
       "fixSnippet": "try {\\n  encoded = encodeURIComponent(message);\\n} catch (e) {\\n  // handle\\n}",
       "likelihood": 7,
       "likelihoodDescription": "International users may input non-utf8 characters",
       "severity": 2,
       "severityDescription": "Function throws uncaught error",
-      "keyAttributeInstructions": {
-        "notifications[]": "Array with message containing non-utf8 characters"
-      }
+      "coveredFlows": []
     }
   ]
 }

package/analyzer-template/packages/ai/src/lib/generateExecutionFlows.ts

@@ -0,0 +1,201 @@
+/**
+ * Generates execution flows using pure static analysis.
+ *
+ * This module has been refactored to use deterministic flow generation
+ * instead of LLM calls. Flows are derived from:
+ * 1. conditionalUsages - variables used in if/ternary/&&/switch
+ * 2. conditionalEffects - setter calls inside conditionals
+ *
+ * Only paths that resolve to controllable data sources produce flows,
+ * eliminating the problem of invalid paths like useState variables.
+ */
+
+import {
+  DataStructure,
+  Entity,
+  ExecutionFlow,
+  ConditionalEffect,
+} from '~codeyam/types';
+import { awsLog } from '~codeyam/utils';
+import { gatherAttributesMap } from './promptGenerators/gatherAttributesMap';
+import { fillInDirectSchemaGapsAndUnknowns } from './dataStructure/helpers/fillInSchemaGapsAndUnknowns';
+import { clearAttributesFromMapping } from './dataStructure/helpers/cleanNonObjectFunctions';
+import type { CompoundConditional, ConditionalUsage } from '~codeyam/types';
+import { LlmCall } from '~codeyam/types';
+import generateExecutionFlowsFromConditionalEffects from './generateExecutionFlowsFromConditionalEffects';
+import generateExecutionFlowsFromConditionals, {
+  ChildComponentConditionalData,
+} from './generateExecutionFlowsFromConditionals';
+import { AI } from '~codeyam/ai';
+
+interface GenerateExecutionFlowsArgs {
+  entity: Pick<Entity, 'sha' | 'name' | 'filePath' | 'code' | 'metadata'>;
+  mergedDataStructure: Omit<DataStructure, 'equivalentSignatureVariables'>;
+  /** @deprecated Model is no longer used - execution flows are generated via static analysis */
+  model?: AI.Model;
+  /**
+   * Optional map of child entity names to their metadata.
+   * Used for merging child component execution flows into the parent.
+   * The caller should:
+   * 1. Look at childBoundaryGatingConditions to see which children need metadata
+   * 2. Find those entities (via importedExports or database lookup)
+   * 3. Pass their metadata here
+   */
+  childEntityMetadata?: Record<string, Entity['metadata']>;
+}
+
+export default function generateExecutionFlows({
+  entity,
+  mergedDataStructure,
+  childEntityMetadata,
+}: GenerateExecutionFlowsArgs) {
+  awsLog(`CodeYam: Generating execution flows (static analysis)`, {
+    filePath: entity.filePath,
+    entityName: entity.name,
+  });
+
+  const isolatedDataStructure = entity.metadata?.isolatedDataStructure;
+  const equivalentSignatureVariables =
+    isolatedDataStructure?.equivalentSignatureVariables ?? {};
+  const { attributesMap, associationMap } = gatherAttributesMap(
+    isolatedDataStructure ?? mergedDataStructure,
+    mergedDataStructure,
+    equivalentSignatureVariables,
+    true,
+  );
+
+  // Clean the attributes map to remove primitive-returning array method paths
+  clearAttributesFromMapping(attributesMap);
+
+  if (Object.keys(attributesMap).length === 0) {
+    console.log(
+      `CodeYam: No valid attributes found for ${entity.filePath} ${entity.name}`,
+    );
+    return {
+      executionFlows: [],
+      llmCall: null as LlmCall | null,
+    };
+  }
+
+  // Build merged schema for type inference
+  const mergedSchemaForTypeLookup = Object.fromEntries(
+    Object.entries(mergedDataStructure.signatureSchema ?? {})
+      .filter(([k]) => k.startsWith('signature['))
+      .map(([k, v]) => [k.replace(/^signature\[\d+\]\./, ''), v]),
+  );
+
+  // Resolve unknown types using heuristics
+  const resolvedAttributesMap = fillInDirectSchemaGapsAndUnknowns({
+    scopeName: entity.name,
+    schema: { ...attributesMap },
+    mergedSchema: mergedSchemaForTypeLookup,
+  });
+
+  // Build fullToShortPathMap from associationMap
+  // associationMap maps full paths → short paths (e.g., "useFetcher<...>().functionCallReturnValue.state" → "state")
+  // fullToShortPathMap is the same mapping (we just use associationMap directly)
+  const fullToShortPathMap: Record<string, string> = {};
+  for (const [fullPath, shortPath] of Object.entries(associationMap)) {
+    fullToShortPathMap[fullPath] = shortPath;
+  }
+
+  // Get pre-computed conditional data from metadata
+  const conditionalUsages: Record<string, ConditionalUsage[]> =
+    entity.metadata?.isolatedDataStructure?.conditionalUsages ?? {};
+  const compoundConditionals: CompoundConditional[] =
+    entity.metadata?.isolatedDataStructure?.compoundConditionals ?? [];
+  const conditionalEffects: ConditionalEffect[] =
+    entity.metadata?.isolatedDataStructure?.conditionalEffects ?? [];
+
+  // Build child component data for merging child flows into parent
+  // This requires:
+  // 1. childBoundaryGatingConditions - which parent conditions gate each child
+  // 2. childEntityMetadata - passed by caller after looking up child entities
+  const childBoundaryGatingConditions: Record<string, ConditionalUsage[]> =
+    entity.metadata?.isolatedDataStructure?.childBoundaryGatingConditions ?? {};
+
+  // Build childComponentData using the provided childEntityMetadata
+  // The caller is responsible for looking up child entities (via importedExports
+  // or database) and passing their metadata here
+  const childComponentData: Record<string, ChildComponentConditionalData> = {};
+  if (childEntityMetadata) {
+    for (const [childName, gatingConditions] of Object.entries(
+      childBoundaryGatingConditions,
+    )) {
+      const childMeta = childEntityMetadata[childName];
+      const childIsolated = childMeta?.isolatedDataStructure;
+
+      if (childIsolated) {
+        childComponentData[childName] = {
+          conditionalUsages: childIsolated.conditionalUsages ?? {},
+          equivalentSignatureVariables:
+            childIsolated.equivalentSignatureVariables ?? {},
+          compoundConditionals: childIsolated.compoundConditionals ?? [],
+          gatingConditions,
+        };
+      }
+    }
+  }
+
+  const conditionalsBasedFlows = generateExecutionFlowsFromConditionals({
+    conditionalUsages,
+    compoundConditionals,
+    attributesMap: resolvedAttributesMap,
+    equivalentSignatureVariables,
+    fullToShortPathMap,
+    childComponentData:
+      Object.keys(childComponentData).length > 0
+        ? childComponentData
+        : undefined,
+  });
+
+  console.log(
+    `CodeYam: Generated ${conditionalsBasedFlows.length} flows from conditional usages`,
+  );
+
+  // Generate flows from conditional effects (setter calls inside conditionals)
+  // Pass resolution context so paths can be resolved to controllable data sources
+  const effectsBasedFlows = generateExecutionFlowsFromConditionalEffects(
+    conditionalEffects,
+    {
+      attributesMap: resolvedAttributesMap,
+      equivalentSignatureVariables,
+      fullToShortPathMap,
+      conditionalUsages,
+    },
+  );
+
+  console.log(
+    `CodeYam: Generated ${effectsBasedFlows.length} flows from conditional effects`,
+  );
+
+  // Merge all flows, deduplicating by ID
+  // Effects-based flows take precedence as they have precise data source paths
+  const allFlows: ExecutionFlow[] = [];
+  const seenIds = new Set<string>();
+
+  // Add effects-based flows first (higher priority)
+  for (const flow of effectsBasedFlows) {
+    if (!seenIds.has(flow.id)) {
+      seenIds.add(flow.id);
+      allFlows.push(flow);
+    }
+  }
+
+  // Add conditionals-based flows
+  for (const flow of conditionalsBasedFlows) {
+    if (!seenIds.has(flow.id)) {
+      seenIds.add(flow.id);
+      allFlows.push(flow);
+    }
+  }
+
+  console.log(
+    `CodeYam: Total execution flows for ${entity.name}: ${allFlows.length}`,
+  );
+
+  return {
+    executionFlows: allFlows,
+    llmCall: null as LlmCall | null, // No LLM calls in static analysis mode
+  };
+}