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

package/analyzer-template/.build-info.json

@@ -1,10 +1,10 @@
 {
-  "buildTimestamp": "2025-12-17T19:39:28.401Z",
-  "buildTime": 1766000368401,
-  "gitCommit": "bbe4da9b5873990798f51f39d49831246271496a",
+  "buildTimestamp": "2025-12-23T17:38:51.428Z",
+  "buildTime": 1766511531428,
+  "gitCommit": "e38f7bd58a1d4e993ace03d386883a673bd25fde",
   "nodeVersion": "v20.19.6",
-  "contentHash": "be7e64fc3bba85964ee680ed15541409c2e2b8872b75b862e387b8e1e25ed618",
-  "buildNumber": 121,
-  "semanticVersion": "0.1.121",
-  "version": "0.1.121 (2025-12-17T19:39+be7e64f)"
+  "contentHash": "eaad128c84b241d0b1c80bea014c54c92c3ec1e09a65b9894af91b7acde4d16d",
+  "buildNumber": 169,
+  "semanticVersion": "0.1.169",
+  "version": "0.1.169 (2025-12-23T17:38+eaad128)"
 }

package/analyzer-template/common/execAsync.ts

@@ -1,7 +1,7 @@
 import {
   loadBackgroundJob,
   updateBackgroundJobProgress,
-} from '~codeyam/supabase';
+} from '~codeyam/database';
 import * as fs from 'fs';
 import { ChildProcessWithoutNullStreams, spawn } from 'child_process';
 

package/analyzer-template/log.txt

@@ -1,7 +1,7 @@
 
-[12/17/2025, 7:39:28 PM] > codeyam-combo@1.0.0 mergeDependencies
-[12/17/2025, 7:39:28 PM] > node ./scripts/mergePackageJsonFiles.cjs
+[12/23/2025, 5:38:51 PM] > codeyam-combo@1.0.0 mergeDependencies
+[12/23/2025, 5:38:51 PM] > node ./scripts/mergePackageJsonFiles.cjs
 
 
-[12/17/2025, 7:39:28 PM] Merged dependencies into root package.json
+[12/23/2025, 5:38:51 PM] Merged dependencies into root package.json
 

package/analyzer-template/package.json

@@ -10,18 +10,18 @@
     "@aws-sdk/client-cloudwatch-logs": "^3.940.0",
     "@aws-sdk/client-cloudfront": "^3.899.0",
     "@aws-sdk/client-codebuild": "^3.948.0",
-    "@aws-sdk/client-dynamodb": "^3.899.0",
+    "@aws-sdk/client-dynamodb": "^3.956.0",
     "@aws-sdk/client-ec2": "^3.899.0",
     "@aws-sdk/client-ecr": "^3.948.0",
-    "@aws-sdk/client-ecs": "^3.937.0",
+    "@aws-sdk/client-ecs": "^3.956.0",
     "@aws-sdk/client-s3": "^3.940.0",
-    "@aws-sdk/client-sqs": "^3.940.0",
+    "@aws-sdk/client-sqs": "^3.956.0",
     "@aws-sdk/lib-storage": "^3.940.0",
     "@aws-sdk/util-dynamodb": "^3.902.0",
     "@octokit/auth-app": "^8.1.0",
     "@octokit/rest": "^22.0.0",
     "@sendgrid/mail": "^8.1.4",
-    "@supabase/supabase-js": "2.52.1",
+    "@supabase/supabase-js": "2.88.0",
     "domhandler": "^5.0.3",
     "dotenv": "^17.2.3",
     "express": "^5.2.1",
@@ -44,11 +44,11 @@
     "pluralize": "^8.0.0",
     "@anthropic-ai/sdk": "^0.71.0",
     "@aws-sdk/s3-request-presigner": "^3.940.0",
-    "@octokit/request": "^10.0.3",
     "better-sqlite3": "^12.4.1",
     "fetch-retry": "^6.0.0",
     "kysely": "^0.28.5",
     "pg": "^8.16.3",
