@codeyam/codeyam-cli 0.1.0-staging.1669d45 → 0.1.0-staging.323686

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

@@ -16,7 +16,6 @@ import { awsLog } from '~codeyam/utils';
 import gatherDataForMocks from './gatherDataForMocks';
 import enrichArrayTypesFromChildSignatures from './enrichArrayTypesFromChildSignatures';
 import enrichUnknownTypesFromSourceEquivalencies from './enrichUnknownTypesFromSourceEquivalencies';
-
 export interface GenerateDataStructureArgs {
   entity: Entity;
   dependentAnalyses: ReadonlyAnalysisMap;
@@ -256,8 +255,10 @@ export default function generateDataStructure({
           );
 
           if (existingImport) {
-            // Merge callVariableNames if the same dependency exists with different patterns
-            if (imported.callVariableNames && imported.calls) {
+            // Merge calls from child into existing import
+            // Note: Check length > 0 because empty array [] is truthy but has no variable names
+            if (imported.callVariableNames?.length && imported.calls) {
+              // Case 1: Both calls and callVariableNames are set - merge as pairs
               existingImport.calls = existingImport.calls || [];
               existingImport.callVariableNames =
                 existingImport.callVariableNames || [];
@@ -274,6 +275,18 @@ export default function generateDataStructure({
                   existingImport.callVariableNames.push(varName);
                 }
               }
+            } else if (imported.calls) {
+              // Case 2: Only calls are set (no callVariableNames) - common with tRPC
+              // where destructuring like `const { data, isLoading } = trpc.xxx.useQuery()`
+              // doesn't create a variable name for the hook call itself
+              existingImport.calls = existingImport.calls || [];
+
+              // Add each call that doesn't already exist
+              for (const call of imported.calls) {
+                if (!existingImport.calls.includes(call)) {
+                  existingImport.calls.push(call);
+                }
+              }
             }
           } else {
             // Add new import
@@ -527,10 +540,13 @@ export default function generateDataStructure({
 
     // Enrich mocked dependency array types with fields from child component signatures
     // This ensures that when getSurveysAction returns { data: array }, and SurveyCard
-    // expects survey.updatedAt, the array element type includes updatedAt
+    // expects survey.updatedAt, the array element type includes updatedAt.
+    // Uses usageEquivalencies to trace data flow and only enrich arrays with fields
+    // from children that actually receive elements from that specific array.
     enrichArrayTypesFromChildSignatures(
       allImportedExports,
       mergedDataStructure.dependencySchemas,
+      mergedDataStructure.usageEquivalencies,
     );
 
     // Enrich mocked dependency unknown types using sourceEquivalencies
@@ -544,12 +560,33 @@ export default function generateDataStructure({
       allImportedExports,
     );
 
-    const dataForMocks = gatherDataForMocks(
+    let dataForMocks = gatherDataForMocks(
       allImportedExports,
       mergedDataStructure.dependencySchemas,
       { entityName: entity.name },
     );
 
+    // Merge dataForMocks from non-mocked child analyses to include transitive dependency data.
+    // This handles cases where grandchild trpc calls aren't in allImportedExports because
+    // the grandchild's analysis wasn't in dependentAnalyses.
+    //
+    // Issue 19 fix: The child's dataForMocks already contains merged data from its
+    // dependencies (including grandchildren). By merging the child's dataForMocks,
+    // we transitively include all nested dependency data.
+    for (const filePath in nonMockedDependentAnalyses) {
+      for (const name in nonMockedDependentAnalyses[filePath]) {
+        const childAnalysis = nonMockedDependentAnalyses[filePath][name];
+        const childDataForMocks =
+          childAnalysis?.metadata?.scenariosDataStructure?.dataForMocks;
+        if (childDataForMocks && Object.keys(childDataForMocks).length > 0) {
+          dataForMocks = mergeJsonTypeDefinitions(
+            dataForMocks as Record<string, unknown>,
+            childDataForMocks as Record<string, unknown>,
+          ) as { [importAlias: string]: JsonTypeDefinition };
+        }
+      }
+    }
+
     const finalizedArgumentsSchema = fillInDirectSchemaGapsAndUnknowns({
       schema: { ...mergedDataStructure.signatureSchema },
     });

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

@@ -108,7 +108,7 @@ export default async function generateExecutionFlows({
  * then looks them up in importedExports to get their file paths,
  * then retrieves their metadata from dependentAnalyses.
  */
-function buildChildEntityMetadata(
+export function buildChildEntityMetadata(
   entity: Entity,
   dependentAnalyses?: ReadonlyAnalysisMap,
 ): Record<string, Entity['metadata']> {

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

@@ -1134,6 +1134,83 @@ export default function mergeInDependentDataStructure({
     }
 
     cleanSchema(depSchema.returnValueSchema);
+
+    // Pull signature requirements from downstream functions into the mocked return value.
+    // When a mocked function's return flows into another function's signature (via usageEquivalencies),
+    // we need to include that function's signature requirements in the mock.
+    //
+    // Example: fromE5() returns a currency object that flows to calculateTotalPrice(price, quantity).
+    // calculateTotalPrice's signatureSchema shows signature[0].multiply() is required.
+    // We need to add multiply() to fromE5's mock return value.
+    const usageEquivalencies = srcSchema.usageEquivalencies ?? {};
+    for (const [returnPath, equivalencies] of Object.entries(
+      usageEquivalencies,
+    )) {
+      // Only process return value paths (functionCallReturnValue)
+      if (!returnPath.includes('.functionCallReturnValue')) continue;
+
+      for (const equiv of equivalencies) {
+        // Check if this equivalency points to a signature path
+        const signatureMatch = equiv.schemaPath.match(/\.signature\[(\d+)\]$/);
+        if (!signatureMatch) continue;
+
+        const targetFunctionName = cleanFunctionName(equiv.scopeNodeName);
+        const signatureIndex = signatureMatch[1];
+
+        // Look up the target function's analysis to get its signature requirements
+        // First try dependentAnalyses, then dependencySchemas
+        let targetSignatureSchema: Record<string, string> | undefined;
+
+        // Check dependentAnalyses first (has the full merged analysis)
+        for (const depFilePath in dependentAnalyses) {
+          const analysis = dependentAnalyses[depFilePath]?.[targetFunctionName];
+          if (analysis?.metadata?.mergedDataStructure?.signatureSchema) {
+            targetSignatureSchema =
+              analysis.metadata.mergedDataStructure.signatureSchema;
+            break;
+          }
+        }
+
+        // Fallback to dependencySchemas if not found
+        if (!targetSignatureSchema) {
+          for (const depFilePath in dependencySchemas) {
+            const schema = dependencySchemas[depFilePath]?.[targetFunctionName];
+            if (schema?.signatureSchema) {
+              targetSignatureSchema = schema.signatureSchema;
+              break;
+            }
+          }
+        }
+
+        if (!targetSignatureSchema) continue;
+
+        // Find all paths in the target's signatureSchema that extend from signature[N]
+        // e.g., signature[0].multiply(quantity) -> .multiply(quantity)
+        const signaturePrefix = `signature[${signatureIndex}]`;
+        for (const [sigPath, sigType] of Object.entries(
+          targetSignatureSchema,
+        )) {
+          if (!sigPath.startsWith(signaturePrefix)) continue;
+
+          // Skip the base signature[N] path itself - we only want the method/property extensions
+          if (sigPath === signaturePrefix) continue;
+
+          // Extract the suffix after signature[N] (e.g., ".multiply(quantity)")
+          const suffix = sigPath.slice(signaturePrefix.length);
+
+          // Build the path for the mocked return value
+          // e.g., fromE5(priceE5).functionCallReturnValue.multiply(quantity)
+          const returnValuePath = returnPath + suffix;
+
+          // Add to the mocked dependency's return value schema if not already present
+          if (!(returnValuePath in depSchema.returnValueSchema)) {
+            depSchema.returnValueSchema[returnValuePath] = sigType;
+          }
+        }
+      }
+    }
+
+    cleanSchema(depSchema.returnValueSchema);
   }
 
   // Process the input dependencySchemas FIRST (before child dependentAnalyses).

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

@@ -2,6 +2,49 @@ import { splitOutsideParenthesesAndArrays } from '~codeyam/ai';
 import { JsonTypeDefinition, ReadonlyAnalysisMap } from '~codeyam/types';
 import { awsLog } from '~codeyam/utils';
 
+/**
+ * Deep merge for JsonTypeDefinition schemas.
+ * Only recursively merges when BOTH sides are plain objects (not arrays, not primitives).
+ * This is different from the general deepMerge which is designed for data values -
+ * here we're merging type schemas where leaf values are strings like "boolean" or "function".
+ *
+ * When types are incompatible (e.g., array vs object), prefer keeping the base value
+ * since it was set first from the root entity's validatedVariables.
+ */
+function deepMergeSchemas(
+  base: JsonTypeDefinition,
+  override: JsonTypeDefinition,
+): JsonTypeDefinition {
+  // If override is null/undefined, return base
+  if (override === null || override === undefined) return base;
+  // If base is null/undefined, return override
+  if (base === null || base === undefined) return override;
+
+  // Only recursively merge if BOTH are plain objects (not arrays, not primitives)
+  const baseIsPlainObject =
+    typeof base === 'object' && !Array.isArray(base) && base !== null;
+  const overrideIsPlainObject =
+    typeof override === 'object' &&
+    !Array.isArray(override) &&
+    override !== null;
+
+  if (baseIsPlainObject && overrideIsPlainObject) {
+    const result: JsonTypeDefinition = { ...base };
+    for (const key in override) {
+      result[key] = deepMergeSchemas(
+        base[key] as JsonTypeDefinition,
+        override[key] as JsonTypeDefinition,
+      );
+    }
+    return result;
+  }
+
+  // For incompatible types (array vs object, string vs object, etc.), keep base
+  // This ensures the root entity's structure is preserved when a dependency
+  // has a different view of the same mock
+  return base;
+}
+
 export function mergeInStructure(
   name: string | number,
   key: string | number,
@@ -155,10 +198,10 @@ export default function mergeValidatedDataStructures({
       }
       activeValidatedParts = validatedVariables[usedName] as JsonTypeDefinition;
     }
-    dataForMocks = {
-      ...dataForMocks,
-      ...validatedData,
-    };
+    // Use deep merge instead of shallow spread to preserve previously merged
+    // dependency data. This fixes Issue #15 where multiple dependencies with
+    // the same top-level key (e.g., trpc) would overwrite each other.
+    dataForMocks = deepMergeSchemas(dataForMocks, validatedData);
   };
 
   for (const dependency of relevantDependencies) {
@@ -181,13 +224,15 @@ export default function mergeValidatedDataStructures({
     for (const mockName in dependencyDataForMocks) {
       addMockDataForEntity(mockName);
 
-      // If addMockDataForEntity didn't find matching entries in validatedVariables,
-      // copy the dependency's value directly. This handles cases like usePathname()
-      // which returns a simple "string" type but isn't in the root's validatedVariables.
-      if (dataForMocks[mockName] === undefined) {
-        dataForMocks[mockName] = dependencyDataForMocks[
-          mockName
-        ] as JsonTypeDefinition;
+      // Always deep merge the dependency's value to preserve nested structures.
+      // This handles cases like usePathname() which returns a simple "string" type,
+      // AND cases like trpc where both root and dependency have nested data that
+      // needs to be combined (e.g., trpc.quote from root + trpc.fastener.getAttributeValues
+      // from dependency).
+      if (dependencyDataForMocks[mockName] !== undefined) {
+        dataForMocks = deepMergeSchemas(dataForMocks, {
+          [mockName]: dependencyDataForMocks[mockName],
+        } as JsonTypeDefinition);
       }
     }
   }

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

@@ -18,7 +18,7 @@
     "@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/lib-storage": "^3.975.0",
     "@aws-sdk/s3-request-presigner": "^3.940.0",
     "@aws-sdk/util-dynamodb": "^3.971.0"
   }

package/analyzer-template/packages/database/src/lib/kysely/db.ts

@@ -245,7 +245,14 @@ export function getSqliteDatabase(sqlitePath?: string) {
 export function getPostgreDatabase() {
   const connectionString = getPostgresConnectionString();
   console.log(`CodeYam: Using PostgreSQL database at: ${connectionString}`);
-  const pool = new Pool({ connectionString });
+  const pool = new Pool({
+    connectionString,
+    // Session pooler (required for IPv4) holds real Postgres connections,
+    // so keep this low: 10 ECS tasks × 3 = 30 connections max
+    max: 3,
+    // Release idle connections after 10s to free up pool slots
+    idleTimeoutMillis: 10000,
+  });
   pool.on('error', (err: Error, _client: PoolClient) => {
     console.error('CodeYam: Unexpected error on idle PostgreSQL client', err);
   });

package/analyzer-template/packages/database/src/lib/kysely/tables/commitsTable.ts

@@ -33,6 +33,12 @@ export const CommitsTableColumns = Object.keys(
   commitsSchema,
 ) as (keyof CommitsTable)[];
 
+// Lightweight columns list excluding 'files' (which can be 1MB+ for large commits)
+// Use this for queries where file diff data is not needed
+export const CommitsTableColumnsLite = CommitsTableColumns.filter(
+  (col) => col !== 'files',
+) as Exclude<keyof CommitsTable, 'files'>[];
+
 export async function createCommitsTable(db: Kysely<any>): Promise<void> {
   await db.schema
     .createTable('commits')

package/analyzer-template/packages/database/src/lib/loadAnalyses.ts

@@ -27,6 +27,7 @@ function buildAnalysesQuery({
   commitIds,
   branchCommitSha,
   limit,
+  excludeMetadata,
 }: LoadAnalysesArgs & {
   ids?: string[];
   fileIds?: string[];
@@ -37,7 +38,32 @@ function buildAnalysesQuery({
   const { jsonObjectFrom, jsonArrayFrom } = getJsonHelper();
 
   // Create CTE for filtering analyses
-  let filteredAnalysisCTE = db.selectFrom('analyses').selectAll('analyses');
+  // When excludeMetadata is true, select specific columns to avoid loading 64MB+ of metadata
+  let filteredAnalysisCTE = excludeMetadata
+    ? db
+        .selectFrom('analyses')
+        .select([
+          'analyses.id',
+          'analyses.project_id',
+          'analyses.file_id',
+          'analyses.commit_id',
+          'analyses.entity_sha',
+          'analyses.entity_name',
+          'analyses.entity_type',
+          'analyses.file_path',
+          'analyses.status',
+          'analyses.created_at',
+          'analyses.updated_at',
+          'analyses.tree_sha',
+          'analyses.analyzed_tree_sha',
+          'analyses.dependency_analyzed_tree_sha',
+          'analyses.previous_analysis_id',
+          'analyses.branch_commit_sha',
+          'analyses.indirect',
+          'analyses.committed_at',
+          'analyses.completed_at',
+        ])
+    : db.selectFrom('analyses').selectAll('analyses');
 
   // Apply filters
   if (projectId) {
@@ -96,6 +122,35 @@ function buildAnalysesQuery({
   }
 
   // Main query with JSON aggregations referencing the CTE
+  // When excludeMetadata is true, skip the entity subquery (saves loading entity metadata again)
+  if (excludeMetadata) {
+    return db
+      .with('filtered_analyses', () => filteredAnalysisCTE)
+      .selectFrom('filtered_analyses')
+      .selectAll('filtered_analyses')
+      .select((eb: ExpressionBuilder<any, any>) => [
+        // Skip entity subquery - not needed for list views and loads 41MB+ of entity metadata
+
+        jsonArrayFrom(
+          eb
+            .selectFrom('scenarios')
+            .select(aliasedTableColumns('scenarios', ScenariosTableColumns))
+            .whereRef('scenarios.analysis_id', '=', 'filtered_analyses.id'),
+        ).as('scenarios'),
+
+        jsonArrayFrom(
+          eb
+            .selectFrom('analysis_branches')
+            .select(['id', 'branch_id'])
+            .whereRef(
+              'analysis_branches.analysis_id',
+              '=',
+              'filtered_analyses.id',
+            ),
+        ).as('analysis_branches'),
+      ]);
+  }
+
   return db
     .with('filtered_analyses', () => filteredAnalysisCTE)
     .selectFrom('filtered_analyses')
@@ -138,6 +193,8 @@ export interface LoadAnalysesArgs {
   entityShas?: string[];
   branchCommitSha?: string;
   limit?: number;
+  /** Exclude large metadata columns for faster list queries */
+  excludeMetadata?: boolean;
 }
 
 export default async function loadAnalyses(

package/analyzer-template/packages/database/src/lib/loadAnalysis.ts

@@ -45,6 +45,7 @@ export default async function loadAnalysis({
   // TODO: Consider refactoring to use CTE + aliasedTableColumns pattern (Pattern 3)
   // like loadMostRecentPreviousAnalysis for more elegant single-query approach
   const db = getDatabase();
+  const startTime = Date.now();
 
   try {
     // Build the main query
@@ -169,6 +170,8 @@ export default async function loadAnalysis({
     });
 
     const analysis = await query.executeTakeFirst();
+    const queryTime = Date.now() - startTime;
+
     if (!analysis) {
       awsLog('CodeYam Error: Analysis not found', null, {
         id,
@@ -188,6 +191,16 @@ export default async function loadAnalysis({
       return null;
     }
 
+    // DEBUG: Log slow queries (when includeCommitAndBranch=true, includes files column which can be 1MB+)
+    if (queryTime > 100 && includeCommitAndBranch) {
+      const commit = (analysis as any).commit;
+      const filesSize = commit?.files ? JSON.stringify(commit.files).length : 0;
+      console.log(
+        `CodeYam DEBUG: [CommitFilesTiming] loadAnalysis took ${queryTime}ms (files: ${Math.round(filesSize / 1024)}KB)`,
+        { id: analysis.id, entityName: analysis.entity_name },
+      );
+    }
+
     return dbToAnalysis(analysis);
   } catch (error) {
     awsLog('CodeYam Error: Database error loading analysis', error, {

package/analyzer-template/packages/database/src/lib/loadBranch.ts

@@ -98,9 +98,10 @@ async function loadCommitsForBranch(branchId: string): Promise<DbCommit[]> {
   const db = getDatabase();
 
   const { jsonArrayFrom } = getJsonHelper();
+  const startTime = Date.now();
 
   try {
-    return await db
+    const commits = await db
       .selectFrom('commits')
       .selectAll()
       .select((eb: ExpressionBuilder<any, any>) => [
@@ -115,6 +116,20 @@ async function loadCommitsForBranch(branchId: string): Promise<DbCommit[]> {
       .where('commits.branch_id', '=', branchId)
       .orderBy('commits.committed_at', 'desc')
       .execute();
+    const queryTime = Date.now() - startTime;
+
+    // DEBUG: Log slow queries (includes files column which can be 1MB+)
+    if (queryTime > 100) {
+      const totalFilesSize = commits.reduce((sum, c: any) => {
+        return sum + (c.files ? JSON.stringify(c.files).length : 0);
+      }, 0);
+      console.log(
+        `CodeYam DEBUG: [CommitFilesTiming] loadCommitsForBranch took ${queryTime}ms (${commits.length} commits, totalFiles: ${Math.round(totalFilesSize / 1024)}KB)`,
+        { branchId },
+      );
+    }
+
+    return commits;
   } catch (error) {
     awsLog('CodeYam Error: Loading commits for branch', error, { branchId });
     return [];

package/analyzer-template/packages/database/src/lib/loadCommit.ts

@@ -69,6 +69,7 @@ export default async function loadCommit({
   branchId,
 }: LoadCommitArgs) {
   const db = getDatabase();
+  const startTime = Date.now();
 
   try {
     let query = db
@@ -97,6 +98,7 @@ export default async function loadCommit({
     query = query.orderBy('committed_at', 'desc').limit(1);
 
     const commit = await query.executeTakeFirst();
+    const queryTime = Date.now() - startTime;
 
     if (!commit) {
       awsLog('CodeYam Error: Commit not found', null, {
@@ -108,6 +110,15 @@ export default async function loadCommit({
       return null;
     }
 
+    // DEBUG: Log slow queries (includes files column which can be 1MB+)
+    if (queryTime > 100) {
+      const filesSize = commit.files ? JSON.stringify(commit.files).length : 0;
+      console.log(
+        `CodeYam DEBUG: [CommitFilesTiming] loadCommit took ${queryTime}ms (files: ${Math.round(filesSize / 1024)}KB)`,
+        { sha: commit.sha },
+      );
+    }
+
     // Load branch and mergedBranch separately
     const [branch, mergedBranch, analyses] = await Promise.all([
       commit.branch_id

package/analyzer-template/packages/database/src/lib/loadCommits.ts

@@ -19,6 +19,8 @@ interface LoadCommitsArgs {
   shas?: string[];
   fileNames?: string[];
   limit?: number;
+  /** Skip loading related data (analyses, entities, branches) for faster queries */
+  skipRelations?: boolean;
 }
 
 async function loadBranchesForCommits(
@@ -137,6 +139,7 @@ export default async function loadCommits({
   shas,
   fileNames,
   limit = 10,
+  skipRelations = false,
 }: LoadCommitsArgs): Promise<Commit[]> {
   if (!projectId && !ids) {
     throw new Error('Must provide projectId or ids');
@@ -144,6 +147,7 @@ export default async function loadCommits({
 
   const db = getDatabase();
   const { jsonObjectFrom } = getJsonHelper();
+  const startTime = Date.now();
 
   try {
     let query = db
@@ -203,11 +207,35 @@ export default async function loadCommits({
       .orderBy('committed_at', 'desc')
       .limit(limit)
       .execute();
+    const queryTime = Date.now() - startTime;
 
     if (!commits || commits.length === 0) {
       return [];
     }
 
+    // DEBUG: Log slow queries (includes files column which can be 1MB+)
+    if (queryTime > 100) {
+      const totalFilesSize = commits.reduce((sum, c: any) => {
+        return sum + (c.files ? JSON.stringify(c.files).length : 0);
+      }, 0);
+      console.log(
+        `CodeYam DEBUG: [CommitFilesTiming] loadCommits took ${queryTime}ms (${commits.length} commits, totalFiles: ${Math.round(totalFilesSize / 1024)}KB)`,
+      );
+    }
+
+    // When skipRelations is true, just return commits without loading related data
+    // This is much faster for queries that only need commit metadata
+    if (skipRelations) {
+      const dbCommits: DbCommit[] = commits.map((commit: any) => ({
+        ...commit,
+        branch: undefined,
+        mergedBranch: undefined,
+        analyses: [],
+        entities: [],
+      }));
+      return dbCommits.map(dbToCommit);
+    }
+
     const commitIds = commits.map((c: any) => c.id);
 
     // Load all relations in parallel

package/analyzer-template/packages/database/src/lib/loadEntities.ts

@@ -9,6 +9,8 @@ export interface LoadEntitiesArgs {
   filePaths?: string[];
   names?: string[];
   shas?: string[];
+  /** Exclude large metadata column for faster list queries */
+  excludeMetadata?: boolean;
 }
 
 export default async function loadEntities({
@@ -18,6 +20,7 @@ export default async function loadEntities({
   filePaths,
   names,
   shas,
+  excludeMetadata,
 }: LoadEntitiesArgs): Promise<Entity[] | null> {
   if (
     (fileIds && fileIds.length == 0) ||
@@ -39,6 +42,7 @@ export default async function loadEntities({
         filePaths,
         names,
         shas: chunk,
+        excludeMetadata,
       });
 
       if (chunkEntities) {
@@ -51,9 +55,28 @@ export default async function loadEntities({
   const db = getDatabase();
 
   try {
-    const query = db
-      .selectFrom('entities')
-      .selectAll('entities')
+    // When excludeMetadata is true, select all columns except the large metadata column
+    // This dramatically speeds up list queries (41MB+ of JSON avoided)
+    const baseQuery = excludeMetadata
+      ? db
+          .selectFrom('entities')
+          .select([
+            'entities.project_id',
+            'entities.file_id',
+            'entities.commit_id',
+            'entities.name',
+            'entities.sha',
+            'entities.entity_type',
+            'entities.file_path',
+            'entities.description',
+            'entities.documentation',
+            'entities.quality',
+            'entities.created_at',
+            'entities.updated_at',
+          ])
+      : db.selectFrom('entities').selectAll('entities');
+
+    const query = baseQuery
       .$if(!!branchId, (qb) =>
         qb
           .innerJoin(

package/analyzer-template/packages/database/src/lib/loadEntityBranches.ts

@@ -121,6 +121,7 @@ async function loadCommitsForEntities(
   const db = getDatabase();
 
   const { jsonArrayFrom } = getJsonHelper();
+  const startTime = Date.now();
 
   try {
     const commits = await db
@@ -137,6 +138,17 @@ async function loadCommitsForEntities(
       ])
       .where('commits.id', 'in', commitIds)
       .execute();
+    const queryTime = Date.now() - startTime;
+
+    // DEBUG: Log slow queries (includes files column which can be 1MB+)
+    if (queryTime > 100) {
+      const totalFilesSize = commits.reduce((sum, c: any) => {
+        return sum + (c.files ? JSON.stringify(c.files).length : 0);
+      }, 0);
+      console.log(
+        `CodeYam DEBUG: [CommitFilesTiming] loadCommitsForEntities took ${queryTime}ms (${commits.length} commits, totalFiles: ${Math.round(totalFilesSize / 1024)}KB)`,
+      );
+    }
 
     return new Map(commits.map((commit) => [commit.id, commit]));
   } catch (error) {