@codeyam/codeyam-cli 0.1.0-staging.bbe4da9 → 0.1.0-staging.d0ad4ae

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';
 

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,
+        );
       }
     }
 
@@ -269,9 +314,13 @@ interface EnrichedConditionalUsageInput extends ConditionalUsage {
 
 export function formatConditionalUsagesForPrompt(
   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 '';
   }
 
@@ -315,9 +364,72 @@ export function formatConditionalUsagesForPrompt(
       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.',

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, {
+  KeyAttributeSelection,
+} from './promptGenerators/guessNewScenarioDataFromDescriptionGenerator';
 import guessEditScenarioDataFromDescriptionGenerator from './promptGenerators/guessEditScenarioDataFromDescriptionGenerator';
 import { AI, DEFAULT_LARGER_MODEL } from '~codeyam/ai';
 import { parseJsonSafe } from './parsers/parseJsonSafe';
 
+export type { KeyAttributeSelection };
+
 export interface GuessScenarioDataFromDescriptionArgs {
   description: string;
   editingMockName?: string;
   editingMockData?: { [key: string]: unknown };
   existingScenarios: Scenario[];
   scenariosDataStructure: ScenariosDataStructure;
+  keyAttributeSelections?: KeyAttributeSelection[];
   model?: AI.Model;
 }
 
@@ -22,6 +26,7 @@ export default async function generateEntityScenarios({
   editingMockData,
   existingScenarios,
   scenariosDataStructure,
+  keyAttributeSelections,
   model,
 }: GuessScenarioDataFromDescriptionArgs): Promise<
   Scenario['metadata']['data'] | null
@@ -38,6 +43,7 @@ export default async function generateEntityScenarios({
         description,
         existingScenarios,
         scenariosDataStructure,
+        keyAttributeSelections,
       });
 
   const response = await completionCall({

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

@@ -12,6 +12,53 @@ export interface Statement {
 }
 
 export default function mergeStatements(statements: Statement[]) {
+  // Debug: Log input statements to understand what we're merging
+  const hasStateStructure = statements.some((s) =>
+    Object.keys(s.structure || {}).some(
+      (k) => k === 'state' || k.includes('state'),
+    ),
+  );
+  const hasStateEquiv = statements.some((s) =>
+    Object.keys(s.equivalentVariables || {}).some(
+      (k) => k === 'state' || k.includes('state'),
+    ),
+  );
+  if (hasStateStructure || hasStateEquiv) {
+    console.log(
+      `[UNION-TYPE] mergeStatements INPUT: ${statements.length} statements`,
+    );
+    statements.forEach((s, i) => {
+      const stateInStructure = Object.entries(s.structure || {}).filter(
+        ([k]) => k === 'state' || k.includes('state'),
+      );
+      const stateInEquiv = Object.entries(s.equivalentVariables || {}).filter(
+        ([k]) => k === 'state' || k.includes('state'),
+      );
+      const sigInEquiv = Object.entries(s.equivalentVariables || {}).filter(
+        ([k, v]) => k === 'state' || v === 'signature[0]',
+      );
+      if (
+        stateInStructure.length > 0 ||
+        stateInEquiv.length > 0 ||
+        sigInEquiv.length > 0
+      ) {
+        console.log(`[UNION-TYPE]   Statement ${i}:`);
+        if (stateInStructure.length > 0)
+          console.log(
+            `[UNION-TYPE]     structure: ${JSON.stringify(Object.fromEntries(stateInStructure))}`,
+          );
+        if (stateInEquiv.length > 0)
+          console.log(
+            `[UNION-TYPE]     equivalentVariables (state): ${JSON.stringify(Object.fromEntries(stateInEquiv))}`,
+          );
+        if (sigInEquiv.length > 0)
+          console.log(
+            `[UNION-TYPE]     equivalentVariables (sig): ${JSON.stringify(Object.fromEntries(sigInEquiv))}`,
+          );
+      }
+    });
+  }
+
   // This should be handled by the AST Analyzer but it currently has a bug
   const ensureFunctionCallReturnValue = (path: string, value: string) => {
     if (path.endsWith(')') && value !== 'function') {
@@ -77,6 +124,15 @@ export default function mergeStatements(statements: Statement[]) {
   ) => {
     if (!mapping[key] || mapping[key] === 'unknown') {
       mapping[key] = value;
+      return;
+    }
+
+    // Prefer union types (containing ' | ') over generic types like "string"
+    const existingIsGeneric =
+      mapping[key] === 'string' || mapping[key] === 'unknown';
+    const newIsUnion = value.includes("'") && value.includes(' | ');
+    if (existingIsGeneric && newIsUnion) {
+      mapping[key] = value;
     }
   };
 
@@ -157,5 +213,53 @@ export default function mergeStatements(statements: Statement[]) {
 
   const llmCalls = statements.map((result) => result.llmCall).filter(Boolean);
 
+  // Propagate more specific types through equivalentVariables
+  // If we have equivalentVariables[A] = B, and structure[A] is more specific than structure[B],
+  // then update structure[B] to match structure[A]
+  // This handles cases like: "state" -> "signature[0]" where "state" has a union type
+
+  // Debug: Log union types in merged structure
+  const unionTypesInStructure = Object.entries(structure).filter(
+    ([_, v]) => typeof v === 'string' && v.includes("'") && v.includes(' | '),
+  );
+  if (unionTypesInStructure.length > 0) {
+    console.log(
+      `[UNION-TYPE] mergeStatements: Found ${unionTypesInStructure.length} union types in merged structure`,
+    );
+    unionTypesInStructure.forEach(([k, v]) =>
+      console.log(`[UNION-TYPE]   structure["${k}"] = ${v}`),
+    );
+    console.log(
+      `[UNION-TYPE] mergeStatements: equivalentVariables = ${JSON.stringify(equivalentVariables)}`,
+    );
+  }
+
+  for (const [source, target] of Object.entries(equivalentVariables) as [
+    string,
+    string,
+  ][]) {
+    const sourceType = structure[source];
+    const targetType = structure[target];
+
+    // Check if source has a more specific type (union type vs generic type)
+    if (sourceType) {
+      const sourceIsUnion =
+        sourceType.includes("'") && sourceType.includes(' | ');
+
+      if (sourceIsUnion) {
+        // Target doesn't exist or is generic - propagate the union type
+        const targetIsGeneric =
+          !targetType || targetType === 'string' || targetType === 'unknown';
+
+        if (targetIsGeneric) {
+          console.log(
+            `[UNION-TYPE] mergeStatements: Propagating "${source}" (${sourceType}) -> "${target}"`,
+          );
+          structure[target] = sourceType;
+        }
+      }
+    }
+  }
+
   return { structure, equivalentVariables, llmCalls };
 }

package/analyzer-template/packages/ai/src/lib/promptGenerators/gatherAttributesMap.ts

@@ -1,4 +1,4 @@
-import { Entity } from '~codeyam/types';
+import { DataStructure } from '~codeyam/types';
 import cleanOutBoundary from '../cleanOutBoundary';
 import {
   joinParenthesesAndArrays,
@@ -65,19 +65,80 @@ function validAttribute(attribute: string) {
   return true;
 }
 
+/**
+ * Gathers attributes from data structures for use in prompts.
+ *
+ * @param isolatedDataStructure - The entity's own data structure (determines which paths to include)
+ * @param mergedDataStructureOrEquivalentVars - Either the merged data structure (with richer types from
+ *   dependent analyses) OR equivalentSignatureVariables for backwards compatibility
+ * @param equivalentSignatureVariablesOrReverse - Either equivalentSignatureVariables OR reverse flag
+ * @param reverseArg - The reverse flag (only used when all 4 args provided)
+ */
 export function gatherAttributesMap(
-  entity: Pick<Entity, 'metadata'>,
-  reverse = false,
+  isolatedDataStructure: Omit<DataStructure, 'equivalentSignatureVariables'>,
+  mergedDataStructureOrEquivalentVars?:
+    | Omit<DataStructure, 'equivalentSignatureVariables'>
+    | DataStructure['equivalentSignatureVariables'],
+  equivalentSignatureVariablesOrReverse?:
+    | DataStructure['equivalentSignatureVariables']
+    | boolean,
+  reverseArg?: boolean,
 ) {
+  // Handle backwards compatibility: detect if called with old signature
+  // Old: (mergedDataStructure, equivalentSignatureVariables?, reverse?)
+  // New: (isolatedDataStructure, mergedDataStructure, equivalentSignatureVariables?, reverse?)
+  let mergedDataStructure: Omit<
+    DataStructure,
+    'equivalentSignatureVariables'
+  > | null;
+  let equivalentSignatureVariables: DataStructure['equivalentSignatureVariables'];
+  let reverse: boolean;
+
+  if (
+    mergedDataStructureOrEquivalentVars &&
+    typeof mergedDataStructureOrEquivalentVars === 'object' &&
+    'dependencySchemas' in mergedDataStructureOrEquivalentVars
+  ) {
+    // New signature: (isolated, merged, equivalentVars?, reverse?)
+    mergedDataStructure = mergedDataStructureOrEquivalentVars as Omit<
+      DataStructure,
+      'equivalentSignatureVariables'
+    >;
+    equivalentSignatureVariables =
+      (equivalentSignatureVariablesOrReverse as DataStructure['equivalentSignatureVariables']) ??
+      {};
+    reverse = reverseArg ?? false;
+  } else {
+    // Old signature: (merged, equivalentVars?, reverse?)
+    // Use isolatedDataStructure as both isolated and merged for backwards compatibility
+    mergedDataStructure = null; // Will use isolatedDataStructure for types
+    equivalentSignatureVariables =
+      (mergedDataStructureOrEquivalentVars as DataStructure['equivalentSignatureVariables']) ??
+      {};
+    reverse =
+      (equivalentSignatureVariablesOrReverse as boolean | undefined) ?? false;
+  }
+
   const attributesMap: Record<string, string> = {};
   const associationMap: Record<string, string> = {};
   // Maps internalPath -> full data structure path (e.g., "useDiffModal().diffView")
   const dataStructurePathMap: Record<string, string> = {};
-  const { signatureSchema, equivalentSignatureVariables, dependencySchemas } =
-    entity.metadata.isolatedDataStructure;
-  for (const key in signatureSchema) {
+
+  // Use isolatedDataStructure for paths, but look up types in mergedDataStructure when available
+  const isolatedSignatureSchema = isolatedDataStructure.signatureSchema;
+  const mergedSignatureSchema =
+    mergedDataStructure?.signatureSchema ?? isolatedSignatureSchema;
+  const isolatedDependencySchemas = isolatedDataStructure.dependencySchemas;
+  const mergedDependencySchemas =
+    mergedDataStructure?.dependencySchemas ?? isolatedDependencySchemas;
+
+  // Process signature schema - use isolatedDataStructure keys, but merged types
+  for (const key in isolatedSignatureSchema) {
     const keyParts = splitOutsideParenthesesAndArrays(key);
     if (keyParts[0].startsWith('signature')) {
+      // Use merged type if available, otherwise fall back to isolated type
+      const typeValue =
+        mergedSignatureSchema[key] ?? isolatedSignatureSchema[key];
       const equivalentSignatureVariable =
         equivalentSignatureVariables[keyParts[0]];
       const equivalentSignatureVariableParts = splitOutsideParenthesesAndArrays(
@@ -92,7 +153,7 @@ export function gatherAttributesMap(
           equivalentKey,
           ...keyParts.slice(1),
         ]);
-        attributesMap[equivalentPath] = signatureSchema[key];
+        attributesMap[equivalentPath] = typeValue;
         associationMap[reverse ? equivalentPath : key] = reverse
           ? key
           : equivalentPath;
@@ -100,7 +161,7 @@ export function gatherAttributesMap(
         dataStructurePathMap[equivalentPath] = equivalentPath;
       } else {
         const relativePath = joinParenthesesAndArrays(keyParts.slice(1));
-        attributesMap[relativePath] = signatureSchema[key];
+        attributesMap[relativePath] = typeValue;
         associationMap[reverse ? relativePath : key] = reverse
           ? key
           : relativePath;
@@ -110,25 +171,41 @@ export function gatherAttributesMap(
     }
   }
 
-  for (const filePath in dependencySchemas) {
-    for (const entityName in dependencySchemas[filePath]) {
-      const returnValueDataStructure =
-        dependencySchemas[filePath][entityName].returnValueSchema ?? {};
+  // Process dependency schemas - iterate through isolatedDependencySchemas (for which paths to include)
+  // but use mergedDependencySchemas for types (richer type information)
+  for (const filePath in isolatedDependencySchemas) {
+    for (const entityName in isolatedDependencySchemas[filePath]) {
+      // Get the isolated return value schema (determines which paths exist)
+      const isolatedReturnValueSchema =
+        isolatedDependencySchemas[filePath][entityName].returnValueSchema ?? {};
+
+      // Get the merged return value schema (for richer types)
+      const mergedReturnValueSchema =
+        mergedDependencySchemas?.[filePath]?.[entityName]?.returnValueSchema ??
+        isolatedReturnValueSchema;
 
-      // First pass: collect all function paths
+      // First pass: collect all function paths from merged schema (for broader coverage)
       const functionPaths: string[] = [];
-      for (const path in returnValueDataStructure) {
-        if (returnValueDataStructure[path] === 'function') {
+      for (const path in mergedReturnValueSchema) {
+        if (mergedReturnValueSchema[path] === 'function') {
           functionPaths.push(path);
         }
       }
 
-      // Second pass: process all paths
-      for (const path in returnValueDataStructure) {
+      // Second pass: process paths from merged schema, but only include paths that
+      // are rooted in an isolated path (i.e., isolatedDataStructure knows about this dependency)
+      for (const path in mergedReturnValueSchema) {
         const pathParts = splitOutsideParenthesesAndArrays(path);
         if (pathParts.length < 2) continue;
 
-        if (returnValueDataStructure[path] === 'function') {
+        // Filter out paths that contain signature[N] anywhere
+        // These represent function input parameters, not data from data sources
+        // Key attributes must reference data sources, not function inputs
+        if (pathParts.some((part) => part.startsWith('signature['))) {
+          continue;
+        }
+
+        if (mergedReturnValueSchema[path] === 'function') {
           continue;
         }
 
@@ -176,7 +253,7 @@ export function gatherAttributesMap(
               const relativePath = path;
               if (!validAttribute(relativePath)) continue;
 
-              attributesMap[relativePath] = returnValueDataStructure[path];
+              attributesMap[relativePath] = mergedReturnValueSchema[path];
               associationMap[reverse ? relativePath : path] = reverse
                 ? path
                 : relativePath;
@@ -194,7 +271,8 @@ export function gatherAttributesMap(
         // Normalize the path for internal use (e.g., ['*'] -> '*')
         const relativePath = normalizePathForInternalUse(rawRelativePath);
 
-        attributesMap[relativePath] = returnValueDataStructure[path];
+        // Use the type from mergedReturnValueSchema
+        attributesMap[relativePath] = mergedReturnValueSchema[path];
         associationMap[reverse ? relativePath : path] = reverse
           ? path
           : relativePath;