+    "@octokit/request": "^10.0.3",
     "lucide-react": "^0.556.0",
     "react-resizable": "^3.0.5"
   },
@@ -56,11 +56,11 @@
     "typescript": "^5.9.3",
     "@jest/types": "^30.2.0",
     "@types/jsdom": "^27.0.0",
-    "@octokit/types": "^15.0.0",
     "@types/better-sqlite3": "^7.6.13",
     "@types/jest": "^30.0.0",
     "@types/pg": "^8.15.5",
     "@types/ws": "^8.18.1",
+    "@octokit/types": "^15.0.0",
     "@types/react": "^18.0.0",
     "@types/react-dom": "^18.0.0",
     "@types/react-resizable": "^3.0.7",

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

@@ -24,7 +24,7 @@ import mergeStatements, { Statement } from './mergeStatements';
 import { analyzeScopeWithAst } from './astScopes';
 import { FileAnalyzer } from '~codeyam/analyze';
 import { writeFile } from 'fs/promises';
-import { saveEntityStatements } from '~codeyam/supabase';
+import { saveEntityStatements } from '~codeyam/database';
 import {
   ScopeDataStructure,
   ScopeInfo,
@@ -259,6 +259,32 @@ export async function analyzeScopeLocal({
               },
             );
 
+            // DEBUG: Log child scope replacement context for fetcher statements
+            if (
+              statementScope.text.includes('Fetcher') ||
+              statementScope.text.includes('fetcher')
+            ) {
+              console.log(
+                'CodeYam DEBUG childScope replacement:',
+                JSON.stringify(
+                  {
+                    statementText: statementScope.text.slice(0, 80),
+                    statementStart: statementScope.start,
+                    statementEnd: statementScope.end,
+                    childBoundaries: statementScope.childBoundaries,
+                    relevantChildScopes: Object.keys(relevantChildScopes),
+                    astStructure: astAnalysisResult.structure,
+                    astEquivalentVariables:
+                      astAnalysisResult.equivalentVariables,
+                    astIsComplete: astAnalysisResult.isComplete,
+                    equivalentVariables,
+                  },
+                  null,
+                  2,
+                ),
+              );
+            }
+
             for (const mapping of [structure, equivalentVariables]) {
               for (let [key, value] of Object.entries(mapping)) {
                 for (const [childScopeId, childScope] of sortedEntries) {
@@ -281,6 +307,18 @@ export async function analyzeScopeLocal({
                   };
 
                   if (value.includes(scopeText)) {
+                    // DEBUG: Log when replacement happens
+                    if (key.includes('Fetcher') || key.includes('fetcher')) {
+                      console.log(
+                        'CodeYam DEBUG value replacement:',
+                        JSON.stringify({
+                          key,
+                          oldValue: value,
+                          childScopeId,
+                          scopeTextPreview: scopeText.slice(0, 50),
+                        }),
+                      );
+                    }
                     value = replaceChildScopeId(value);
                     mapping[key] = value;
                   }

package/analyzer-template/packages/ai/src/lib/astScopes/astScopeAnalyzer.ts

@@ -155,9 +155,6 @@ export class ASTScopeAnalyzer {
    * Performs the analysis by identifying and processing patterns in the AST
    */
   analyze(): AstScopeAnalysisResult {
-    // Debug log the source code
-    // console.log('Analyzing source code:', this.scope.text);
-
     // Create analysis context
     const context: AnalysisContext = this.createAnalysisContext();
 
@@ -167,27 +164,9 @@ export class ASTScopeAnalyzer {
       this.statementInfo.start,
       this.statementInfo.end,
     );
-    // console.info('SOURCEFILE', this.sourceFile.getText());
-    // console.info('RANGE', this.statementInfo.start, this.statementInfo.end, this.sourceFile.getText().slice(this.statementInfo.start, this.statementInfo.end));
 
     this.processNodes(relevantNodes, context);
 
-    // for (const childBoundary of this.statementInfo.childBoundaries) {
-    //   const boundaryText = this.sourceFile.getText().slice(childBoundary.start, childBoundary.end);
-    //   console.info('CHILD', boundaryText);
-    //   for (const equivalentVariableKey in this.equivalentVariables) {
-    //     const equivalentVariableValue = this.equivalentVariables[equivalentVariableKey];
-    //     for (const path of [equivalentVariableKey, equivalentVariableValue]) {
-    //       console.info('CHECKING', path);
-    //       console.info("REPLACE", path.replace(boundaryText, ''))
-    //       if (path.replace(boundaryText, '').replace(/[\s\(\)]*/g, '') === '') {
-    //         this.equivalentVariables[equivalentVariableKey] = 'cyScope3'
-    //         delete this.equivalentVariables[equivalentVariableKey];
-    //       }
-    //     }
-    //   }
-    // }
-
     // Calculate completeness
     const completeness = this.calculateCompleteness();
 
@@ -266,6 +245,7 @@ export class ASTScopeAnalyzer {
         processExpression({ node, context, targetPath }),
       addConditionalUsage: (usage) => this.addConditionalUsage(usage),
       getConditionalUsages: () => this.conditionalUsages,
+      updateSchemaType: (path, newType) => this.updateSchemaType(path, newType),
     };
     return context;
   }
@@ -648,6 +628,46 @@ export class ASTScopeAnalyzer {
     }
   }
 
+  /**
+   * Updates the schema type for a path, typically used when switch statements
+   * reveal the valid values for a parameter (creating a union type like "'a' | 'b' | 'c'")
+   *
+   * This method:
+   * 1. Updates the type for the given path
+   * 2. Also updates the type for any equivalent path (e.g., if "state" -> "signature[0]",
+   *    we update both "state" and "signature[0]")
+   * 3. For property paths like "data.status", if "data" -> "signature[0]",
+   *    we also update "signature[0].status"
+   */
+  private updateSchemaType(
+    path: string | StructuredPath,
+    newType: string,
+  ): void {
+    const pathStr = path.toString();
+
+    // Update the type for the given path
+    this.structure[pathStr] = newType;
+
+    // Also update the type for any equivalent path
+    // e.g., if "state" -> "signature[0]", update "signature[0]" as well
+    const equivalentPath = this.equivalentVariables[pathStr];
+    if (equivalentPath) {
+      this.structure[equivalentPath] = newType;
+    }
+
+    // For property paths like "data.status", check if the base has an equivalence
+    // e.g., if "data" -> "signature[0]", transform "data.status" to "signature[0].status"
+    for (const [varPath, equivalence] of Object.entries(
+      this.equivalentVariables,
+    )) {
+      if (pathStr.startsWith(varPath + '.')) {
+        const suffix = pathStr.slice(varPath.length);
+        const transformedPath = equivalence + suffix;
+        this.structure[transformedPath] = newType;
+      }
+    }
+  }
+
   /**
    * Get a simplified type string from a TypeScript Type object
    * This converts TypeScript's internal type representation to our type system

package/analyzer-template/packages/ai/src/lib/astScopes/methodSemantics.ts

@@ -343,6 +343,56 @@ export class ArraySpliceSemantics implements MethodSemantics {
   }
 }
 
+/**
+ * Array push method semantics
+ *
+ * push() adds one or more elements to the end of an array and returns the new length.
+ * Critically for data flow analysis, pushed elements become array elements.
+ */
+export class ArrayPushSemantics implements MethodSemantics {
+  getReturnType(): string {
+    return 'number'; // push returns the new length of the array
+  }
+
+  addEquivalences(
+    methodCallPath: StructuredPath,
+    sourcePath: StructuredPath,
+    context: AnalysisContext,
+  ): void {
+    // Mark source as array
+    context.addType(sourcePath, 'array');
+
+    // Get the last function call segment to access the arguments
+    const functionCallSegment = methodCallPath.getLastFunctionCallSegment();
+
+    if (functionCallSegment && functionCallSegment.args.length > 0) {
+      // Each argument is an element being added to the array
+      // Establish equivalence: array[] === pushed element
+      // This enables tracing through patterns like:
+      //   allEntities.push({...entity})
+      //   allEntities.map(e => e.prop) // e.prop traces back to entity.prop
+      //
+      // We use methodCallPath.withParameter(i) because that's the path used when
+      // processExpression processes each argument. The spread equivalencies are
+      // set up against signature[i] paths, so we need to connect to those.
+      //
+      // Note: The path transformation in paths.ts now correctly handles the case
+      // where .signature[n] follows a function call - it won't add
+      // .functionCallReturnValue before the parameter path.
+      for (let i = 0; i < functionCallSegment.args.length; i++) {
+        context.addEquivalence(
+          sourcePath.withElement('*'),
+          methodCallPath.withParameter(i),
+        );
+      }
+    }
+  }
+
+  isComplete(): boolean {
+    return true;
+  }
+}
+
 /**
  * Array join method semantics
  *
@@ -710,6 +760,7 @@ export function createMethodRegistry(): MethodSemanticsRegistry {
   registry.register('concat', new ArrayConcatSemantics(), 'Array');
   registry.register('slice', new ArraySliceSemantics(), 'Array');
   registry.register('splice', new ArraySpliceSemantics(), 'Array');
+  registry.register('push', new ArrayPushSemantics(), 'Array');
 
   // Register Object methods
   registry.register('fromEntries', new ObjectFromEntriesSemantics(), 'Object');

package/analyzer-template/packages/ai/src/lib/astScopes/paths.ts

@@ -415,7 +415,20 @@ export class StructuredPath {
             result += `(${argsStr})`;
           }
 
-          if (i === lastFunctionCallIndex && doRenderFunctionCallReturnValue) {
+          // Add .functionCallReturnValue if:
+          // 1. This is the last function call in the path
+          // 2. We're rendering with return values (right-hand side of equivalency)
+          // 3. The next segment is NOT a parameter (signature[n])
+          // Parameter segments represent function inputs, not outputs, so they
+          // shouldn't go through .functionCallReturnValue
+          const nextSegmentIsParameter =
+            i + 1 < segments.length &&
+            segments[i + 1].type === PathRelationship.PARAMETER;
+          if (
+            i === lastFunctionCallIndex &&
+            doRenderFunctionCallReturnValue &&
+            !nextSegmentIsParameter
+          ) {
             // Add the return value marker
             result += '.functionCallReturnValue';
           }

package/analyzer-template/packages/ai/src/lib/astScopes/patterns/switchStatementHandler.ts

@@ -40,13 +40,22 @@ export class SwitchStatementHandler implements PatternHandler {
         }
       }
 
+      const discriminantPathStr = discriminantPath.toLeftHandSideString();
+
       // Record the conditional usage
       context.addConditionalUsage({
-        path: discriminantPath.toLeftHandSideString(),
+        path: discriminantPathStr,
         conditionType: 'switch',
         comparedValues: caseValues.length > 0 ? caseValues : undefined,
         location: 'switch',
       });
+
+      // Update the schema type to be a union of the case values
+      // This ensures the LLM knows the valid values for this field
+      if (caseValues.length > 0) {
+        const unionType = caseValues.map((v) => `'${v}'`).join(' | ');
+        context.updateSchemaType(discriminantPathStr, unionType);
+      }
     }
 
     // Process each clause in the switch statement

package/analyzer-template/packages/ai/src/lib/astScopes/processExpression.ts

@@ -2,7 +2,7 @@ import ts from 'typescript';
 import { AnalysisContext, ConditionalUsage } from './types';
 import { StructuredPath } from './paths';
 import { nodeToSource } from './nodeToSource';
-import { methodRegistry } from './methodSemantics';
+import { methodRegistry, ArrayPushSemantics } from './methodSemantics';
 import {
   isArithmeticOperator,
   isAssignmentOperator,
@@ -15,6 +15,47 @@ import {
 } from './sharedPatterns';
 import { processBindingPattern } from './processBindings';
 
+/**
+ * Checks if an expression is likely an array type.
+ * Uses TypeScript's type checker when available, falls back to heuristics.
+ */
+function isLikelyArrayType(
+  expr: ts.Expression,
+  typeChecker: ts.TypeChecker | undefined,
+): boolean {
+  if (typeChecker) {
+    try {
+      const type = typeChecker.getTypeAtLocation(expr);
+      const typeString = typeChecker.typeToString(type);
+      // Check for common array type patterns:
+      // - T[] syntax (includes any[], string[], etc.)
+      // - Array<T> syntax
+      // - ReadonlyArray<T> syntax
+      // - readonly T[] syntax (starts with "readonly " and ends with "[]")
+      if (
+        typeString.includes('[]') ||
+        typeString.startsWith('Array<') ||
+        typeString.startsWith('ReadonlyArray<')
+      ) {
+        return true;
+      }
+      // Check if it's a tuple or array literal type via TypeScript's type flags
+      if (type.getFlags() & ts.TypeFlags.Object) {
+        const objectType = type as ts.ObjectType;
+        if (
+          objectType.objectFlags & ts.ObjectFlags.Tuple ||
+          objectType.objectFlags & ts.ObjectFlags.ArrayLiteral
+        ) {
+          return true;
+        }
+      }
+    } catch {
+      // Type checking can fail in some edge cases, fall through to false
+    }
+  }
+  return false;
+}
+
 /**
  * Marks variables used in truthiness checks as potentially undefined.
  * When code checks `if (x)` or `x && ...`, it indicates x might be falsy (null/undefined).
@@ -939,10 +980,19 @@ export function processExpression({
         );
 
         if (sourcePath) {
-          // Apply method semantics
-          semantics.addEquivalences(callPath, sourcePath, context);
-          returnType = semantics.getReturnType();
-          handledBySemantics = true;
+          // For array-specific semantics (like push), verify the source is actually an array
+          // This prevents router.push() from being mistakenly treated as Array.push()
+          const isArraySemantics = semantics instanceof ArrayPushSemantics;
+          const shouldApply =
+            !isArraySemantics ||
+            isLikelyArrayType(sourceExpr, context.typeChecker);
+
+          if (shouldApply) {
+            // Apply method semantics
+            semantics.addEquivalences(callPath, sourcePath, context);
+            returnType = semantics.getReturnType();
+            handledBySemantics = true;
+          }
         }
       }
     }
@@ -965,10 +1015,18 @@ export function processExpression({
         );
 
         if (sourcePath) {
-          // Apply method semantics
-          semantics.addEquivalences(callPath, sourcePath, context);
-          returnType = semantics.getReturnType();
-          handledBySemantics = true;
+          // For array-specific semantics (like push), verify the source is actually an array
+          const isArraySemantics = semantics instanceof ArrayPushSemantics;
+          const shouldApply =
+            !isArraySemantics ||
+            isLikelyArrayType(sourceExpr, context.typeChecker);
+
+          if (shouldApply) {
+            // Apply method semantics
+            semantics.addEquivalences(callPath, sourcePath, context);
+            returnType = semantics.getReturnType();
+            handledBySemantics = true;
+          }
         }
       }
     }
@@ -1901,8 +1959,9 @@ export function processExpression({
       }
     }
 
-    // Register component as 'function' type (not 'JSX')
-    context.addType(componentPath, 'function');
+    // Register component as 'jsx-component' type to distinguish from regular function calls
+    // This allows downstream code to identify JSX components and not treat them as method chains
+    context.addType(componentPath, 'jsx-component');
 
     // If targetPath is provided (e.g., in variable assignment), establish equivalence to hardcoded "JSX"
     if (targetPath) {

package/analyzer-template/packages/ai/src/lib/astScopes/types.ts

@@ -317,4 +317,8 @@ export interface AnalysisContext {
 
   // Get all conditional usages
   getConditionalUsages(): Record<string, ConditionalUsage[]>;
+
+  // Update a schema type, typically used when switch statements reveal
+  // the valid values for a parameter (creating a union type)
+  updateSchemaType(path: string | StructuredPath, newType: string): void;
 }