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

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

@@ -36,6 +36,10 @@ import {
   createDebugBundlesTable,
   DebugBundlesTable,
 } from './tables/debugReportsTable';
+import {
+  createLabsRequestsTable,
+  LabsRequestsTable,
+} from './tables/labsRequestsTable';
 import { createEntitiesTable, EntitiesTable } from './tables/entitiesTable';
 import {
   createEntityBranchesTable,
@@ -107,6 +111,7 @@ const databaseSchema = {
   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);
   });
@@ -384,6 +396,7 @@ export async function createSqliteSchema(db: Kysely<Database>): Promise<void> {
   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/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

@@ -6,7 +6,7 @@ import { schemaField, defaultNow } from '../schemaHelpers';
 /**
  * Metadata for a debug bundle upload.
  * Note: "bundle" refers to the tarball upload (base + delta).
- * The markdown "debug report" from /debug-codeyam is stored in feedback.debugReport.
+ * The markdown "debug report" from /codeyam-diagnose is stored in feedback.debugReport.
  */
 interface DebugBundleMetadata {
   timestamp: string;
@@ -25,6 +25,22 @@ interface DebugBundleMetadata {
     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;
+  };
 }
 
 // Table name remains 'debug_reports' in the database for backwards compatibility

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

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) {

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

@@ -40,15 +40,19 @@ export default async function loadReadyToBeCapturedAnalyses(
           .whereRef('scenarios.analysis_id', '=', 'analyses.id'),
       ).as('scenarios'),
     ])
+    // Cross-database compatible: use -> (not ->>) for boolean JSON fields
+    // PostgreSQL: jsonb `true` auto-casts to string 'true' for comparison
+    // SQLite: -> returns text 'true' which equals string 'true'
+    // (Note: ->> returns integer 1 in SQLite for booleans, breaking string comparisons)
     .where(
-      // Use ->> to extract as text for proper comparison (-> returns JSONB which doesn't compare to string)
-      sql<string>` ${sql.ref('analyses.status')} ->> 'readyToBeCaptured'`,
+      sql<string>`${sql.ref('analyses.status')} -> 'readyToBeCaptured'`,
       '=',
       'true',
     )
     // Exclude entities that are not exported - they cannot be captured because they can't be imported
+    // Use -> operator for cross-database boolean comparison
     .where(
-      sql<boolean>`(${sql.ref('entities.metadata')} ->> 'notExported') IS NULL OR (${sql.ref('entities.metadata')} ->> 'notExported') != 'true'`,
+      sql<boolean>`(${sql.ref('entities.metadata')} -> 'notExported') IS NULL OR (${sql.ref('entities.metadata')} -> 'notExported') != 'true'`,
     );
 
   if (projectId) {

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

@@ -1,7 +1,7 @@
 import { Project } from '~codeyam/types';
 import { type Insertable } from 'kysely';
 import { ProjectsTable } from './kysely/tables/projectsTable';
-import { randomUUID } from 'crypto';
+const randomUUID = () => crypto.randomUUID();
 
 export default function projectToDb(
   project: Project,

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

@@ -3,7 +3,7 @@ import dbToFile from './dbToFile';
 import { File } from '~codeyam/types';
 import { Insertable, Selectable } from 'kysely';
 import { FilesTable } from './kysely/tables/filesTable';
-import { randomUUID } from 'crypto';
+const randomUUID = () => crypto.randomUUID();
 
 const BATCH_SIZE = 100;
 

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

@@ -1,7 +1,7 @@
 import { Scenario } from '~codeyam/types';
 import { type Insertable } from 'kysely';
 import { ScenariosTable } from './kysely/tables/scenariosTable';
-import { randomUUID } from 'crypto';
+const randomUUID = () => crypto.randomUUID();
 
 export default function scenarioToDb(
   scenario: Scenario,

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

@@ -2,16 +2,10 @@
  * updates commit metadata by merging partial updates with existing data.
  * uses database transactions to ensure atomic updates and handle concurrent modifications.
  */
-import {
-  Commit,
-  CommitMetadata,
-  CommitRunStatus,
-  DeepReadonly,
-} from '~codeyam/types';
+import { CommitMetadata, CommitRunStatus } from '~codeyam/types';
 import { getDatabase } from './kysely/db';
 import { awsLog } from '~codeyam/utils';
 import { deepMerge, DeepUpdate } from './jsonUpdateUtils';
-import dbToCommit from './dbToCommit';
 
 type UpdateCommitMetadataArgs = {
   commitId?: string;
@@ -19,10 +13,7 @@ type UpdateCommitMetadataArgs = {
   metadataUpdate?: DeepUpdate<CommitMetadata>;
   runStatusUpdate?: DeepUpdate<CommitRunStatus>;
   archiveCurrentRun?: boolean;
-  updateCallback?: (
-    metadata: CommitMetadata,
-    commit: DeepReadonly<Commit>,
-  ) => void | Promise<void>;
+  updateCallback?: (metadata: CommitMetadata) => void | Promise<void>;
 };
 
 export default async function updateCommitMetadata({
@@ -37,9 +28,11 @@ export default async function updateCommitMetadata({
     return await getDatabase()
       .transaction()
       .execute(async (trx) => {
+        // Only select what we need - the files column can be 1MB+ and kills performance
+        // If updateCallback is provided, it might need the full commit, so use selectAll
         const commit = await trx
           .selectFrom('commits')
-          .selectAll()
+          .select(['id', 'metadata'])
           .$if(!!commitId, (qb: any) => qb.where('id', '=', commitId))
           .$if(!!commitSha, (qb: any) => qb.where('sha', '=', commitSha))
           .executeTakeFirst();
@@ -150,7 +143,7 @@ export default async function updateCommitMetadata({
 
         // Allow callback to perform complex atomic updates
         if (updateCallback) {
-          await updateCallback(updatedMetadata, dbToCommit(commit));
+          await updateCallback(updatedMetadata);
         }
 
         try {
@@ -158,7 +151,7 @@ export default async function updateCommitMetadata({
             .updateTable('commits')
             .set({ metadata: JSON.stringify(updatedMetadata) })
             .where('id', '=', commit.id)
-            .returningAll()
+            .returning(['id']) // Don't return all columns - files can be 1MB+
             .executeTakeFirst();
 
           if (!result) {

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

@@ -1,7 +1,7 @@
 import { UserScenario } from '~codeyam/types';
 import { Insertable } from 'kysely';
 import { UserScenariosTable } from './kysely/tables/userScenariosTable';
-import { randomUUID } from 'crypto';
+const randomUUID = () => crypto.randomUUID();
 
 export default function userScenarioToDb(
   userScenario: UserScenario,