@codeyam/codeyam-cli 0.1.0-staging.ad31e3e → 0.1.0-staging.b8a55ba

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

@@ -1,10 +1,10 @@
 {
-  "buildTimestamp": "2025-12-16T15:34:02.479Z",
-  "buildTime": 1765899242479,
-  "gitCommit": "ad31e3ef5ec259a22ee009ca6a7bc35682c297a7",
+  "buildTimestamp": "2026-01-08T16:34:34.962Z",
+  "buildTime": 1767890074962,
+  "gitCommit": "b8a55bae42c01162f8b78a22f77b23029ff8e6fe",
   "nodeVersion": "v20.19.6",
-  "contentHash": "72c7943edf0ece740338c522a5b1737e7586cb2bee94c4bb8c3dfc320cc4f63f",
-  "buildNumber": 99,
-  "semanticVersion": "0.1.99",
-  "version": "0.1.99 (2025-12-16T15:34+72c7943)"
+  "contentHash": "15631e2833f0bf3b73a8d75736c067328a964c6150dbd4efaba4f99f1a4fa136",
+  "buildNumber": 338,
+  "semanticVersion": "0.1.338",
+  "version": "0.1.338 (2026-01-08T16:34+15631e2)"
 }

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, 3:34:02 PM] > codeyam-combo@1.0.0 mergeDependencies
-[12/16/2025, 3:34:02 PM] > node ./scripts/mergePackageJsonFiles.cjs
+[1/8/2026, 4:34:34 PM] > codeyam-combo@1.0.0 mergeDependencies
+[1/8/2026, 4:34:34 PM] > node ./scripts/mergePackageJsonFiles.cjs
 
 
-[12/16/2025, 3:34:02 PM] Merged dependencies into root package.json
+[1/8/2026, 4:34:34 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-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,27 +44,28 @@
     "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"
   },
   "devDependencies": {
     "typescript": "^5.9.3",
     "@jest/types": "^30.2.0",
+    "@types/node": "^25.0.2",
     "@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

@@ -5,6 +5,7 @@ import {
   AnalysisIssue,
   AstScopeAnalysisResult,
   CompletenessInfo,
+  CompoundConditional,
   ConditionalUsage,
 } from './types';
 import { PatternHandler } from './patterns/patternHandler';
@@ -103,6 +104,7 @@ export class ASTScopeAnalyzer {
   private equivalentVariables: Record<string, string> = {};
   private environmentVariables: string[] = [];
   private conditionalUsages: Record<string, ConditionalUsage[]> = {};
+  private compoundConditionals: CompoundConditional[] = [];
   private sourceFile: ts.SourceFile;
   private statementInfo: StatementInfo;
   private issues: AnalysisIssue[] = [];
@@ -155,9 +157,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 +166,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();
 
@@ -224,6 +205,7 @@ export class ASTScopeAnalyzer {
       equivalentVariables: this.equivalentVariables,
       environmentVariables: this.environmentVariables,
       conditionalUsages: this.conditionalUsages,
+      compoundConditionals: this.compoundConditionals,
       isComplete:
         completeness.equivalences === 'full' &&
         completeness.structures === 'full',
@@ -266,6 +248,10 @@ export class ASTScopeAnalyzer {
         processExpression({ node, context, targetPath }),
       addConditionalUsage: (usage) => this.addConditionalUsage(usage),
       getConditionalUsages: () => this.conditionalUsages,
+      addCompoundConditional: (compound) =>
+        this.addCompoundConditional(compound),
+      getCompoundConditionals: () => this.compoundConditionals,
+      updateSchemaType: (path, newType) => this.updateSchemaType(path, newType),
     };
     return context;
   }
@@ -648,6 +634,62 @@ export class ASTScopeAnalyzer {
     }
   }
 
+  /**
+   * Add a compound conditional for key attribute dependency detection
+   */
+  private addCompoundConditional(compound: CompoundConditional): void {
+    // Avoid duplicates by expression and location (chainId is generated each time)
+    const exists = this.compoundConditionals.some(
+      (existing) =>
+        existing.expression === compound.expression &&
+        existing.sourceLocation.lineNumber ===
+          compound.sourceLocation.lineNumber,
+    );
+    if (!exists) {
+      this.compoundConditionals.push(compound);
+    }
+  }
+
+  /**
+   * 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

@@ -1,8 +1,29 @@
 import ts from 'typescript';
-import { AnalysisContext } from '../types';
+import { AnalysisContext, ConditionalUsage } from '../types';
 import { PatternHandler } from './patternHandler';
 import { StructuredPath } from '../paths';
 
+/**
+ * Helper to extract source location from an AST node
+ */
+function getSourceLocation(
+  node: ts.Node,
+  sourceFile: ts.SourceFile,
+): 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,
+  };
+}
+
 /**
  * Handler for switch statements
  *
@@ -40,13 +61,23 @@ 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',
+        sourceLocation: getSourceLocation(node, context.sourceFile),
       });
+
+      // 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