@codeyam/codeyam-cli 0.1.0-staging.da5baf5 → 0.1.0-staging.dd216e0

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

@@ -1,10 +1,10 @@
 {
-  "buildTimestamp": "2025-12-15T15:50:41.971Z",
-  "buildTime": 1765813841971,
-  "gitCommit": "da5baf534309f9f059e043042730bf0993eb0640",
+  "buildTimestamp": "2026-01-05T15:37:00.926Z",
+  "buildTime": 1767627420926,
+  "gitCommit": "dd216e0d6e5598b942521bc0a8f6d12a2f59f72c",
   "nodeVersion": "v20.19.6",
-  "contentHash": "2c9f0bc4d65197e4b67c5ccef109d0ecbdfa22dfe54c5231acde2ef566661ef0",
-  "buildNumber": 96,
-  "semanticVersion": "0.1.96",
-  "version": "0.1.96 (2025-12-15T15:50+2c9f0bc)"
+  "contentHash": "59774340cd442a1859141603f254287683931a71da475f0b8a4b9bbba0c7eaed",
+  "buildNumber": 305,
+  "semanticVersion": "0.1.305",
+  "version": "0.1.305 (2026-01-05T15:37+5977434)"
 }

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/15/2025, 3:50:41 PM] > codeyam-combo@1.0.0 mergeDependencies
-[12/15/2025, 3:50:41 PM] > node ./scripts/mergePackageJsonFiles.cjs
+[1/5/2026, 3:37:00 PM] > codeyam-combo@1.0.0 mergeDependencies
+[1/5/2026, 3:37:00 PM] > node ./scripts/mergePackageJsonFiles.cjs
 
 
-[12/15/2025, 3:50:41 PM] Merged dependencies into root package.json
+[1/5/2026, 3:37:00 PM] Merged dependencies into root package.json
 

package/analyzer-template/package.json

@@ -7,28 +7,28 @@
     "build": "tsc && node ./scripts/postbuild.cjs"
   },
   "dependencies": {
-    "@aws-sdk/client-cloudwatch-logs": "^3.940.0",
+    "@aws-sdk/client-cloudwatch-logs": "^3.962.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-s3": "^3.899.0",
-    "@aws-sdk/client-sqs": "^3.940.0",
-    "@aws-sdk/lib-storage": "^3.899.0",
+    "@aws-sdk/client-ecs": "^3.956.0",
+    "@aws-sdk/client-s3": "^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",
@@ -43,27 +43,29 @@
     "uuid": "^11.1.0",
     "pluralize": "^8.0.0",
     "@anthropic-ai/sdk": "^0.71.0",
-    "@octokit/request": "^10.0.3",
+    "@aws-sdk/s3-request-presigner": "^3.940.0",
     "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"
   },
   "devDependencies": {
     "typescript": "^5.9.3",
     "@jest/types": "^30.2.0",
+    "@types/node": "^22.0.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,
@@ -32,6 +32,7 @@ import {
 import FunctionCallManager from './dataStructure/equivalencyManagers/FunctionCallManager';
 import { ReactFrameworkManager } from './dataStructure/equivalencyManagers/frameworks/ReactFrameworkManager';
 import { JavascriptFrameworkManager } from './dataStructure/equivalencyManagers/frameworks/JavascriptFrameworkManager';
+import { MuiManager } from './dataStructure/equivalencyManagers/frameworks/MuiManager';
 import ParentScopeManager from './dataStructure/equivalencyManagers/ParentScopeManager';
 import { AI } from '~codeyam/ai';
 import Piscina from 'piscina';
@@ -259,6 +260,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 +308,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;
                   }
@@ -435,6 +474,7 @@ export async function analyzeScopeLocal({
           new FunctionCallManager(),
           new ReactFrameworkManager(),
           new JavascriptFrameworkManager(),
+          new MuiManager(),
           new ParentScopeManager(),
         ],
         scope.name,

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