@codeyam/codeyam-cli 0.1.0-staging.28f73cf → 0.1.0-staging.596f0eb

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

@@ -1,10 +1,10 @@
 {
-  "buildTimestamp": "2025-12-16T20:02:21.653Z",
-  "buildTime": 1765915341653,
-  "gitCommit": "28f73cf22d6b331e2b51d4decb98d0a609c4aaed",
+  "buildTimestamp": "2025-12-29T14:25:31.079Z",
+  "buildTime": 1767018331079,
+  "gitCommit": "596f0eba949668a0fbeb95513ac34bec8fe830b9",
   "nodeVersion": "v20.19.6",
-  "contentHash": "ac87fbc219400e8885551f1406d39408dd12ca20cbec5bf28def6b90be8e623f",
-  "buildNumber": 99,
-  "semanticVersion": "0.1.99",
-  "version": "0.1.99 (2025-12-16T20:02+ac87fbc)"
+  "contentHash": "4ace14f6fdebddb09650af55ef766aa49b01e8edc4c9644fff7d051498b4e584",
+  "buildNumber": 251,
+  "semanticVersion": "0.1.251",
+  "version": "0.1.251 (2025-12-29T14:25+4ace14f)"
 }

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/16/2025, 8:02:21 PM] > codeyam-combo@1.0.0 mergeDependencies
-[12/16/2025, 8:02:21 PM] > node ./scripts/mergePackageJsonFiles.cjs
+[12/29/2025, 2:25:30 PM] > codeyam-combo@1.0.0 mergeDependencies
+[12/29/2025, 2:25:30 PM] > node ./scripts/mergePackageJsonFiles.cjs
 
 
-[12/16/2025, 8:02:21 PM] Merged dependencies into root package.json
+[12/29/2025, 2:25:31 PM] Merged dependencies into root package.json
 

package/analyzer-template/package.json

@@ -10,25 +10,25 @@
     "@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",
     "get-port": "^7.1.0",
     "htmlparser2": "^10.0.0",
     "jest": "^30.2.0",
-    "jsdom": "^27.3.0",
+    "jsdom": "^27.4.0",
     "jsonc-parser": "^3.2.1",
     "lru-cache": "^11.2.4",
     "openai": "^6.9.0",
@@ -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,15 +56,15 @@
     "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",
-    "@types/react": "^18.0.0",
-    "@types/react-dom": "^18.0.0",
+    "@octokit/types": "^15.0.0",
+    "@types/react": "^19.2.7",
+    "@types/react-dom": "^19.2.3",
     "@types/react-resizable": "^3.0.7",
-    "react": "^18.0.0",
-    "react-dom": "^18.0.0"
+    "react": "^19.2.3",
+    "react-dom": "^19.2.3"
   }
 }

package/analyzer-template/packages/ai/index.ts

@@ -49,7 +49,10 @@ export {
   functionArguments,
 } from './src/lib/splitOutsideParentheses';
 export { cleanKnownObjectFunctionsFromMapping } from './src/lib/dataStructure/helpers/cleanKnownObjectFunctions';
-export { clearAttributesFromMapping } from './src/lib/dataStructure/helpers/cleanNonObjectFunctions';
+export {
+  clearAttributesFromMapping,
+  removeDuplicateFunctionCalls,
+} from './src/lib/dataStructure/helpers/cleanNonObjectFunctions';
 export { default as convertDotNotation } from './src/lib/dataStructure/helpers/convertDotNotation';
 export { default as cleanOutBoundary } from './src/lib/cleanOutBoundary';
 export { fillInDirectSchemaGapsAndUnknowns } from './src/lib/dataStructure/helpers/fillInSchemaGapsAndUnknowns';

package/analyzer-template/packages/ai/package.json

@@ -10,7 +10,7 @@
   "license": "ISC",
   "dependencies": {
     "@anthropic-ai/sdk": "^0.71.0",
-    "jsdom": "^27.3.0",
+    "jsdom": "^27.4.0",
     "p-queue": "^8.1.0",
     "p-retry": "^6.2.1",
     "piscina": "^5.1.4",

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;
+          }
         }
       }
     }
@@ -1667,6 +1725,24 @@ export function processExpression({
     return true;
   }
 
+  // Handle Void Expression: void x, void 0, void func()
+  if (ts.isVoidExpression(unwrappedNode)) {
+    // Process the inner expression for side effects
+    processExpression({ node: unwrappedNode.expression, context });
+
+    // void always returns undefined
+    if (targetPath) {
+      const voidPath = StructuredPath.createLiteralPath(
+        'undefined',
+        'undefined',
+      );
+      context.addEquivalence(targetPath, voidPath);
+      context.addType(targetPath, 'undefined');
+    }
+
+    return true;
+  }
+
   // Handle Prefix Unary Expressions: ++x, --y, !z, -a
   if (ts.isPrefixUnaryExpression(unwrappedNode)) {
     // Process the operand
@@ -1883,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;
 }