@codeyam/codeyam-cli 0.1.0-staging.1 → 0.1.0-staging.1669d45

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

@@ -4,7 +4,7 @@ import { saveLlmCall } from '~codeyam/aws/dynamodb';
 import generateEntityPropsStructureGenerator from './promptGenerators/generateEntityPropsStructureGenerator';
 import identifyReserved, { ReservedFeature } from './identifyReserved';
 import splitOutsideParentheses from './splitOutsideParentheses';
-import { generateSha, loadStatement, saveStatement } from '~codeyam/supabase';
+import { generateSha, loadStatement, saveStatement } from '~codeyam/database';
 import { ScopeInfo } from './dataStructure/ScopeDataStructure';
 import { AI, parseJsonSafe } from '~codeyam/ai';
 
@@ -152,85 +152,52 @@ export default async function generateStatementAnalysis({
   return { sha, structure, equivalentVariables, llmCall };
 }
 
-const SYSTEM_MESSAGE = (reservedStrategies: string[]) => `**Task:**  
+const SYSTEM_MESSAGE = (
+  reservedStrategies: string[],
+) => `Analyze a code snippet to extract:
 
-We have a code snippet we need to analyze.
+1. **structure**: The data type of each variable and property path (string, number, boolean, array, object, function, or unknown)
+2. **equivalentVariables**: Assignments between variables, where the key is the target (left side) and value is the source (right side)
 
-We want to determine:
+## Type Rules
 
-1) What is the data structure of the variables in the code snippet?
-3) What variables or aspects of variables are equivalent in the code snippet?
+- Use type annotations when available; otherwise infer from context or use "unknown"
+- Non-primitive types are "object"
+- Function calls are "function"
 
-If there is any type information in the code snippet leverage it to inform the data structure of the variables but do not otherwise worry about it or include it. If a type is not a primitive simply label it as "object".
+## Equivalency Rules
 
