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

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

@@ -11,6 +11,7 @@ import type {
 import validateJson from './validateJson';
 import { awsLog, awsLogDebugLevel } from '~codeyam/utils';
 import { AI, parseJsonSafe } from '~codeyam/ai';
+import convertNullToUndefinedBySchema from './dataStructure/helpers/convertNullToUndefinedBySchema';
 
 const DEFAULT_SCENARIO_NAME = 'Default Scenario';
 
@@ -144,8 +145,9 @@ export async function generateDataForScenario({
 
   if (structure.dataForMocks && !fullScenarioData.data.argumentsData) {
     fullScenarioData.data.argumentsData = [];
-    if (structure.arguments && !fullScenarioData.data.argumentsData) {
-      fullScenarioData.data.argumentsData = [];
+    // Populate argumentsData from structure.arguments using top-level data values
+    // Bug fix: removed redundant !argumentsData check that was always false after setting to []
+    if (structure.arguments) {
       for (let i = 0; i < structure.arguments.length; ++i) {
         if (!fullScenarioData.data.argumentsData[i]) {
           fullScenarioData.data.argumentsData[i] = {};
@@ -166,6 +168,27 @@ export async function generateDataForScenario({
     }
   }
 
+  // Convert null values to undefined based on schema type constraints.
+  // LLM uses null for "no value" (JSON doesn't support undefined), but TypeScript
+  // types like "string | undefined" don't accept null. This converts null→undefined
+  // for fields typed as "T | undefined" (but preserves null for "T | null").
+  if (structure.dataForMocks && fullScenarioData.data.mockData) {
+    convertNullToUndefinedBySchema(
+      fullScenarioData.data.mockData,
+      structure.dataForMocks,
+    );
+  }
+  if (structure.arguments && fullScenarioData.data.argumentsData) {
+    for (let i = 0; i < fullScenarioData.data.argumentsData.length; i++) {
+      if (structure.arguments[i]) {
+        convertNullToUndefinedBySchema(
+          fullScenarioData.data.argumentsData[i],
+          structure.arguments[i],
+        );
+      }
+    }
+  }
+
   return {
     scenarioData: fullScenarioData,
     llmCall: { name: scenario.name, id: llmCall.id },
@@ -285,7 +308,7 @@ export const generateSystemMessage = (
     ? `## Default Scenario
 Generate COMPLETE, robust data for the entire data structure.
 - Fill ALL fields with realistic values (except error attributes and key attributes set to null or undefined)
-- Arrays should have 2-3 items
+- Arrays should have 3-5 items to provide realistic test data variety
 - Don't skip nested attributes unless the key attributes specify a parent attribute should be null or undefined
 - This provides the baseline data for all other scenarios`
     : `## Non-Default Scenario
@@ -317,26 +340,19 @@ Use for relative dates. Code runs in Node (no browser APIs, no external librarie
 \`\`\`
 Use simple elements only (\`<div>\`, \`<span>\`). No custom components.
 
-## Mock Data Keys
-**CRITICAL: Use keys EXACTLY as provided in the structure. Do NOT change key formats.**
-
-Keys use the canonical format: \`EntityName::hookName::index\`
-\`\`\`json
-{
-  "mockData": {
-    "DashboardPage::useLoaderData::0": { "user": { "name": "John" } },
-    "DashboardPage::useFetcher::0": { "data": null, "state": "idle" },
-    "DashboardPage::useFetcher::1": { "data": { "reportId": "abc123" } }
-  }
-}
-\`\`\`
-
-The format is deterministic:
-- \`EntityName\` - the component name
-- \`hookName\` - the function/hook being called
-- \`index\` - distinguishes multiple calls to the same hook (0, 1, 2...)
+### Arrays
+- Arrays should have many items (at least 4) unless specified otherwise
+- Each item must follow the exact structure provided
+- In general we want robust data, not minimal data unless specified otherwise
 
-**You MUST use the exact keys provided in the structure. Do NOT substitute variable names or use alternative formats.**
+## CRITICAL: Preserve Exact Structure
+Your response MUST mirror the EXACT nested structure provided in mockData Structure.
+- Do NOT reorganize, split, or create duplicate keys
+- The hierarchy of nested objects must match exactly what was provided unless overridden by scenario rules
+- Only change the leaf VALUES (replacing type descriptions like "string" with actual data like "hello")
+- Copy the key strings EXACTLY from the structure
+- Do NOT modify type parameters, arguments, or any part of the key
+- The keys preserve the exact function call as written in the original code
 
 ## Response Format
 \`\`\`json
@@ -354,7 +370,7 @@ The format is deterministic:
 ## Rules
 - Valid JSON only—no raw code outside markers
 - No \`undefined\`—use \`null\` or omit
-- No data references (can't use \`posts[0]\` elsewhere—duplicate the value)
+- No data references (can't use \`posts[0]\` elsewhere — duplicate the value)
 - Scenario name must match exactly: "${scenarioName}"
 - Empty mockData: \`{}\`, empty argumentsData: \`[]\`
 `;

package/analyzer-template/packages/ai/src/lib/promptGenerators/generateChangesEntityScenariosGenerator.ts

@@ -7,12 +7,18 @@ import {
 } from '~codeyam/types';
 import gatherRelevantDependentKeyAttributes from '../gatherRelevantDependentKeyAttributes';
 
+interface ModifiedKeyAttribute {
+  keyAttribute: Analysis['metadata']['keyAttributes'][0];
+  newSourceLocations: Analysis['metadata']['keyAttributes'][0]['sourceLocations'];
+}
+
 interface GenerateChangesEntityScenariosGeneratorArgs {
   entity: Pick<Entity, 'name' | 'code' | 'metadata'>;
   mergedDataStructure: Omit<DataStructure, 'equivalentSignatureVariables'>;
   keyAttributes: Analysis['metadata']['keyAttributes'];
   addedKeyAttributes: Analysis['metadata']['keyAttributes'];
   removedKeyAttributes: Analysis['metadata']['keyAttributes'];
+  modifiedKeyAttributes?: ModifiedKeyAttribute[];
   dependentAnalyses: ReadonlyAnalysisMap;
   existingScenarios: Scenario[];
   commitDiff: string;
@@ -26,6 +32,7 @@ export default function generateChangesEntityScenariosGenerator({
   keyAttributes,
   addedKeyAttributes,
   removedKeyAttributes,
+  modifiedKeyAttributes,
   dependentAnalyses,
   existingScenarios,
   commitDiff,
@@ -98,6 +105,25 @@ export default function generateChangesEntityScenariosGenerator({
       ? JSON.stringify(removedKeyAttributes, null, 2)
       : 'None';
 
+  // Format modified key attributes to highlight new usages
+  const modifiedSection =
+    modifiedKeyAttributes && modifiedKeyAttributes.length > 0
+      ? JSON.stringify(
+          modifiedKeyAttributes.map((mod) => ({
+            localVariable: mod.keyAttribute.internalPath,
+            dataStructurePath: mod.keyAttribute.dataStructurePath,
+            description: mod.keyAttribute.description,
+            newCodeUsages: mod.newSourceLocations?.map((loc) => ({
+              line: loc.lineNumber,
+              code: loc.codeSnippet,
+              context: loc.description,
+            })),
+          })),
+          null,
+          2,
+        )
+      : 'None';
+
   const changedFieldsSection =
     changedDataStructureFields.length > 0
       ? `
@@ -197,6 +223,12 @@ ${addedSection}
 \`\`\`json
 ${removedSection}
 \`\`\`
+
+## Key Attributes with New Usages
+These existing key attributes have NEW code usages that may warrant new or updated scenarios:
+\`\`\`json
+${modifiedSection}
+\`\`\`
 ${changedFieldsSection}
 ## Current Key Attributes
 \`\`\`json

package/analyzer-template/packages/analyze/src/lib/FileAnalyzer.ts

@@ -846,6 +846,20 @@ export class FileAnalyzer {
     return getEntityType({ entityName, sourceFile: this.sourceFile });
   }
 
+  /**
+   * Checks if the entity (function/component) is async.
+   * Async functions in Next.js are Server Components that need special handling.
+   */
+  isEntityAsync(entityName: string): boolean {
+    if (!this.sourceFile) return false;
+    const entityNode = lib.asts.sourceFiles.getEntityNode({
+      entityName,
+      sourceFile: this.sourceFile,
+    });
+    if (!entityNode) return false;
+    return lib.asts.nodes.isAsyncFunction(entityNode);
+  }
+
   getEntityStartAndEnd(entityName: string): { start: number; end: number } {
     if (!this.sourceFile) return { start: 0, end: 0 };
     const node = this.getAllEntityNodes()[entityName];

package/analyzer-template/packages/analyze/src/lib/asts/nodes/index.ts

@@ -7,6 +7,7 @@ export { getCallExpressionNames } from './getCallExpressionNames';
 export { getNodeType } from './getNodeType';
 export { getFunctionNodeType } from './getFunctionNodeType';
 export { isDefaultExport } from './isDefaultExport';
+export { isAsyncFunction } from './isAsyncFunction';
 
 interface ImportInfo {
   packageName: string;

package/analyzer-template/packages/analyze/src/lib/asts/nodes/isAsyncFunction.ts

@@ -0,0 +1,67 @@
+import ts from 'typescript';
+
+/**
+ * Checks if a node represents an async function or component.
+ * This includes:
+ * - Function declarations with async modifier
+ * - Arrow functions with async modifier
+ * - Variable declarations initialized with async functions
+ * - Method declarations with async modifier
+ */
+export function isAsyncFunction(node: ts.Node): boolean {
+  if (!node) return false;
+
+  // Direct function declaration: async function foo() {}
+  if (ts.isFunctionDeclaration(node)) {
+    return hasAsyncModifier(node);
+  }
+
+  // Arrow function: const foo = async () => {}
+  if (ts.isArrowFunction(node)) {
+    return hasAsyncModifier(node);
+  }
+
+  // Function expression: const foo = async function() {}
+  if (ts.isFunctionExpression(node)) {
+    return hasAsyncModifier(node);
+  }
+
+  // Method declaration: async method() {}
+  if (ts.isMethodDeclaration(node)) {
+    return hasAsyncModifier(node);
+  }
+
+  // Variable declaration: const foo = async () => {} or const foo = async function() {}
+  if (ts.isVariableDeclaration(node) && node.initializer) {
+    return isAsyncFunction(node.initializer);
+  }
+
+  // Variable statement: export const foo = async () => {}
+  if (ts.isVariableStatement(node)) {
+    for (const decl of node.declarationList.declarations) {
+      if (decl.initializer && isAsyncFunction(decl.initializer)) {
+        return true;
+      }
+    }
+  }
+
+  // Export assignment: export default async function() {}
+  if (ts.isExportAssignment(node) && node.expression) {
+    return isAsyncFunction(node.expression);
+  }
+
+  return false;
+}
+
+function hasAsyncModifier(
+  node:
+    | ts.FunctionDeclaration
+    | ts.ArrowFunction
+    | ts.FunctionExpression
+    | ts.MethodDeclaration,
+): boolean {
+  if (!node.modifiers) return false;
+  return node.modifiers.some(
+    (modifier) => modifier.kind === ts.SyntaxKind.AsyncKeyword,
+  );
+}

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

@@ -104,6 +104,13 @@ export default async function prepareEntityDataStructures(
                 }
               }
 
+              // LOGGING: Track dependencySchemas entity names for debugging :: format issues
+              const allEntityNames: string[] = [];
+              for (const filePath in clonedDependencySchemas) {
+                for (const entityName in clonedDependencySchemas[filePath]) {
+                  allEntityNames.push(`${filePath}:${entityName}`);
+                }
+              }
               entity.metadata.isolatedDataStructure = {
                 signatureSchema: deduplicateFunctionSchemas(
                   isolatedDataStructure.signatureSchema,
@@ -185,17 +192,11 @@ export default async function prepareEntityDataStructures(
             importedExport.isMocked === true ||
             importedExport.isMocked === false
           ) {
-            console.log(
-              `CodeYam: [${entity.name}] SKIP ${importedExport.name} - already has isMocked=${importedExport.isMocked}`,
-            );
             continue;
           }
 
           // Never mock visual components - they render UI and should use real implementation
           if (importedExport.entityType === 'visual') {
-            console.log(
-              `CodeYam: [${entity.name}] SKIP ${importedExport.name} - visual component, setting isMocked=false`,
-            );
             importedExport.isMocked = false;
             continue;
           }
@@ -213,23 +214,8 @@ export default async function prepareEntityDataStructures(
           const isServerOnly = importedFileContent
             ? isServerOnlyFile(importedFileContent)
             : false;
-          console.log(
-            `CodeYam: [${entity.name}] CHECK ${importedExport.name} from ${importedFilePath}:`,
-            {
-              hasFileAnalyzer: !!importedFileAnalyzer,
-              hasSourceFile: !!importedFileAnalyzer?.sourceFile,
-              hasFileContent: !!importedFileContent,
-              contentFirst50Chars: importedFileContent
-                ?.substring(0, 50)
-                ?.replace(/\n/g, '\\n'),
-              isServerOnly,
-            },
-          );
 
           if (importedFileContent && isServerOnly) {
-            console.log(
-              `CodeYam: [${entity.name}] ✓ MARKING ${importedExport.name} as isMocked=true (server-only file detected)`,
-            );
             importedExport.isMocked = true;
             continue;
           }
@@ -240,9 +226,6 @@ export default async function prepareEntityDataStructures(
               dep.entityName === importedExport.name,
           );
           importedExport.isMocked = matchesMockedDep;
-          console.log(
-            `CodeYam: [${entity.name}] ${importedExport.name} isMocked=${matchesMockedDep} (from mockedDependencies)`,
-          );
         }
 
         // Browser globals that should always be mocked (they make network calls)
@@ -328,19 +311,21 @@ async function getEntityDataStructureAndFunctionCalls({
         functionName: importedExport.name,
       });
 
-      // If no signature found, this function doesn't exist in the analysis
-      if (!signatureSchema) {
-        return acc;
-      }
-
       const returnValueSchema = getReturnValue(dataStructure, {
         functionName: importedExport.name,
       });
 
+      // If neither signature nor return value found, this function doesn't exist in the analysis.
+      // We need to check BOTH because hooks like useParams() have no signature (no arguments)
+      // but DO have a return value that needs to be mocked.
+      if (!signatureSchema && !returnValueSchema) {
+        return acc;
+      }
+
       // Clone schemas before deduplication to avoid mutating shared references
       // getReturnValue() and getFunctionSignature() return direct references, so we need
       // to clone them before passing to deduplicateFunctionSchemas (which may mutate)
-      const clonedSignatureSchema = { ...signatureSchema };
+      const clonedSignatureSchema = { ...(signatureSchema ?? {}) };
       const clonedReturnValueSchema = { ...(returnValueSchema ?? {}) };
 
       acc[importedExport.filePath] ||= {};
@@ -365,53 +350,57 @@ async function getEntityDataStructureAndFunctionCalls({
           fc.name.startsWith(importedExport.name + '<'),
       );
 
-      // Track how many times each variable name has been seen across ALL matching calls
-      // This handles the case where multiple parameterized calls (e.g., useFetcher<ConfigData>,
-      // useFetcher<SettingsData>) assign to the same variable name
-      const varNameCounts: Record<string, number> = {};
-
       for (const efc of matchingCalls) {
         // Check if this call has perVariableSchemas (multiple calls with same signature)
+        // This is the destructuring case: const { a, b, c } = useLoaderData()
+        // Instead of creating ::variable qualified keys, merge into a single entry
+        // with the call signature as key and named properties in the schema
         if (efc?.perVariableSchemas) {
+          // Use the call signature as the key (e.g., "useLoaderData<typeof loader>()")
+          const callSignatureKey = efc.callSignature;
+
+          // Merge all variable schemas by prepending the call signature to each path.
+          // perVariableSchemas paths are like "functionCallReturnValue.entities.sha"
+          // We need to prefix them with the call signature to get:
+          // "useLoaderData<typeof loader>().functionCallReturnValue.entities.sha"
+          const mergedReturnValueSchema: Record<string, string> = {};
+
+          // Set the top-level return value as object since it contains named properties
+          mergedReturnValueSchema[
+            `${callSignatureKey}.functionCallReturnValue`
+          ] = 'object';
+
           for (const [varName, perVarSchema] of Object.entries(
             efc.perVariableSchemas,
           )) {
-            // Track occurrences of this variable name
-            const occurrence = varNameCounts[varName] ?? 0;
-            varNameCounts[varName] = occurrence + 1;
-
-            // Use indexed key if variable name is reused (e.g., fetcher, fetcher[1])
-            const indexedVarName =
-              occurrence === 0 ? varName : `${varName}[${occurrence}]`;
-            const qualifiedKey = `${importedExport.name}::${indexedVarName}`;
-            acc[importedExport.filePath][qualifiedKey] = {
-              signatureSchema: deduplicateFunctionSchemas({
-                ...signatureSchema,
-              }),
-              returnValueSchema: deduplicateFunctionSchemas({
-                ...perVarSchema,
-              }),
-              usageEquivalencies:
-                getUsageEquivalencies(dataStructure, importedExport.name) ?? {},
-              sourceEquivalencies:
-                getSourceEquivalencies(dataStructure, importedExport.name) ??
-                {},
-            };
+            for (const [path, type] of Object.entries(perVarSchema)) {
+              // Prepend the call signature to the path
+              // Input: "functionCallReturnValue.entities.sha"
+              // Output: "useLoaderData<typeof loader>().functionCallReturnValue.entities.sha"
+              const rewrittenPath = `${callSignatureKey}.${path}`;
+              mergedReturnValueSchema[rewrittenPath] = type;
+            }
           }
+
+          acc[importedExport.filePath][callSignatureKey] = {
+            signatureSchema: deduplicateFunctionSchemas({
+              ...signatureSchema,
+            }),
+            returnValueSchema: deduplicateFunctionSchemas(
+              mergedReturnValueSchema,
+            ),
+            usageEquivalencies:
+              getUsageEquivalencies(dataStructure, importedExport.name) ?? {},
+            sourceEquivalencies:
+              getSourceEquivalencies(dataStructure, importedExport.name) ?? {},
+          };
         } else if (efc?.receivingVariableNames?.length === 1) {
           // For parameterized calls like useFetcher<UserData>(), each is a separate entry
-          // with a single receivingVariableName. Create a variable-qualified entry using
-          // the specific return value for this parameterized call.
+          // with a single receivingVariableName. Use the call signature as the key.
           const varName = efc.receivingVariableNames[0];
 
-          // Track occurrences of this variable name across all efc entries
-          const occurrence = varNameCounts[varName] ?? 0;
-          varNameCounts[varName] = occurrence + 1;
-
-          // Use indexed key if variable name is reused (e.g., fetcher, fetcher[1])
-          const indexedVarName =
-            occurrence === 0 ? varName : `${varName}[${occurrence}]`;
-          const qualifiedKey = `${importedExport.name}::${indexedVarName}`;
+          // Use the call signature as the key (e.g., "useFetcher<UserData>()")
+          const callSignatureKey = efc.callSignature;
 
           // PREFER perVariableSchemas over getReturnValue() when available
           // perVariableSchemas has the SPECIFIC schema for this parameterized call,
@@ -434,7 +423,7 @@ async function getEntityDataStructureAndFunctionCalls({
             parameterizedReturnValue &&
             Object.keys(parameterizedReturnValue).length > 0
           ) {
-            acc[importedExport.filePath][qualifiedKey] = {
+            acc[importedExport.filePath][callSignatureKey] = {
               signatureSchema: deduplicateFunctionSchemas({
                 ...signatureSchema,
               }),
@@ -557,6 +546,7 @@ async function getEntityDataStructureAndFunctionCalls({
       ) {
         variableNames.push(...aggregatedReceivingVariableNames);
       }
+
       if (variableNames.length > 0) {
         callVariableNames[entityName] = variableNames;
       }
@@ -776,14 +766,28 @@ export function determineMockedDependencies(entity: Entity) {
         entityReturnValueSchema,
       );
 
+      // Check if returnValueSchema is completely empty (no traced calls at all)
+      // This indicates a side-effect function that we couldn't trace
+      const returnValueSchemaEmpty =
+        Object.keys(entityReturnValueSchema ?? {}).length === 0;
+
       const entityShouldBeMocked =
         !onlyHasJsxComponents &&
         (isValidationFn ||
           hasChainedCallsWithNoReturn ||
+          // If entity takes no args AND has return value, it reads from external source
+          // Examples: useParams(), useAuth(), getConfig()
+          (emptySignature && hasReturnValue) ||
+          // If entity takes no args AND returnValueSchema is completely empty,
+          // it's a side-effect function calling external services
+          // Examples: logPageView(), initializeAnalytics(), trackEvent()
+          // NOTE: We don't mock entities that have function markers but no return value
+          // (like React components: FileProvider() has 'function' type but no return data)
+          (emptySignature && returnValueSchemaEmpty) ||
           ((signatureHasFunctions || returnValueHasFunctions) &&
             hasReturnValue &&
-            ((emptySignature && hasReturnValue) ||
-              (!complexSignature && complexReturnValue))));
+            !complexSignature &&
+            complexReturnValue));
 
       if (entityShouldBeMocked) {
         mockedEntities.push({

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

@@ -376,6 +376,12 @@ export default async function analyzeEntities({
             // Circular dependency detected in path - skip
             continue;
           }
+          // If already visited via another traversal path, skip to avoid deadlock.
+          // Its subtree has been fully explored; any leaves are already in leafKeys.
+          // Blocking on it would just propagate the block and cause stuck analysis.
+          if (visited.has(dependentEntityKey)) {
+            continue;
+          }
           isLeaf = false;
           visitEntity(dependentEntity, [...path, dependentEntityKey]);
         }

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

@@ -161,6 +161,9 @@ export default async function findOrCreateEntity({
   const defaultExport = fileAnalyzer.isDefaultExport(entity.name);
   entity.metadata.namedExport = !defaultExport;
 
+  // Detect if the entity is an async function/component (Server Component in Next.js)
+  entity.metadata.isAsync = fileAnalyzer.isEntityAsync(localEntityName);
+
   if (defaultExport) {
     const allEntityNodes = fileAnalyzer.getAllEntityNodes();
     entity.metadata.exportAlias = Object.keys(allEntityNodes).find(

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

@@ -22,6 +22,7 @@ import {
   pushAnalysisError,
   Semaphore,
 } from '~codeyam/utils';
+import deepEqual from '../utils/deepEqual';
 
 export interface AnalyzeChangeArgs {
   previousAnalysis: Analysis;
@@ -133,15 +134,30 @@ export default async function analyzeChange({
       analysis.status.steps.push(keyAttributesStep);
     }
 
-    if (
-      analysis.metadata.scenariosDataStructure ===
-      previousAnalysis.metadata.scenariosDataStructure
-    ) {
+    const dataStructureUnchanged = deepEqual(
+      analysis.metadata.scenariosDataStructure,
+      previousAnalysis.metadata.scenariosDataStructure,
+    );
+
+    const keyAttributesUnchanged = deepEqual(
+      analysis.metadata.keyAttributes,
+      previousAnalysis.metadata.keyAttributes,
+    );
+
+    if (dataStructureUnchanged && keyAttributesUnchanged) {
       awsLogDebugLevel(
         1,
-        `Data structure unchanged, reusing previous scenarios for ${entity.name}...`,
+        `Data structure and key attributes unchanged, reusing previous scenarios for ${entity.name}...`,
       );
-      analysis.scenarios = previousAnalysis.scenarios;
+      // Reuse previous scenarios but mark them for recapture if entity code changed
+      analysis.scenarios = previousAnalysis.scenarios.map((scenario) => ({
+        ...scenario,
+        metadata: {
+          ...scenario.metadata,
+          // Only mark for recapture if entity code actually changed
+          needsRecapture: entityChanged,
+        },
+      }));
     } else {
       if (!steps || steps.includes(Step.Scenarios)) {
         awsLogDebugLevel(1, `Generating scenarios for ${entity.name}...`);

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

@@ -271,13 +271,17 @@ export default async function analyzeEntity({
         });
       }
 
+      // Return early if analysis is already complete for its purpose:
+      // - Full analysis: has analyzedTreeSha
+      // - Dependency analysis: has keyAttributes (Structure + KeyAttributes already ran)
+      const isCompleteDependencyAnalysis =
+        analyzeAsDependency && !!existingAnalysis.metadata?.keyAttributes;
+
       if (
         !force &&
-        !!existingAnalysis.analyzedTreeSha &&
-        existingAnalysis.dependencyAnalyzedTreeSha === dependencyAnalyzedTreeSha //&&
-        // (existingAnalysis.status?.finishedAt ||
-        //   existingAnalysis.status?.readyToBeCaptured ||
-        //   branchCommitSha)
+        existingAnalysis.dependencyAnalyzedTreeSha ===
+          dependencyAnalyzedTreeSha &&
+        (!!existingAnalysis.analyzedTreeSha || isCompleteDependencyAnalysis)
       ) {
         awsLogDebugLevel(1, `Using existing analysis for ${entity.name}...`);
         awsLog('Returning existing analysis', {