@codeyam/codeyam-cli 0.1.0-staging.e38f7bd → 0.1.0

package/analyzer-template/packages/aws/src/lib/ecs/ecsTaskFactory.ts

@@ -5,51 +5,22 @@ export type EcsStartConfig = {
 };
 
 /**
- * Prepare to run an ECS task for the classical analysis-then-capture flow
- * which uses a 'project' image for analysis and a 'playwright' image for capture.
+ * Prepare to run an ECS task for analysis with distributed capture orchestration.
+ * Uses the unified 'combo' image which includes both analysis and capture capabilities.
  */
-export function getEcsStartConfigForAnalysisThenCapture(
-  projectEnvironmentVariables: Record<string, string>,
-  playwrightEnvironmentVariables: Record<string, string>,
-): EcsStartConfig {
-  return {
-    taskDefinition: getEcsTaskDefinitionName(
-      EcsTaskDefinitionUse.AnalyzeThenCapture,
-    ),
-    containerEnvironmentVariables: [
-      [
-        getEcsImageNameForType(EcsImageType.Project),
-        projectEnvironmentVariables,
-      ],
-      [
-        getEcsImageNameForType(EcsImageType.Playwright),
-        playwrightEnvironmentVariables,
-      ],
-    ],
-  };
-}
-
-/**
- * Prepare to run an ECS task for the new analysis flow with distributed capture
- * tasks orchestrated from only a 'project' image.
- */
-export function getEcsStartConfigFoAnalysisWithOrchestration(
+export function getEcsStartConfigForAnalysis(
   environmentVariables: Record<string, string>,
 ): EcsStartConfig {
   return {
-    taskDefinition: getEcsTaskDefinitionName(
-      EcsTaskDefinitionUse.AnalyzeWithOrchestration,
-    ),
-    containerEnvironmentVariables: [
-      [getEcsImageNameForType(EcsImageType.Project), environmentVariables],
-    ],
+    taskDefinition: getEcsTaskDefinitionName(EcsTaskDefinitionUse.Analysis),
+    containerEnvironmentVariables: [[getEcsImageName(), environmentVariables]],
   };
 }
 
 /**
  * Prepare to run an ECS worker task that implements the capture portion of the
- * distributed orchestration, which uses a 'combo' image. This task is launched
- * from a task created with `getEcsStartConfigFoAnalysisWithOrchestration()`
+ * distributed orchestration. Uses the same unified 'combo' image.
+ * This task is launched from a task created with `getEcsStartConfigForAnalysis()`
  */
 export function getEcsStartConfigForOrchestrationTask(
   environmentVariables: Record<string, string>,
@@ -58,52 +29,29 @@ export function getEcsStartConfigForOrchestrationTask(
     taskDefinition: getEcsTaskDefinitionName(
       EcsTaskDefinitionUse.OrchestrationTask,
     ),
-    containerEnvironmentVariables: [
-      [getEcsImageNameForType(EcsImageType.Combo), environmentVariables],
-    ],
+    containerEnvironmentVariables: [[getEcsImageName(), environmentVariables]],
   };
 }
 
 export enum EcsTaskDefinitionUse {
-  /* A 'project' image runs analysis while a 'playwright' image captures the entities. */
-  AnalyzeThenCapture = 'analyze-then-capture',
-  /* A 'project' image runs analysis while firing up distributed capture orchestration. */
-  AnalyzeWithOrchestration = 'analyze-with-orchestration',
-  /* A worker task that combines 'project' and 'playwright' code, launched by orchestration. */
+  /* Main analysis task - runs analysis and fires up distributed capture orchestration. */
+  Analysis = 'analysis',
+  /* A worker task launched by orchestration to capture scenarios. */
   OrchestrationTask = 'orchestration-task',
 }
 
 export function getEcsTaskDefinitionName(forUse: EcsTaskDefinitionUse): string {
   switch (forUse) {
-    case EcsTaskDefinitionUse.AnalyzeThenCapture:
-      return `${process.env.ECR_REPOSITORY_NAME}-project-and-playwright`;
-    case EcsTaskDefinitionUse.AnalyzeWithOrchestration:
-      return `${process.env.ECR_REPOSITORY_NAME}-project`;
+    case EcsTaskDefinitionUse.Analysis:
+      return `${process.env.ECR_REPOSITORY_NAME}-analysis`;
     case EcsTaskDefinitionUse.OrchestrationTask:
-      return `${process.env.ECR_REPOSITORY_NAME}-combo`;
+      return `${process.env.ECR_REPOSITORY_NAME}-orchestration`;
     default:
       throw new Error(`Unknown task definition use: ${forUse}`);
   }
 }
 
-export enum EcsImageType {
-  /* The virtualized server that runs the project code. */
-  Project = 'project',
-  /* The playwright capture process which waits for the project to be ready. */
-  Playwright = 'playwright',
-  /* A combo image that combines both project and playwright code, used by orchestration. */
-  Combo = 'combo',
-}
-
-export function getEcsImageNameForType(type: EcsImageType): string {
-  switch (type) {
-    case EcsImageType.Project:
-      return `${process.env.ECR_REPOSITORY_NAME}-project`;
-    case EcsImageType.Playwright:
-      return `${process.env.ECR_REPOSITORY_NAME}-playwright`;
-    case EcsImageType.Combo:
-      return `${process.env.ECR_REPOSITORY_NAME}-combo`;
-    default:
-      throw new Error(`Unknown image type: ${type}`);
-  }
+/** Returns the name of the unified Docker image used for all ECS tasks. */
+export function getEcsImageName(): string {
+  return `${process.env.ECR_REPOSITORY_NAME}-combo`;
 }

package/analyzer-template/packages/aws/src/lib/s3/checkS3ObjectExists.ts

@@ -0,0 +1,47 @@
+import { S3Client, HeadObjectCommand } from '@aws-sdk/client-s3';
+
+interface CheckS3ObjectExistsArgs {
+  bucketName: string;
+  key: string;
+}
+
+interface CheckS3ObjectExistsResult {
+  exists: boolean;
+  size?: number;
+}
+
+/**
+ * Check if an object exists in S3 using a HEAD request.
+ * Returns the object size if it exists.
+ */
+export default async function checkS3ObjectExists({
+  bucketName,
+  key,
+}: CheckS3ObjectExistsArgs): Promise<CheckS3ObjectExistsResult> {
+  const s3Client = new S3Client({});
+
+  const command = new HeadObjectCommand({
+    Bucket: bucketName,
+    Key: key,
+  });
+
+  try {
+    const response = await s3Client.send(command);
+    return {
+      exists: true,
+      size: response.ContentLength,
+    };
+  } catch (error: unknown) {
+    // NotFound is expected when object doesn't exist
+    if (
+      error &&
+      typeof error === 'object' &&
+      'name' in error &&
+      error.name === 'NotFound'
+    ) {
+      return { exists: false };
+    }
+    // Re-throw unexpected errors
+    throw error;
+  }
+}

package/analyzer-template/packages/aws/src/lib/s3/uploadFileToS3.ts

@@ -24,11 +24,18 @@ export default async function uploadFileToS3({
   });
 
   try {
+    let lastLoggedMB = 0;
     upload.on('httpUploadProgress', (progress) => {
-      console.log(progress);
+      const loadedMB = Math.floor((progress.loaded ?? 0) / (1024 * 1024));
+      // Log every 10MB to avoid spam
+      if (loadedMB >= lastLoggedMB + 10) {
+        lastLoggedMB = loadedMB;
+        console.log(`Uploading ${key}... ${loadedMB}MB`);
+      }
     });
 
     await upload.done();
+    console.log(`Uploaded ${key}`);
   } catch (error) {
     console.log('Error. File not uploaded.', error);
     throw error;

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

@@ -15,7 +15,7 @@
     "@supabase/supabase-js": "2.88.0",
     "better-sqlite3": "^12.4.1",
     "fetch-retry": "^6.0.0",
-    "kysely": "^0.28.5",
+    "kysely": "^0.28.11",
     "pg": "^8.16.3"
   },
   "jest": {

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

@@ -1,6 +1,6 @@
 import { AnalysisBranch } from '~codeyam/types';
 import { DbAnalysisBranch } from './kysely/tableRelations';
-import { randomUUID } from 'crypto';
+const randomUUID = () => crypto.randomUUID();
 import { AnalysisBranchesTable } from './kysely/tables/analysisBranchesTable';
 import { type Insertable } from 'kysely';
 

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

@@ -1,7 +1,7 @@
 import { Analysis } from '~codeyam/types';
 import { type Insertable } from 'kysely';
 import { AnalysesTable } from './kysely/tables/analysesTable';
-import { randomUUID } from 'crypto';
+const randomUUID = () => crypto.randomUUID();
 
 export default function analysisToDb(
   analysis: Analysis,

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

@@ -1,7 +1,7 @@
 import { Branch } from '~codeyam/types';
 import { type Insertable } from 'kysely';
 import { BranchesTable } from './kysely/tables/branchesTable';
-import { randomUUID } from 'crypto';
+const randomUUID = () => crypto.randomUUID();
 
 export default function branchToDb(branch: Branch): Insertable<BranchesTable> {
   const { id, projectId, activeAt, contentChangedAt, metadata, ...remaining } =

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

@@ -1,6 +1,6 @@
 import { CommitBranch } from '~codeyam/types';
 import { type Insertable } from 'kysely';
-import { randomUUID } from 'crypto';
+const randomUUID = () => crypto.randomUUID();
 import { CommitBranchesTable } from './kysely/tables/commitBranchesTable';
 
 export default function commitBranchToDb(

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

@@ -1,7 +1,7 @@
 import { Commit } from '~codeyam/types';
 import { CommitsTable } from './kysely/tables/commitsTable';
 import { type Insertable } from 'kysely';
-import { randomUUID } from 'crypto';
+const randomUUID = () => crypto.randomUUID();
 
 export default function commitToDb(
   commit: Commit,

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

@@ -1,7 +1,7 @@
 import { File } from '~codeyam/types';
 import { type Insertable } from 'kysely';
 import { FilesTable } from './kysely/tables/filesTable';
-import { randomUUID } from 'crypto';
+const randomUUID = () => crypto.randomUUID();
 
 export default function fileToDb(file: File): Insertable<FilesTable> {
   return {

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

@@ -33,9 +33,13 @@ import {
 } from './tables/commitBranchesTable';
 import { CommitsTable, createCommitsTable } from './tables/commitsTable';
 import {
-  createDebugReportsTable,
-  DebugReportsTable,
+  createDebugBundlesTable,
+  DebugBundlesTable,
 } from './tables/debugReportsTable';
+import {
+  createLabsRequestsTable,
+  LabsRequestsTable,
+} from './tables/labsRequestsTable';
 import { createEntitiesTable, EntitiesTable } from './tables/entitiesTable';
 import {
   createEntityBranchesTable,
@@ -101,12 +105,13 @@ const databaseSchema = {
   branches: schemaField<BranchesTable>(),
   commit_branches: schemaField<CommitBranchesTable>(),
   commits: schemaField<CommitsTable>(),
-  debug_reports: schemaField<DebugReportsTable>(),
+  debug_reports: schemaField<DebugBundlesTable>(),
   entities: schemaField<EntitiesTable>(),
   entity_branches: schemaField<EntityBranchesTable>(),
   entity_statements: schemaField<EntityStatementsTable>(),
   files: schemaField<FilesTable>(),
   github_payloads: schemaField<GithubPayloadsTable>(),
+  labs_requests: schemaField<LabsRequestsTable>(),
   github_users: schemaField<GithubUsersTable>(),
   scenario_comments: schemaField<ScenarioCommentsTable>(),
   scenarios: schemaField<ScenariosTable>(),
@@ -245,7 +250,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);
   });
@@ -377,13 +389,14 @@ export async function createSqliteSchema(db: Kysely<Database>): Promise<void> {
   await createBranchesTable(db);
   await createCommitBranchesTable(db);
   await createCommitsTable(db);
-  await createDebugReportsTable(db);
+  await createDebugBundlesTable(db);
   await createEntitiesTable(db);
   await createEntityBranchesTable(db);
   await createEntityStatementsTable(db);
   await createFilesTable(db);
   await createGithubPayloadsTable(db);
   await createGithubUsersTable(db);
+  await createLabsRequestsTable(db);
   await createScenarioCommentsTable(db);
   await createScenariosTable(db);
   await createStatementsTable(db);

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

@@ -6,7 +6,7 @@ import { BackgroundJobsTable } from './tables/backgroundJobsTable';
 import { BranchesTable } from './tables/branchesTable';
 import { CommitsTable } from './tables/commitsTable';
 import { CommitBranchesTable } from './tables/commitBranchesTable';
-import { DebugReportsTable } from './tables/debugReportsTable';
+import { DebugBundlesTable } from './tables/debugReportsTable';
 import { EntitiesTable } from './tables/entitiesTable';
 import { EntityBranchesTable } from './tables/entityBranchesTable';
 import { FilesTable } from './tables/filesTable';
@@ -105,4 +105,4 @@ export type DbUserScenario = Selectable<UserScenariosTable> & {
 
 export type DbStatement = Selectable<StatementsTable>;
 
-export type DbDebugReport = Selectable<DebugReportsTable>;
+export type DbDebugBundle = Selectable<DebugBundlesTable>;

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/kysely/tables/debugReportsTable.ts

@@ -3,7 +3,12 @@ import type { Generated, JSONColumnType } from 'kysely';
 
 import { schemaField, defaultNow } from '../schemaHelpers';
 
-interface DebugReportMetadata {
+/**
+ * Metadata for a debug bundle upload.
+ * Note: "bundle" refers to the tarball upload (base + delta).
+ * The markdown "debug report" from /codeyam-diagnose is stored in feedback.debugReport.
+ */
+interface DebugBundleMetadata {
   timestamp: string;
   git: {
     sha: string;
@@ -20,28 +25,48 @@ interface DebugReportMetadata {
     platform: string;
     arch: string;
   };
+  feedback?: {
+    source: string;
+    issueType?: string;
+    description?: string;
+    email?: string;
+    entitySha?: string;
+    scenarioId?: string;
+    analysisId?: string;
+    currentUrl?: string;
+    recentActivity?: string[];
+    debugReport?: string;
+    entityName?: string;
+    entityType?: string;
+    scenarioName?: string;
+    errorMessage?: string;
+  };
 }
 
-const debugReportsSchema = {
+// Table name remains 'debug_reports' in the database for backwards compatibility
+const debugBundlesSchema = {
   id: schemaField<Generated<string>>(),
   project_slug: schemaField<string>(),
   s3_key: schemaField<string>(),
   file_size_bytes: schemaField<number | null>(),
-  metadata: schemaField<JSONColumnType<DebugReportMetadata> | null>(),
+  metadata: schemaField<JSONColumnType<DebugBundleMetadata> | null>(),
   status: schemaField<string | null>(),
   created_at: schemaField<Generated<string>>(),
   uploaded_at: schemaField<string | null>(),
+  base_sha: schemaField<string | null>(),
+  delta_size_bytes: schemaField<number | null>(),
 } as const;
 
-export type DebugReportsTable = {
-  [K in keyof typeof debugReportsSchema]: (typeof debugReportsSchema)[K];
+export type DebugBundlesTable = {
+  [K in keyof typeof debugBundlesSchema]: (typeof debugBundlesSchema)[K];
 };
 
-export const DebugReportsTableColumns = Object.keys(
-  debugReportsSchema,
-) as (keyof DebugReportsTable)[];
+export const DebugBundlesTableColumns = Object.keys(
+  debugBundlesSchema,
+) as (keyof DebugBundlesTable)[];
 
-export async function createDebugReportsTable(db: Kysely<any>): Promise<void> {
+export async function createDebugBundlesTable(db: Kysely<any>): Promise<void> {
+  // Table name remains 'debug_reports' for backwards compatibility
   await db.schema
     .createTable('debug_reports')
     .addColumn('id', 'uuid', (col: ColumnDefinitionBuilder) => col.primaryKey())
@@ -56,6 +81,8 @@ export async function createDebugReportsTable(db: Kysely<any>): Promise<void> {
     .addColumn('status', 'varchar')
     .addColumn('created_at', 'datetime', defaultNow(true))
     .addColumn('uploaded_at', 'datetime')
+    .addColumn('base_sha', 'varchar')
+    .addColumn('delta_size_bytes', 'bigint')
     .ifNotExists()
     .execute();
 }

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

@@ -0,0 +1,52 @@
+import { Kysely, ColumnDefinitionBuilder } from 'kysely';
+import type { Generated } from 'kysely';
+
+import { schemaField, defaultNow } from '../schemaHelpers';
+
+const labsRequestsSchema = {
+  id: schemaField<Generated<string>>(),
+  project_slug: schemaField<string>(),
+  name: schemaField<string>(),
+  email: schemaField<string>(),
+  org_name: schemaField<string | null>(),
+  org_size: schemaField<string | null>(),
+  project_size: schemaField<string | null>(),
+  tech_stack: schemaField<string | null>(),
+  status: schemaField<string | null>(),
+  unlock_code: schemaField<string | null>(),
+  created_at: schemaField<Generated<string>>(),
+  approved_at: schemaField<string | null>(),
+} as const;
+
+export type LabsRequestsTable = {
+  [K in keyof typeof labsRequestsSchema]: (typeof labsRequestsSchema)[K];
+};
+
+export const LabsRequestsTableColumns = Object.keys(
+  labsRequestsSchema,
+) as (keyof LabsRequestsTable)[];
+
+export async function createLabsRequestsTable(db: Kysely<any>): Promise<void> {
+  await db.schema
+    .createTable('labs_requests')
+    .addColumn('id', 'uuid', (col: ColumnDefinitionBuilder) => col.primaryKey())
+    .addColumn('project_slug', 'varchar', (col: ColumnDefinitionBuilder) =>
+      col.notNull().unique(),
+    )
+    .addColumn('name', 'varchar', (col: ColumnDefinitionBuilder) =>
+      col.notNull(),
+    )
+    .addColumn('email', 'varchar', (col: ColumnDefinitionBuilder) =>
+      col.notNull(),
+    )
+    .addColumn('org_name', 'varchar')
+    .addColumn('org_size', 'varchar')
+    .addColumn('project_size', 'varchar')
+    .addColumn('tech_stack', 'varchar')
+    .addColumn('status', 'varchar')
+    .addColumn('unlock_code', 'varchar')
+    .addColumn('created_at', 'datetime', defaultNow(true))
+    .addColumn('approved_at', 'datetime')
+    .ifNotExists()
+    .execute();
+}

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 [];