-**Definitions:**
+For assignments like \`const a = b\`, record \`"a": "b"\`.
 
-Data Structure: 
-- Every variable in the code snippet has a data structure.
-- The data structure of a variable is the type of data it holds. For example, a variable could hold a string, a number, an array, an object, a function, etc.
-- We want to identify every aspect of every variable in the code snippet.
+For destructuring like \`const { x } = obj\`, record \`"x": "obj.x"\`.
 
-Example:
-\`\`\`typescript
-const { name, age } = person;
-\`\`\`
+For function calls like \`const result = foo(arg)\`:
+- Record \`"result": "foo(arg).functionCallReturnValue"\`
+- Record \`"foo(arg).signature[0]": "arg"\`
 
-In this case three variables are declared: \`name\`, \`age\`, and \`person\` so the overall structure would be:
+For destructured function returns like \`const { data } = foo()\`:
+- Record \`"data": "foo().functionCallReturnValue.data"\`
 
-\`\`\`json
-{
-  "structure": {
-    "person": "object",
-    "person.name": "string",
-    "person.age": "number"
-    "name": "string",
-    "age": "number"
-  }
-}
-\`\`\`
-
-Equivalent Variables:
-- In the code variables or aspects of a variable may be assigned to one another, passed in as arguments to a function call, or assigned to the return value of a function call.
-- We want to track all of these equivalent variables so that we can merge the data structure of all equivalencies together.
-- The key should be the variable or aspect of a variable that is recieving existing data from the other variable, which is the path.
+## Example
 
-Example:
 \`\`\`typescript
-const { name, hobbies } = person;
-hobbies[0].started = selectedHobby.alreadyStarted;
+const { name } = person;
+const result = process(name);
 \`\`\`
 
-Here we have a number of equivalencies:
-
-\`\`\`
-{
-  "equivalentVariables": {
-    "name": "person.name",
-    "hobbies": "person.hobbies",
-    "hobbies[0].started": "selectedHobby.alreadyStarted"    
-  }
-}
-\`\`\`
-
-**Response:**
-
-Combine these together to form the response:
-
 \`\`\`json
 {
   "structure": {
     "person": "object",
     "person.name": "string",
-    "person.hobbies": "array",
-    "person.hobbies[0]": "object",
-    "person.hobbies[0].started": "boolean",
-    "selectedHobby": "object",
-    "selectedHobby.alreadyStarted": "boolean"
+    "name": "string",
+    "process(name)": "function",
+    "result": "unknown"
   },
   "equivalentVariables": {
     "name": "person.name",
-    "hobbies": "person.hobbies",
-    "hobbies[0].started": "selectedHobby.alreadyStarted"    
+    "process(name).signature[0]": "name",
+    "result": "process(name).functionCallReturnValue"
   }
 }
 \`\`\`
@@ -239,10 +206,7 @@ ${relevantExamples(reservedStrategies)}
 
 ---
 
-**Important:**
-
-- Take your time and analyze the code snippet carefully. Capture all the data structures, function calls, and equivalencies you can find. If you miss any the simulation will fail.
-- Double check your work to ensure nothing was missed and all rules are followed.
+Analyze carefully. Missing equivalencies will cause simulation failures.
 `;
 
 function keywords(reservedStrategies: string[]) {
@@ -348,7 +312,20 @@ const STRATEGIES = {
     name: 'Basic Variable Assignment',
     examples: [
       {
-        name: 'Simple',
+        name: 'Simple Assignment',
+        code: `const selectedPerson = person;`,
+        response: `{
+    "structure": {
+      "selectedPerson": "unknown",
+      "person": "unknown"
+    },
+    "equivalentVariables": {
+      "selectedPerson": "person"
+    }
+  }`,
+      },
+      {
+        name: 'Property Assignment',
         code: `selectedPerson.position = position.name;`,
         response: `{
     "structure": {
@@ -363,7 +340,7 @@ const STRATEGIES = {
   }`,
       },
       {
-        name: 'Basic Deconstruction',
+        name: 'Destructuring',
         code: `const { name, age } = getPerson(personId);`,
         response: `{
     "structure": {
@@ -404,10 +381,10 @@ const STRATEGIES = {
         response: `{
     "structure": {
       "person": "object",
-      "options: "object"
+      "options": "object"
     },
     "equivalentVariables": {
-      "person": "signature[0]": 
+      "person": "signature[0]",
       "options": "signature[1]"
     }
   }`,
@@ -477,7 +454,7 @@ const STRATEGIES = {
       "name": "string",
       "title": "string",
       "category": "string",
-      "age": "number",
+      "age": "number"
     },
     "equivalentVariables": {
       "name": "signature[0].name",
@@ -932,10 +909,10 @@ const STRATEGIES = {
         response: `{
     "structure": {
       "age": "number",
-      "returnValue": "number",
+      "returnValue": "number"
     },
     "equivalentVariables": {
-      "returnValue: "age"
+      "returnValue": "age"
     }
   }`,
       },
@@ -988,7 +965,7 @@ const STRATEGIES = {
     "structure": {
       "items": "array",
       "items.filter(cyScope1())": "function",
-      "cyScope1()" : "function",
+      "cyScope1()": "function",
       "List()": "function",
       "div()": "function"
     },
@@ -1684,7 +1661,7 @@ const STRATEGIES = {
     "foo(arg1).bar({ arg2, arg3 }).bar().baz(arg4, arg5).boo()": "function"
   },
   "equivalentVariables": {
-   "data": "foo(arg1).bar({ arg2, arg3 }).bar().baz(arg4, arg5).boo().functionCallReturnValue.data"
+   "data": "foo(arg1).bar({ arg2, arg3 }).bar().baz(arg4, arg5).boo().functionCallReturnValue.data",
    "error": "foo(arg1).bar({ arg2, arg3 }).bar().baz(arg4, arg5).boo().functionCallReturnValue.error"
   }
 }`,

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

@@ -1,5 +1,5 @@
 import ts from 'typescript';
-import { ConditionalUsage } from './astScopes/types';
+import { CompoundConditional, ConditionalUsage } from './astScopes/types';
 import { StructuredPath } from './astScopes/paths';
 import {
   isComparisonOperator,
@@ -28,20 +28,50 @@ export default function getConditionalUsagesFromCode(
     ts.ScriptKind.TSX,
   );
 
-  function addUsage(usage: ConditionalUsage) {
+  /**
+   * Helper to get source location from an AST node
+   */
+  function getSourceLocation(
+    node: ts.Node,
+  ): ConditionalUsage['sourceLocation'] {
+    const start = node.getStart(sourceFile);
+    const { line, character } = sourceFile.getLineAndCharacterOfPosition(start);
+    const codeSnippet = node.getText(sourceFile);
+
+    return {
+      lineNumber: line + 1, // Convert to 1-based
+      column: character,
+      codeSnippet:
+        codeSnippet.length > 100
+          ? codeSnippet.slice(0, 100) + '...'
+          : codeSnippet,
+    };
+  }
+
+  function addUsage(
+    usage: Omit<ConditionalUsage, 'sourceLocation'>,
+    node: ts.Node,
+  ) {
+    const fullUsage: ConditionalUsage = {
+      ...usage,
+      sourceLocation: getSourceLocation(node),
+    };
+
     if (!conditionalUsages[usage.path]) {
       conditionalUsages[usage.path] = [];
     }
-    // Avoid duplicates
+    // Avoid duplicates (but allow different source locations)
     const exists = conditionalUsages[usage.path].some(
       (existing) =>
-        existing.location === usage.location &&
-        existing.conditionType === usage.conditionType &&
+        existing.location === fullUsage.location &&
+        existing.conditionType === fullUsage.conditionType &&
+        existing.sourceLocation?.lineNumber ===
+          fullUsage.sourceLocation?.lineNumber &&
         JSON.stringify(existing.comparedValues) ===
-          JSON.stringify(usage.comparedValues),
+          JSON.stringify(fullUsage.comparedValues),
     );
     if (!exists) {
-      conditionalUsages[usage.path].push(usage);
+      conditionalUsages[usage.path].push(fullUsage);
     }
   }
 
@@ -91,33 +121,45 @@ export default function getConditionalUsagesFromCode(
 
       if (leftPath && isLiteralExpression(unwrapped.right)) {
         const literalValue = getLiteralValue(unwrapped.right);
-        addUsage({
-          path: leftPath,
-          conditionType: 'comparison',
-          comparedValues:
-            literalValue !== undefined ? [literalValue] : undefined,
-          location,
-        });
+        addUsage(
+          {
+            path: leftPath,
+            conditionType: 'comparison',
+            comparedValues:
+              literalValue !== undefined ? [literalValue] : undefined,
+            location,
+          },
+          unwrapped,
+        );
         return;
       }
 
       if (rightPath && isLiteralExpression(unwrapped.left)) {
         const literalValue = getLiteralValue(unwrapped.left);
-        addUsage({
-          path: rightPath,
-          conditionType: 'comparison',
-          comparedValues:
-            literalValue !== undefined ? [literalValue] : undefined,
-          location,
-        });
+        addUsage(
+          {
+            path: rightPath,
+            conditionType: 'comparison',
+            comparedValues:
+              literalValue !== undefined ? [literalValue] : undefined,
+            location,
+          },
+          unwrapped,
+        );
         return;
       }
 
       if (leftPath) {
-        addUsage({ path: leftPath, conditionType: 'comparison', location });
+        addUsage(
+          { path: leftPath, conditionType: 'comparison', location },
+          unwrapped,
+        );
       }
       if (rightPath) {
-        addUsage({ path: rightPath, conditionType: 'comparison', location });
+        addUsage(
+          { path: rightPath, conditionType: 'comparison', location },
+          unwrapped,
+        );
       }
       return;
     }
@@ -134,7 +176,7 @@ export default function getConditionalUsagesFromCode(
     // Handle simple identifiers or property accesses (truthiness checks)
     const path = getPathFromNode(unwrapped, sourceFile);
     if (path) {
-      addUsage({ path, conditionType: 'truthiness', location });
+      addUsage({ path, conditionType: 'truthiness', location }, unwrapped);
     }
   }
 
@@ -170,12 +212,15 @@ export default function getConditionalUsagesFromCode(
             }
           }
         }
-        addUsage({
-          path: discriminantPath,
-          conditionType: 'switch',
-          comparedValues: caseValues.length > 0 ? caseValues : undefined,
-          location: 'switch',
-        });
+        addUsage(
+          {
+            path: discriminantPath,
+            conditionType: 'switch',
+            comparedValues: caseValues.length > 0 ? caseValues : undefined,
+            location: 'switch',
+          },
+          node,
+        );
       }
     }
 
@@ -259,18 +304,30 @@ function getLiteralValue(expr: ts.Expression): string | undefined {
 /**
  * Format conditional usages into a string for the LLM prompt
  */
+/**
+ * Interface for conditional usages that may have source tracing information.
+ * This is a superset of ConditionalUsage that includes optional sourceDataPath.
+ */
+interface EnrichedConditionalUsageInput extends ConditionalUsage {
+  sourceDataPath?: string;
+}
+
 export function formatConditionalUsagesForPrompt(
-  conditionalUsages: Record<string, ConditionalUsage[]>,
+  conditionalUsages: Record<string, EnrichedConditionalUsageInput[]>,
+  compoundConditionals?: CompoundConditional[],
 ): string {
   const entries = Object.entries(conditionalUsages);
-  if (entries.length === 0) {
+  if (
+    entries.length === 0 &&
+    (!compoundConditionals || compoundConditionals.length === 0)
+  ) {
     return '';
   }
 
   const lines: string[] = [
     '\n## Static Analysis: Attributes Used in Conditionals',
     '',
-    'The following attributes were found to be used in conditional statements, making them potential key attributes:',
+    'The following attributes were found to be used in conditional statements, making them very likely key attributes:',
     '',
   ];
 
@@ -281,29 +338,105 @@ export function formatConditionalUsagesForPrompt(
       .flatMap((u) => u.comparedValues || []);
     const uniqueValues = [...new Set(allComparedValues)];
 
-    let description = `- "${path}": `;
+    // Get the source data path if available (traced back to data source)
+    const sourceDataPath = usages.find((u) => u.sourceDataPath)?.sourceDataPath;
+
+    let description = `- "${path}"`;
+
+    // If we have a source data path, show that the local variable derives from a data source
+    if (sourceDataPath) {
+      description += `\n    - Source: "${sourceDataPath}"`;
+    }
+
+    description += '\n    - ';
 
     if (uniqueTypes.includes('switch')) {
-      description += 'used as switch discriminant';
+      description += 'Used as switch discriminant';
       if (uniqueValues.length > 0) {
         description += ` with cases: ${uniqueValues.map((v) => `"${v}"`).join(', ')}`;
       }
     } else if (uniqueTypes.includes('comparison')) {
-      description += 'used in comparison';
+      description += 'Used in comparison';
       if (uniqueValues.length > 0) {
         description += ` against values: ${uniqueValues.map((v) => `"${v}"`).join(', ')}`;
       }
     } else {
-      description += 'used in truthiness check (presence/absence matters)';
+      description += 'Used in truthiness check (presence/absence matters)';
+    }
+
+    // Include source locations if available (show up to 3 examples)
+    const usagesWithLocation = usages.filter((u) => u.sourceLocation);
+    if (usagesWithLocation.length > 0) {
+      description += '\n    - Locations:';
+      for (const usage of usagesWithLocation.slice(0, 3)) {
+        const loc = usage.sourceLocation!;
+        const snippet =
+          loc.codeSnippet.length > 60
+            ? loc.codeSnippet.slice(0, 60) + '...'
+            : loc.codeSnippet;
+        description += `\n      - Line ${loc.lineNumber}: \`${snippet}\``;
+      }
+      if (usagesWithLocation.length > 3) {
+        description += `\n      - ... and ${usagesWithLocation.length - 3} more`;
+      }
     }
 
     lines.push(description);
   }
 
+  // Add compound conditionals section if present
+  if (compoundConditionals && compoundConditionals.length > 0) {
+    lines.push('');
+    lines.push(
+      '### Compound Conditionals (ALL conditions must be true together)',
+    );
+    lines.push('');
+    lines.push(
+      'These conditions are combined with && and must ALL be satisfied together for a code path to execute.',
+    );
+    lines.push(
+      'IMPORTANT: Ensure at least one scenario satisfies ALL conditions in each compound conditional simultaneously.',
+    );
+    lines.push('');
+
+    for (const compound of compoundConditionals) {
+      lines.push(`- Chain at line ${compound.sourceLocation.lineNumber}:`);
+      lines.push(`    - Expression: \`${compound.expression}\``);
+      lines.push(`    - All these conditions must be TRUE together:`);
+
+      for (const condition of compound.conditions) {
+        let conditionDesc = `      - \`${condition.path}\``;
+        if (
+          condition.conditionType === 'comparison' &&
+          condition.comparedValues?.length
+        ) {
+          const op = condition.isNegated ? '!== ' : '=== ';
+          conditionDesc += ` ${op}${condition.comparedValues.map((v) => `"${v}"`).join(' or ')}`;
+        } else if (condition.conditionType === 'truthiness') {
+          conditionDesc += condition.isNegated
+            ? ' must be falsy (false, null, undefined, 0, "")'
+            : ' must be truthy';
+        }
+        if (condition.requiredValue !== undefined) {
+          conditionDesc += ` (required: ${JSON.stringify(condition.requiredValue)})`;
+        }
+        lines.push(conditionDesc);
+      }
+    }
+
+    lines.push('');
+    lines.push(
+      'When key attributes are part of compound conditionals, list the other conditions as dependencies.',
+    );
+  }
+
   lines.push('');
   lines.push(
     'Consider these attributes as candidates for key attributes, especially those with specific comparison values.',
   );
+  lines.push(
+    'When a local variable derives from a data source, the data source is the key attribute.',
+  );
 
   return lines.join('\n');
 }

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

@@ -2,13 +2,6 @@ import OpenAI from 'openai';
 import { getLLMCallCost } from './getLLMCallCost';
 import { AI, LlmCallStats } from './types';
 
-/**
- * It looks like this function can be massively simplified, and I (AG) think
- * that we aren't using openrouter anymore. But, until this is figured out, it
- * might not be worth refactoring and messing something subtle up. Ideally
- * whatever implicit functionality is in here can be represented in the new
- * `getLLMCallStats` such that this get replaced by it.
- */
 export function getLLMCallStats({
   chatRequest,
   chatCompletion,
@@ -28,13 +21,6 @@ export function getLLMCallStats({
       error: JSON.stringify(chatCompletion.error),
     };
   }
-  if (!chatRequest.model) {
-    // this was previously used to indicate openrouter calls, but we aren't
-    // doing that anymore and anyway it was a pretty obscure way to indicate
-    // that state of affairs. if we bring multi-provider back, we will want
-    // to rewrite a fair bit of this.
-    return null;
-  }
 
   const usage = chatCompletion.usage || {
     prompt_tokens: 0,

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

@@ -1,18 +1,22 @@
 import { saveLlmCall } from '~codeyam/aws/dynamodb';
 import { ScenariosDataStructure, Scenario } from '~codeyam/types';
-import * as lib from '.';
 import completionCall from './completionCall';
-import guessNewScenarioDataFromDescriptionGenerator from './promptGenerators/guessNewScenarioDataFromDescriptionGenerator';
+import guessNewScenarioDataFromDescriptionGenerator, {
+  ExecutionFlowSelection,
+} from './promptGenerators/guessNewScenarioDataFromDescriptionGenerator';
 import guessEditScenarioDataFromDescriptionGenerator from './promptGenerators/guessEditScenarioDataFromDescriptionGenerator';
 import { AI, DEFAULT_LARGER_MODEL } from '~codeyam/ai';
 import { parseJsonSafe } from './parsers/parseJsonSafe';
 
+export type { ExecutionFlowSelection };
+
 export interface GuessScenarioDataFromDescriptionArgs {
   description: string;
   editingMockName?: string;
   editingMockData?: { [key: string]: unknown };
   existingScenarios: Scenario[];
   scenariosDataStructure: ScenariosDataStructure;
+  flowSelections?: ExecutionFlowSelection[];
   model?: AI.Model;
 }
 
@@ -22,6 +26,7 @@ export default async function generateEntityScenarios({
   editingMockData,
   existingScenarios,
   scenariosDataStructure,
+  flowSelections,
   model,
 }: GuessScenarioDataFromDescriptionArgs): Promise<
   Scenario['metadata']['data'] | null
@@ -38,6 +43,7 @@ export default async function generateEntityScenarios({
         description,
         existingScenarios,
         scenariosDataStructure,
+        flowSelections,
       });
 
   const response = await completionCall({