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

package/analyzer-template/packages/analyze/src/lib/files/scenarios/mergeInDependentDataStructure.ts

@@ -1,4 +1,3 @@
-// import { writeFile } from 'node:fs/promises';
 import {
   splitOutsideParenthesesAndArrays,
   joinParenthesesAndArrays,
@@ -22,6 +21,25 @@ function cleanFunctionName(functionName: string) {
   return functionName?.split('<')[0];
 }
 
+// Extract the type parameter from a function name, e.g., 'useFetcher<{ data: UserData }>()' -> '{ data: UserData }'
+function getTypeParameter(functionName: string): string | null {
+  if (!functionName) return null;
+  const openBracket = functionName.indexOf('<');
+  if (openBracket === -1) return null;
+  // Find matching closing bracket, accounting for nested brackets
+  let depth = 0;
+  for (let i = openBracket; i < functionName.length; i++) {
+    if (functionName[i] === '<') depth++;
+    else if (functionName[i] === '>') {
+      depth--;
+      if (depth === 0) {
+        return functionName.slice(openBracket + 1, i);
+      }
+    }
+  }
+  return null;
+}
+
 // Check if schemaPathPart matches or is a function call variant of pathPart
 // e.g., 'isEntityBeingAnalyzed(entity.sha)' matches 'isEntityBeingAnalyzed'
 function pathPartMatches(pathPart: string, schemaPathPart: string): boolean {
@@ -75,47 +93,6 @@ export default function mergeInDependentDataStructure({
     };
   };
 }) {
-  // writeFile(
-  //   'mergeInDependentDataStructure-debug.json',
-  //   JSON.stringify(
-  //     {
-  //       importedExports: importedExports.map((d) => ({
-  //         filePath: d.filePath,
-  //         name: d.name,
-  //         isMocked: d.isMocked,
-  //       })),
-  //       dependentAnalyses: Object.keys(dependentAnalyses).reduce(
-  //         (pathAcc: Record<string, any>, filePath) => {
-  //           pathAcc[filePath] = Object.keys(dependentAnalyses[filePath]).reduce(
-  //             (nameAcc, name) => {
-  //               nameAcc[name] = {
-  //                 metadata: {
-  //                   mergedDataStructure:
-  //                     dependentAnalyses[filePath][name].metadata
-  //                       .mergedDataStructure,
-  //                 },
-  //               };
-  //               return nameAcc;
-  //             },
-  //             {} as { [name: string]: {
-  //               metadata?: {
-  //                 mergedDataStructure?: ReadonlyAnalysis['metadata']['mergedDataStructure'];
-  //               };
-  //             } },
-  //           );
-  //           return pathAcc;
-  //         },
-  //         {},
-  //       ),
-  //       rootScopeName,
-  //       dataStructure,
-  //       dependencySchemas,
-  //     },
-  //     null,
-  //     2,
-  //   ),
-  // ).catch(() => {});
-
   const mergedDataStructure: Omit<
     DataStructure,
     'equivalentSignatureVariables'
@@ -128,6 +105,44 @@ export default function mergeInDependentDataStructure({
     environmentVariables: [...(dataStructure.environmentVariables || [])],
   };
 
+  // Build a set of functions that have multiple DIFFERENT type parameters.
+  // For these functions, we must NOT normalize paths to avoid merging different schemas.
+  // e.g., if we have both useFetcher<{ data: UserData }>() and useFetcher<{ data: ConfigData }>(),
+  // they must stay separate and not both become 'returnValue'.
+  const functionsWithMultipleTypeParams = new Set<string>();
+  const typeParamsByFunction: Record<string, Set<string>> = {};
+
+  // Helper to scan a schema for type parameters
+  const scanSchemaForTypeParams = (schema: { [key: string]: string }) => {
+    for (const schemaPath of Object.keys(schema ?? {})) {
+      const parts = splitOutsideParenthesesAndArrays(schemaPath);
+      if (parts.length > 0) {
+        const firstPart = parts[0];
+        const typeParam = getTypeParameter(firstPart);
+        if (typeParam) {
+          const baseName = cleanFunctionName(firstPart);
+          typeParamsByFunction[baseName] ||= new Set();
+          typeParamsByFunction[baseName].add(typeParam);
+          if (typeParamsByFunction[baseName].size > 1) {
+            functionsWithMultipleTypeParams.add(baseName);
+          }
+        }
+      }
+    }
+  };
+
+  // Scan the root entity's schema
+  scanSchemaForTypeParams(dataStructure.returnValueSchema);
+
+  // Also scan all dependency schemas for type parameters
+  for (const filePath of Object.keys(dependencySchemas ?? {})) {
+    for (const name of Object.keys(dependencySchemas[filePath] ?? {})) {
+      scanSchemaForTypeParams(
+        dependencySchemas[filePath][name]?.returnValueSchema,
+      );
+    }
+  }
+
   let equivalentSchemaPaths: {
     equivalentRoots: {
       schemaRootPath: string;
@@ -186,6 +201,15 @@ export default function mergeInDependentDataStructure({
       const pathParts = splitOutsideParenthesesAndArrays(path);
       if (pathParts.length > 1) {
         if (pathParts[1].startsWith('functionCallReturnValue')) {
+          // Check if this function has multiple DIFFERENT type parameters.
+          // If so, DON'T normalize to returnValue - keep the full path to avoid
+          // merging different type-parameterized variants together.
+          // e.g., useFetcher<{ data: UserData }>().functionCallReturnValue.data
+          // should NOT be merged with useFetcher<{ data: ConfigData }>().functionCallReturnValue.data
+          const baseName = cleanFunctionName(pathParts[0]);
+          if (functionsWithMultipleTypeParams.has(baseName)) {
+            return path; // Keep the original path with type parameters
+          }
           // functionCallReturnValue immediately follows - normalize to returnValue
           // e.g., useAuth().functionCallReturnValue.user -> returnValue.user
           return joinParenthesesAndArrays([
@@ -325,10 +349,14 @@ export default function mergeInDependentDataStructure({
                 splitOutsideParenthesesAndArrays(schemaPath);
 
               if (schemaPathParts[0].startsWith(functionName)) {
-                schemaPathParts =
-                  schemaPathParts[1] === 'functionCallReturnValue'
-                    ? ['returnValue', ...schemaPathParts.slice(2)]
-                    : schemaPathParts.slice(1);
+                // Only normalize if the function doesn't have multiple different type parameters
+                const baseName = cleanFunctionName(schemaPathParts[0]);
+                if (!functionsWithMultipleTypeParams.has(baseName)) {
+                  schemaPathParts =
+                    schemaPathParts[1] === 'functionCallReturnValue'
+                      ? ['returnValue', ...schemaPathParts.slice(2)]
+                      : schemaPathParts.slice(1);
+                }
               }
 
               if (schemaPathParts.length < pathParts.length) continue;
@@ -398,6 +426,7 @@ export default function mergeInDependentDataStructure({
                   const postfix = joinParenthesesAndArrays(
                     schemaPathParts.slice(matchedUpToIndex),
                   );
+
                   entry.equivalentPostfixes[postfix] = entry
                     .equivalentPostfixes[postfix]
                     ? bestValueFromOptions([
@@ -480,6 +509,47 @@ export default function mergeInDependentDataStructure({
   const mergeAllEquivalentSchemaPaths = () => {
     const mergedEquivalentSchemaPaths: typeof equivalentSchemaPaths = [];
 
+    // Pre-pass: Connect entries with array/array-element relationships.
+    // This handles cases like:
+    // - Entry A has root 'surveys' (array)
+    // - Entry B has root 'surveys[]' (array element)
+    // These need to be connected so Entry B's field postfixes flow to Entry A.
+    // We do this before the main merge to ensure the connection happens regardless
+    // of processing order.
+    for (const esp of equivalentSchemaPaths) {
+      for (const root of esp.equivalentRoots) {
+        if (root.schemaRootPath.endsWith('[]')) {
+          // Find a matching parent entry with the base array path
+          const baseArrayPath = root.schemaRootPath.slice(0, -2);
+          const parentEntry = equivalentSchemaPaths.find(
+            (other) =>
+              other !== esp &&
+              other.equivalentRoots.some(
+                (otherRoot) =>
+                  otherRoot.schemaRootPath === baseArrayPath &&
+                  otherRoot.function?.name === root.function?.name &&
+                  otherRoot.function?.filePath === root.function?.filePath,
+              ),
+          );
+          if (parentEntry) {
+            // Add transformed postfixes from child (array element) to parent (array)
+            // so they can be applied with [] prefix to parent paths
+            for (const [postfixPath, postfixValue] of Object.entries(
+              esp.equivalentPostfixes,
+            )) {
+              const transformedPostfix = joinParenthesesAndArrays(
+                ['[]', postfixPath].filter(Boolean),
+              );
+              if (!(transformedPostfix in parentEntry.equivalentPostfixes)) {
+                parentEntry.equivalentPostfixes[transformedPostfix] =
+                  postfixValue;
+              }
+            }
+          }
+        }
+      }
+    }
+
     const findEquivalentSchemaPathEntry = (
       schemaSubPath: string,
       equivalentRootFunction: (typeof equivalentSchemaPaths)[0]['equivalentRoots'][0]['function'],
@@ -673,6 +743,7 @@ export default function mergeInDependentDataStructure({
           equivalentRoot.schemaRootPath,
           relevantPostfix,
         ]);
+
         schema[newSchemaPath] = postfixValue;
       }
 
@@ -680,6 +751,77 @@ export default function mergeInDependentDataStructure({
     }
   }
 
+  // Propagate equivalency-derived attributes to generic function call variants.
+  // When attributes are traced via equivalencies (e.g., fileComparisons from buildDataMap.signature[2]),
+  // they get written to non-generic paths (returnValue.data.x or funcName().functionCallReturnValue.data.x).
+  // If the ORIGINAL input schema has generic variants (funcName<T>().functionCallReturnValue.data),
+  // we need to copy the attributes to those paths too.
+  for (const filePath in mergedDataStructure.dependencySchemas) {
+    for (const depName in mergedDataStructure.dependencySchemas[filePath]) {
+      const depSchema =
+        mergedDataStructure.dependencySchemas[filePath][depName];
+      const returnValueSchema = depSchema.returnValueSchema;
+
+      // Look at the ORIGINAL input dependencySchemas for generic variants,
+      // since the merged schema may have lost them during equivalency processing
+      const originalSchema = dependencySchemas?.[filePath]?.[depName];
+      const schemaToSearchForGenericVariants =
+        originalSchema?.returnValueSchema || returnValueSchema;
+
+      // Find all unique generic variants of this function
+      // e.g., useFetcher<BranchEntityDiffResult>() from useFetcher<BranchEntityDiffResult>().functionCallReturnValue.data
+      const genericVariants = new Set<string>();
+      const genericRegex = new RegExp(
+        `^${depName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}<[^>]+>\\(\\)`,
+      );
+
+      for (const path in schemaToSearchForGenericVariants) {
+        const match = path.match(genericRegex);
+        if (match) {
+          genericVariants.add(match[0]);
+        }
+      }
+
+      if (genericVariants.size === 0) continue;
+
+      // For each returnValue. path or non-generic function call path,
+      // create corresponding paths for each generic variant
+      const pathsToAdd: [string, string][] = [];
+
+      for (const path in returnValueSchema) {
+        const value = returnValueSchema[path];
+
+        // Handle returnValue. paths
+        if (path.startsWith('returnValue.')) {
+          const suffix = path.slice('returnValue.'.length);
+          for (const genericVariant of genericVariants) {
+            const genericPath = `${genericVariant}.functionCallReturnValue.${suffix}`;
+            if (!(genericPath in returnValueSchema)) {
+              pathsToAdd.push([genericPath, value]);
+            }
+          }
+        }
+        // Handle non-generic function call paths like depName().functionCallReturnValue.x
+        else if (path.startsWith(`${depName}().functionCallReturnValue.`)) {
+          const suffix = path.slice(
+            `${depName}().functionCallReturnValue.`.length,
+          );
+          for (const genericVariant of genericVariants) {
+            const genericPath = `${genericVariant}.functionCallReturnValue.${suffix}`;
+            if (!(genericPath in returnValueSchema)) {
+              pathsToAdd.push([genericPath, value]);
+            }
+          }
+        }
+      }
+
+      // Add the new generic variant paths
+      for (const [path, value] of pathsToAdd) {
+        returnValueSchema[path] = value;
+      }
+    }
+  }
+
   // For mocked dependencies: copy paths from dependencySchemas (usage info) and normalize
   // returnValue. paths that were created by equivalency processing.
   // This ensures all paths use the consistent functionName().functionCallReturnValue. format.
@@ -695,33 +837,38 @@ export default function mergeInDependentDataStructure({
       name: dependency.name,
     });
 
-    // First, normalize any returnValue. paths that were written by equivalency processing
-    // to the standard functionName().functionCallReturnValue. format.
-    // Also delete returnValue[] artifact paths that don't represent actual array structure.
+    // First, normalize any returnValue paths that were written by equivalency processing
+    // to the standard functionName().functionCallReturnValue format.
+    // This includes both returnValue. (dot) and returnValue[ (array) paths.
     const pathsToNormalize: [string, string][] = [];
-    const pathsToDelete: string[] = [];
     for (const path in depSchema.returnValueSchema) {
-      if (path === 'returnValue' || path.startsWith('returnValue.')) {
+      if (
+        path === 'returnValue' ||
+        path.startsWith('returnValue.') ||
+        path.startsWith('returnValue[')
+      ) {
         pathsToNormalize.push([path, depSchema.returnValueSchema[path]]);
-      } else if (path.match(/^returnValue\[\d*\]/)) {
-        // Delete returnValue[] and returnValue[n] paths - these are artifacts from
-        // equivalency processing and don't represent the actual structure of mocked dependencies.
-        // The correct structure comes from srcSchema (dependencySchemas).
-        pathsToDelete.push(path);
       }
     }
-    for (const path of pathsToDelete) {
-      delete depSchema.returnValueSchema[path];
-    }
     for (const [path, value] of pathsToNormalize) {
       delete depSchema.returnValueSchema[path];
-      const normalizedPath =
-        path === 'returnValue'
-          ? `${dependency.name}().functionCallReturnValue`
-          : path.replace(
-              /^returnValue\./,
-              `${dependency.name}().functionCallReturnValue.`,
-            );
+      let normalizedPath: string;
+      if (path === 'returnValue') {
+        normalizedPath = `${dependency.name}().functionCallReturnValue`;
+      } else if (path.startsWith('returnValue.')) {
+        normalizedPath = path.replace(
+          /^returnValue\./,
+          `${dependency.name}().functionCallReturnValue.`,
+        );
+      } else {
+        // path.startsWith('returnValue[')
+        // e.g., returnValue[] -> getOptions().functionCallReturnValue[]
+        // e.g., returnValue[].label -> getOptions().functionCallReturnValue[].label
+        normalizedPath = path.replace(
+          /^returnValue/,
+          `${dependency.name}().functionCallReturnValue`,
+        );
+      }
       depSchema.returnValueSchema[normalizedPath] = value;
     }
 
@@ -773,11 +920,123 @@ export default function mergeInDependentDataStructure({
           depSchema.returnValueSchema[path] = value;
         }
       }
+
+      // Copy object-typed paths for chained API access patterns (like trpc.customer.getCustomersByOrg)
+      // These intermediate paths are needed for constructMockCode to build the nested mock structure.
+      // Example: for trpc.customer.getCustomersByOrg.useQuery().functionCallReturnValue.data,
+      // we need 'trpc', 'trpc.customer', 'trpc.customer.getCustomersByOrg' all typed as 'object'.
+      // Skip paths starting with 'returnValue' - they were already handled above
+      //
+      // EXCEPTION: For function-style dependencies like getSupabase(), skip intermediate object
+      // paths like 'getSupabase().auth' that are just property access after a function call.
+      // These aren't needed because constructMockCode can infer the structure from the actual
+      // function call paths like 'getSupabase().auth.getUser()'. We only need object paths
+      // for object-style dependencies like 'supabase.auth' where the dependency itself is an object.
+      if (value === 'object' && !path.startsWith('returnValue')) {
+        // Check if this is a function-style dependency (path starts with name() or name<T>())
+        const isFunctionStyleDependency =
+          path.startsWith(`${dependency.name}()`) ||
+          path.match(new RegExp(`^${dependency.name}<[^>]+>\\(\\)`));
+
+        // For function-style dependencies, skip intermediate object paths
+        // Only keep object paths that are within functionCallReturnValue
+        if (
+          isFunctionStyleDependency &&
+          !path.includes('.functionCallReturnValue')
+        ) {
+          continue;
+        }
+
+        if (!(path in depSchema.returnValueSchema)) {
+          depSchema.returnValueSchema[path] = value;
+        }
+      }
     }
 
     cleanSchema(depSchema.returnValueSchema);
   }
 
+  // Process the input dependencySchemas FIRST (before child dependentAnalyses).
+  // This ensures the parent entity's direct usage of dependencies takes precedence.
+  // When both parent and child use the same dependency (e.g., useLoaderData),
+  // the parent's schema paths are preserved, and child's paths are merged in later.
+  //
+  // Some dependencies (like .d.ts type declaration files) may not have:
+  // - Equivalencies with the root scope
+  // - A dependent analysis (they're just type declarations)
+  // - Be marked as mocked
+  // Without this, their schemas would be lost entirely.
+  for (const filePath in dependencySchemas) {
+    for (const name in dependencySchemas[filePath]) {
+      const srcSchema = dependencySchemas[filePath][name];
+      if (!srcSchema) continue;
+
+      // Skip mocked dependencies - they were already processed above with path normalization
+      if (mockedDependencies.has(`${filePath}::${name}`)) {
+        continue;
+      }
+
+      // Check if this dependency was already processed by equivalencies
+      const existingSchema =
+        mergedDataStructure.dependencySchemas[filePath]?.[name];
+
+      // Only add if no existing schema (equivalencies didn't process it)
+      if (!existingSchema) {
+        const depSchema = findOrCreateDependentSchemas({ filePath, name });
+        for (const path in srcSchema.returnValueSchema) {
+          depSchema.returnValueSchema[path] = srcSchema.returnValueSchema[path];
+        }
+        for (const path in srcSchema.signatureSchema) {
+          depSchema.signatureSchema[path] = srcSchema.signatureSchema[path];
+        }
+
+        // Clean known object functions (like String.prototype.replace, Array.prototype.map)
+        // from the copied schema. Without this, method call paths on primitives like
+        // "projectSlug.replace(...)" would cause convertDotNotation to create nested
+        // object structures instead of preserving the primitive type.
+        cleanSchema(depSchema.returnValueSchema);
+      }
+
+      // For functions with multiple different type parameters, also create separate entries
+      // for each type-parameterized variant. This allows gatherDataForMocks to look up
+      // the specific schema for each call signature.
+      // This runs regardless of whether the base entry already existed, since we need
+      // the separate variant entries for proper schema lookup.
+      const baseName = cleanFunctionName(name);
+      if (functionsWithMultipleTypeParams.has(baseName)) {
+        // Find all unique type-parameterized call signatures in the schema
+        const typeParamVariants = new Set<string>();
+        for (const path of Object.keys(srcSchema.returnValueSchema)) {
+          const parts = splitOutsideParenthesesAndArrays(path);
+          if (
+            parts.length > 0 &&
+            parts[0].includes('<') &&
+            parts[0].endsWith(')')
+          ) {
+            typeParamVariants.add(parts[0]);
+          }
+        }
+
+        // Create a separate entry for each type-parameterized variant
+        for (const variant of typeParamVariants) {
+          const variantSchema = findOrCreateDependentSchemas({
+            filePath,
+            name: variant,
+          });
+
+          // Copy only paths that belong to this variant
+          for (const path in srcSchema.returnValueSchema) {
+            if (path.startsWith(variant)) {
+              variantSchema.returnValueSchema[path] =
+                srcSchema.returnValueSchema[path];
+            }
+          }
+          cleanSchema(variantSchema.returnValueSchema);
+        }
+      }
+    }
+  }
+
   // Ensure ALL dependencies from dependentAnalyses are included in dependencySchemas,
   // even if they have no equivalencies with the root scope.
   // This preserves nested functionCallReturnValue paths that would otherwise be lost.
@@ -853,11 +1112,5 @@ export default function mergeInDependentDataStructure({
     }
   }
 
-  // writeFile(
-  //   'mergeInDependentDataStructure-debug-result.json',
-  //   // rootScopeName,
-  //   JSON.stringify(mergedDataStructure, null, 2),
-  // ).catch(() => {});
-
   return mergedDataStructure;
 }

package/analyzer-template/packages/analyze/src/lib/files/setImportedExports.ts

@@ -3,7 +3,7 @@ import { ProjectAnalyzer } from '../ProjectAnalyzer';
 import getImportedExports from './getImportedExports';
 import { getFrameworkForFile, isFrameworkRoute } from '~codeyam/utils';
 import findOrCreateEntity from './analyze/findOrCreateEntity';
-import { generateSha, loadEntities, upsertEntities } from '~codeyam/supabase';
+import { generateSha, loadEntities, upsertEntities } from '~codeyam/database';
 import { AnalysisContext } from '../analysisContext';
 import analyzeFrameworkRoute from './analyzeFrameworkRoute';
 

package/analyzer-template/packages/aws/codebuild/index.ts

@@ -4,3 +4,4 @@ export { default as codebuildCheckProject } from '../src/lib/codebuild/checkForC
 export { default as codebuildCreateProject } from '../src/lib/codebuild/createCodeBuildProject';
 export { default as codebuildTrigger } from '../src/lib/codebuild/triggerCodeBuild';
 export { default as codebuildWaitForBuild } from '../src/lib/codebuild/waitForBuild';
+export type { BuildResult } from '../src/lib/codebuild/waitForBuild';

package/analyzer-template/packages/aws/dist/src/lib/codebuild/waitForBuild.d.ts

@@ -1,2 +1,12 @@
-export default function waitForBuild(buildId: string): Promise<'SUCCEEDED' | 'FAILED' | 'TIMED_OUT'>;
+export interface BuildResult {
+    status: 'SUCCEEDED' | 'FAILED' | 'TIMED_OUT';
+    buildId: string;
+    consoleUrl: string;
+    failedPhase?: {
+        phaseType: string;
+        statusCode?: string;
+        message?: string;
+    };
+}
+export default function waitForBuild(buildId: string): Promise<BuildResult>;
 //# sourceMappingURL=waitForBuild.d.ts.map

package/analyzer-template/packages/aws/dist/src/lib/codebuild/waitForBuild.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"waitForBuild.d.ts","sourceRoot":"","sources":["../../../../src/lib/codebuild/waitForBuild.ts"],"names":[],"mappings":"AAKA,wBAA8B,YAAY,CACxC,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,WAAW,GAAG,QAAQ,GAAG,WAAW,CAAC,CAuD/C"}
+{"version":3,"file":"waitForBuild.d.ts","sourceRoot":"","sources":["../../../../src/lib/codebuild/waitForBuild.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,WAAW,GAAG,QAAQ,GAAG,WAAW,CAAC;IAC7C,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE;QACZ,SAAS,EAAE,MAAM,CAAC;QAClB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB,CAAC;CACH;AAUD,wBAA8B,YAAY,CACxC,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,WAAW,CAAC,CA4DtB"}

package/analyzer-template/packages/aws/dist/src/lib/codebuild/waitForBuild.js

@@ -1,4 +1,11 @@
-import { CodeBuildClient, BatchGetBuildsCommand, } from '@aws-sdk/client-codebuild';
+import { BatchGetBuildsCommand, CodeBuildClient, } from '@aws-sdk/client-codebuild';
+function getConsoleUrl(buildId) {
+    // buildId format: project-name:uuid
+    // ARN format: arn:aws:codebuild:region:account:build/project-name:uuid
+    const region = process.env.AWS_REGION || 'us-east-1';
+    const encodedBuildId = encodeURIComponent(buildId);
+    return `https://${region}.console.aws.amazon.com/codesuite/codebuild/projects/${buildId.split(':')[0]}/build/${encodedBuildId}/log`;
+}
 export default async function waitForBuild(buildId) {
     const codeBuildClient = new CodeBuildClient({});
     let attempts = 0;
@@ -12,31 +19,31 @@ export default async function waitForBuild(buildId) {
         if (!build) {
             throw new Error(`Build ${buildId} not found`);
         }
+        const consoleUrl = getConsoleUrl(buildId);
         switch (build.buildStatus) {
             case 'SUCCEEDED':
-                return 'SUCCEEDED';
+                return { status: 'SUCCEEDED', buildId, consoleUrl };
             case 'FAILED':
             case 'FAULT':
             case 'STOPPED': {
                 // Find the first failed phase
                 const failedPhase = build.phases?.find((phase) => phase.phaseStatus === 'FAILED');
-                if (failedPhase) {
-                    const context = failedPhase.contexts?.[0];
-                    console.log('Build failed:', {
-                        phase: failedPhase.phaseType,
-                        statusCode: context?.statusCode,
-                        message: context?.message,
-                    });
-                    // Also log full phases for debugging if needed
-                    console.log('Full build phases:', build.phases);
-                }
-                else {
-                    console.log('Build failed but no failed phase found:', build.phases);
-                }
-                return 'FAILED';
+                const context = failedPhase?.contexts?.[0];
+                return {
+                    status: 'FAILED',
+                    buildId,
+                    consoleUrl,
+                    failedPhase: failedPhase
+                        ? {
+                            phaseType: failedPhase.phaseType ?? 'UNKNOWN',
+                            statusCode: context?.statusCode,
+                            message: context?.message,
+                        }
+                        : undefined,
+                };
             }
             case 'TIMED_OUT':
-                return 'TIMED_OUT';
+                return { status: 'TIMED_OUT', buildId, consoleUrl };
             case 'IN_PROGRESS':
                 await new Promise((resolve) => setTimeout(resolve, 10000)); // Wait 10 seconds
                 attempts++;
@@ -45,6 +52,10 @@ export default async function waitForBuild(buildId) {
                 throw new Error(`Unknown build status: ${build.buildStatus}`);
         }
     }
-    return 'TIMED_OUT';
+    return {
+        status: 'TIMED_OUT',
+        buildId,
+        consoleUrl: getConsoleUrl(buildId),
+    };
 }
 //# sourceMappingURL=waitForBuild.js.map

package/analyzer-template/packages/aws/dist/src/lib/codebuild/waitForBuild.js.map

@@ -1 +1 @@
-{"version":3,"file":"waitForBuild.js","sourceRoot":"","sources":["../../../../src/lib/codebuild/waitForBuild.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,qBAAqB,GACtB,MAAM,2BAA2B,CAAC;AAEnC,MAAM,CAAC,OAAO,CAAC,KAAK,UAAU,YAAY,CACxC,OAAe;IAEf,MAAM,eAAe,GAAG,IAAI,eAAe,CAAC,EAAE,CAAC,CAAC;IAEhD,IAAI,QAAQ,GAAG,CAAC,CAAC;IACjB,MAAM,WAAW,GAAG,GAAG,CAAC,CAAC,sCAAsC;IAE/D,OAAO,QAAQ,GAAG,WAAW,EAAE,CAAC;QAC9B,MAAM,UAAU,GAAG,IAAI,qBAAqB,CAAC;YAC3C,GAAG,EAAE,CAAC,OAAO,CAAC;SACf,CAAC,CAAC;QAEH,MAAM,MAAM,GAAG,MAAM,eAAe,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QACtD,MAAM,KAAK,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,CAAC;QAEjC,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,MAAM,IAAI,KAAK,CAAC,SAAS,OAAO,YAAY,CAAC,CAAC;QAChD,CAAC;QAED,QAAQ,KAAK,CAAC,WAAW,EAAE,CAAC;YAC1B,KAAK,WAAW;gBACd,OAAO,WAAW,CAAC;YACrB,KAAK,QAAQ,CAAC;YACd,KAAK,OAAO,CAAC;YACb,KAAK,SAAS,CAAC,CAAC,CAAC;gBACf,8BAA8B;gBAC9B,MAAM,WAAW,GAAG,KAAK,CAAC,MAAM,EAAE,IAAI,CACpC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,WAAW,KAAK,QAAQ,CAC1C,CAAC;gBACF,IAAI,WAAW,EAAE,CAAC;oBAChB,MAAM,OAAO,GAAG,WAAW,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,CAAC;oBAC1C,OAAO,CAAC,GAAG,CAAC,eAAe,EAAE;wBAC3B,KAAK,EAAE,WAAW,CAAC,SAAS;wBAC5B,UAAU,EAAE,OAAO,EAAE,UAAU;wBAC/B,OAAO,EAAE,OAAO,EAAE,OAAO;qBAC1B,CAAC,CAAC;oBAEH,+CAA+C;oBAC/C,OAAO,CAAC,GAAG,CAAC,oBAAoB,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;gBAClD,CAAC;qBAAM,CAAC;oBACN,OAAO,CAAC,GAAG,CAAC,yCAAyC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;gBACvE,CAAC;gBACD,OAAO,QAAQ,CAAC;YAClB,CAAC;YACD,KAAK,WAAW;gBACd,OAAO,WAAW,CAAC;YACrB,KAAK,aAAa;gBAChB,MAAM,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,kBAAkB;gBAC9E,QAAQ,EAAE,CAAC;gBACX,MAAM;YACR;gBACE,MAAM,IAAI,KAAK,CAAC,yBAAyB,KAAK,CAAC,WAAW,EAAE,CAAC,CAAC;QAClE,CAAC;IACH,CAAC;IAED,OAAO,WAAW,CAAC;AACrB,CAAC"}
+{"version":3,"file":"waitForBuild.js","sourceRoot":"","sources":["../../../../src/lib/codebuild/waitForBuild.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,qBAAqB,EACrB,eAAe,GAChB,MAAM,2BAA2B,CAAC;AAanC,SAAS,aAAa,CAAC,OAAe;IACpC,oCAAoC;IACpC,uEAAuE;IACvE,MAAM,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,UAAU,IAAI,WAAW,CAAC;IACrD,MAAM,cAAc,GAAG,kBAAkB,CAAC,OAAO,CAAC,CAAC;IACnD,OAAO,WAAW,MAAM,wDAAwD,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,UAAU,cAAc,MAAM,CAAC;AACtI,CAAC;AAED,MAAM,CAAC,OAAO,CAAC,KAAK,UAAU,YAAY,CACxC,OAAe;IAEf,MAAM,eAAe,GAAG,IAAI,eAAe,CAAC,EAAE,CAAC,CAAC;IAEhD,IAAI,QAAQ,GAAG,CAAC,CAAC;IACjB,MAAM,WAAW,GAAG,GAAG,CAAC,CAAC,sCAAsC;IAE/D,OAAO,QAAQ,GAAG,WAAW,EAAE,CAAC;QAC9B,MAAM,UAAU,GAAG,IAAI,qBAAqB,CAAC;YAC3C,GAAG,EAAE,CAAC,OAAO,CAAC;SACf,CAAC,CAAC;QAEH,MAAM,MAAM,GAAG,MAAM,eAAe,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QACtD,MAAM,KAAK,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,CAAC;QAEjC,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,MAAM,IAAI,KAAK,CAAC,SAAS,OAAO,YAAY,CAAC,CAAC;QAChD,CAAC;QAED,MAAM,UAAU,GAAG,aAAa,CAAC,OAAO,CAAC,CAAC;QAE1C,QAAQ,KAAK,CAAC,WAAW,EAAE,CAAC;YAC1B,KAAK,WAAW;gBACd,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,OAAO,EAAE,UAAU,EAAE,CAAC;YACtD,KAAK,QAAQ,CAAC;YACd,KAAK,OAAO,CAAC;YACb,KAAK,SAAS,CAAC,CAAC,CAAC;gBACf,8BAA8B;gBAC9B,MAAM,WAAW,GAAG,KAAK,CAAC,MAAM,EAAE,IAAI,CACpC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,WAAW,KAAK,QAAQ,CAC1C,CAAC;gBACF,MAAM,OAAO,GAAG,WAAW,EAAE,QAAQ,EAAE,CAAC,CAAC,CAAC,CAAC;gBAC3C,OAAO;oBACL,MAAM,EAAE,QAAQ;oBAChB,OAAO;oBACP,UAAU;oBACV,WAAW,EAAE,WAAW;wBACtB,CAAC,CAAC;4BACE,SAAS,EAAE,WAAW,CAAC,SAAS,IAAI,SAAS;4BAC7C,UAAU,EAAE,OAAO,EAAE,UAAU;4BAC/B,OAAO,EAAE,OAAO,EAAE,OAAO;yBAC1B;wBACH,CAAC,CAAC,SAAS;iBACd,CAAC;YACJ,CAAC;YACD,KAAK,WAAW;gBACd,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,OAAO,EAAE,UAAU,EAAE,CAAC;YACtD,KAAK,aAAa;gBAChB,MAAM,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,kBAAkB;gBAC9E,QAAQ,EAAE,CAAC;gBACX,MAAM;YACR;gBACE,MAAM,IAAI,KAAK,CAAC,yBAAyB,KAAK,CAAC,WAAW,EAAE,CAAC,CAAC;QAClE,CAAC;IACH,CAAC;IAED,OAAO;QACL,MAAM,EAAE,WAAW;QACnB,OAAO;QACP,UAAU,EAAE,aAAa,CAAC,OAAO,CAAC;KACnC,CAAC;AACJ,CAAC"}

package/analyzer-template/packages/aws/dist/src/lib/ecs/ecsDefineContainer.d.ts

@@ -1,11 +1,11 @@
 import { ContainerDefinition } from '@aws-sdk/client-ecs';
-export default function ecsDefineContainer({ containerName, containerImage, environmentVariables, openPort, dependsOn, }: {
+export default function ecsDefineContainer({ containerName, containerImage, environmentVariables, openPort, command, }: {
     containerName: string;
     containerImage: string;
     environmentVariables?: {
         [key: string]: string;
     };
     openPort?: number;
-    dependsOn?: ContainerDefinition['dependsOn'];
+    command?: string[];
 }): ContainerDefinition;
 //# sourceMappingURL=ecsDefineContainer.d.ts.map

package/analyzer-template/packages/aws/dist/src/lib/ecs/ecsDefineContainer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ecsDefineContainer.d.ts","sourceRoot":"","sources":["../../../../src/lib/ecs/ecsDefineContainer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAE1D,MAAM,CAAC,OAAO,UAAU,kBAAkB,CAAC,EACzC,aAAa,EACb,cAAc,EACd,oBAAyB,EACzB,QAAQ,EACR,SAAS,GACV,EAAE;IACD,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;IACvB,oBAAoB,CAAC,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAC;IACjD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,mBAAmB,CAAC,WAAW,CAAC,CAAC;CAC9C,GAAG,mBAAmB,CA4BtB"}
+{"version":3,"file":"ecsDefineContainer.d.ts","sourceRoot":"","sources":["../../../../src/lib/ecs/ecsDefineContainer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAE1D,MAAM,CAAC,OAAO,UAAU,kBAAkB,CAAC,EACzC,aAAa,EACb,cAAc,EACd,oBAAyB,EACzB,QAAQ,EACR,OAAO,GACR,EAAE;IACD,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;IACvB,oBAAoB,CAAC,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAC;IACjD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;CACpB,GAAG,mBAAmB,CA4BtB"}

package/analyzer-template/packages/aws/dist/src/lib/ecs/ecsDefineContainer.js

@@ -1,8 +1,9 @@
-export default function ecsDefineContainer({ containerName, containerImage, environmentVariables = {}, openPort, dependsOn, }) {
+export default function ecsDefineContainer({ containerName, containerImage, environmentVariables = {}, openPort, command, }) {
     return {
         name: containerName,
         image: containerImage,
         essential: true,
+        command,
         environment: Object.entries(environmentVariables).map(([name, value]) => ({
             name,
             value,
@@ -24,7 +25,6 @@ export default function ecsDefineContainer({ containerName, containerImage, envi
                 'awslogs-stream-prefix': `${process.env.ECS_CLUSTER_NAME}`,
             },
         },
-        dependsOn,
     };
 }
 //# sourceMappingURL=ecsDefineContainer.js.map

package/analyzer-template/packages/aws/dist/src/lib/ecs/ecsDefineContainer.js.map

@@ -1 +1 @@
-{"version":3,"file":"ecsDefineContainer.js","sourceRoot":"","sources":["../../../../src/lib/ecs/ecsDefineContainer.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,OAAO,UAAU,kBAAkB,CAAC,EACzC,aAAa,EACb,cAAc,EACd,oBAAoB,GAAG,EAAE,EACzB,QAAQ,EACR,SAAS,GAOV;IACC,OAAO;QACL,IAAI,EAAE,aAAa;QACnB,KAAK,EAAE,cAAc;QACrB,SAAS,EAAE,IAAI;QACf,WAAW,EAAE,MAAM,CAAC,OAAO,CAAC,oBAAoB,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC;YACxE,IAAI;YACJ,KAAK;SACN,CAAC,CAAC;QACH,YAAY,EAAE,QAAQ;YACpB,CAAC,CAAC;gBACE;oBACE,aAAa,EAAE,QAAQ;oBACvB,QAAQ,EAAE,QAAQ;iBACnB;aACF;YACH,CAAC,CAAC,SAAS;QACb,gBAAgB,EAAE;YAChB,SAAS,EAAE,SAAS;YACpB,OAAO,EAAE;gBACP,sBAAsB,EAAE,MAAM;gBAC9B,eAAe,EAAE,kBAAkB,OAAO,CAAC,GAAG,CAAC,uBAAuB,EAAE;gBACxE,gBAAgB,EAAE,WAAW;gBAC7B,uBAAuB,EAAE,GAAG,OAAO,CAAC,GAAG,CAAC,gBAAgB,EAAE;aAC3D;SACF;QACD,SAAS;KACV,CAAC;AACJ,CAAC"}
+{"version":3,"file":"ecsDefineContainer.js","sourceRoot":"","sources":["../../../../src/lib/ecs/ecsDefineContainer.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,OAAO,UAAU,kBAAkB,CAAC,EACzC,aAAa,EACb,cAAc,EACd,oBAAoB,GAAG,EAAE,EACzB,QAAQ,EACR,OAAO,GAOR;IACC,OAAO;QACL,IAAI,EAAE,aAAa;QACnB,KAAK,EAAE,cAAc;QACrB,SAAS,EAAE,IAAI;QACf,OAAO;QACP,WAAW,EAAE,MAAM,CAAC,OAAO,CAAC,oBAAoB,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC;YACxE,IAAI;YACJ,KAAK;SACN,CAAC,CAAC;QACH,YAAY,EAAE,QAAQ;YACpB,CAAC,CAAC;gBACE;oBACE,aAAa,EAAE,QAAQ;oBACvB,QAAQ,EAAE,QAAQ;iBACnB;aACF;YACH,CAAC,CAAC,SAAS;QACb,gBAAgB,EAAE;YAChB,SAAS,EAAE,SAAS;YACpB,OAAO,EAAE;gBACP,sBAAsB,EAAE,MAAM;gBAC9B,eAAe,EAAE,kBAAkB,OAAO,CAAC,GAAG,CAAC,uBAAuB,EAAE;gBACxE,gBAAgB,EAAE,WAAW;gBAC7B,uBAAuB,EAAE,GAAG,OAAO,CAAC,GAAG,CAAC,gBAAgB,EAAE;aAC3D;SACF;KACF,CAAC;AACJ,CAAC"}