@codeyam/codeyam-cli 0.1.0-staging.8df382d → 0.1.0-staging.a890816

package/analyzer-template/packages/database/index.ts

@@ -75,6 +75,7 @@ export * from './src/lib/kysely/tables/backgroundJobsTable';
 export * from './src/lib/kysely/tables/branchesTable';
 export * from './src/lib/kysely/tables/commitBranchesTable';
 export * from './src/lib/kysely/tables/commitsTable';
+export * from './src/lib/kysely/tables/editorScenariosTable';
 export * from './src/lib/kysely/tables/entitiesTable';
 export * from './src/lib/kysely/tables/entityBranchesTable';
 export * from './src/lib/kysely/tables/entityStatementsTable';

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

@@ -62,6 +62,10 @@ import {
   createScenarioCommentsTable,
   ScenarioCommentsTable,
 } from './tables/scenarioCommentsTable';
+import {
+  createEditorScenariosTable,
+  EditorScenariosTable,
+} from './tables/editorScenariosTable';
 import { createScenariosTable, ScenariosTable } from './tables/scenariosTable';
 import {
   createStatementsTable,
@@ -106,6 +110,7 @@ const databaseSchema = {
   commit_branches: schemaField<CommitBranchesTable>(),
   commits: schemaField<CommitsTable>(),
   debug_reports: schemaField<DebugBundlesTable>(),
+  editor_scenarios: schemaField<EditorScenariosTable>(),
   entities: schemaField<EntitiesTable>(),
   entity_branches: schemaField<EntityBranchesTable>(),
   entity_statements: schemaField<EntityStatementsTable>(),
@@ -210,6 +215,7 @@ export function getSqliteDatabase(sqlitePath?: string) {
     fileMustExist: false,
   });
   sqlite.pragma('journal_mode = WAL');
+  sqlite.pragma('busy_timeout = 5000');
   sqlite.pragma('synchronous = FULL');
 
   // Verify the database has the expected schema
@@ -305,6 +311,7 @@ export async function getDatabaseForTesting(
     // Standard SQLite testing path
     const sqlite = new SQLiteDatabase(dbPath);
     sqlite.pragma('journal_mode = WAL');
+    sqlite.pragma('busy_timeout = 5000');
     sqlite.pragma('synchronous = FULL');
     const kyselyDb = new Kysely<Database>({
       dialect: new SqliteDialect({ database: sqlite }),
@@ -390,6 +397,7 @@ export async function createSqliteSchema(db: Kysely<Database>): Promise<void> {
   await createCommitBranchesTable(db);
   await createCommitsTable(db);
   await createDebugBundlesTable(db);
+  await createEditorScenariosTable(db);
   await createEntitiesTable(db);
   await createEntityBranchesTable(db);
   await createEntityStatementsTable(db);

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

@@ -0,0 +1,62 @@
+import { Kysely, ColumnDefinitionBuilder } from 'kysely';
+import type { Generated } from 'kysely';
+
+import { schemaField, defaultNow } from '../schemaHelpers';
+
+const editorScenariosSchema = {
+  id: schemaField<Generated<string>>(),
+  project_id: schemaField<string>(),
+  name: schemaField<string>(),
+  description: schemaField<string | null>(),
+  component_name: schemaField<string | null>(),
+  component_path: schemaField<string | null>(),
+  screenshot_path: schemaField<string | null>(),
+  created_at: schemaField<Generated<string>>(),
+  updated_at: schemaField<Generated<string>>(),
+} as const;
+
+export type EditorScenariosTable = {
+  [K in keyof typeof editorScenariosSchema]: (typeof editorScenariosSchema)[K];
+};
+
+export const EditorScenariosTableColumns = Object.keys(
+  editorScenariosSchema,
+) as (keyof EditorScenariosTable)[];
+
+export async function createEditorScenariosTable(
+  db: Kysely<any>,
+): Promise<void> {
+  await db.schema
+    .createTable('editor_scenarios')
+    .addColumn('id', 'uuid', (col: ColumnDefinitionBuilder) => col.primaryKey())
+    .addColumn('project_id', 'uuid', (col: ColumnDefinitionBuilder) =>
+      col.notNull(),
+    )
+    .addColumn('name', 'varchar', (col: ColumnDefinitionBuilder) =>
+      col.notNull(),
+    )
+    .addColumn('description', 'text')
+    .addColumn('component_name', 'varchar')
+    .addColumn('component_path', 'varchar')
+    .addColumn('screenshot_path', 'varchar')
+    .addColumn('created_at', 'datetime', defaultNow(true))
+    .addColumn('updated_at', 'datetime', defaultNow(true))
+    .ifNotExists()
+    .execute();
+
+  // Add columns to existing tables (ALTER TABLE has no IF NOT EXISTS in SQLite)
+  for (const col of [
+    'component_name',
+    'component_path',
+    'screenshot_path',
+  ] as const) {
+    try {
+      await db.schema
+        .alterTable('editor_scenarios')
+        .addColumn(col, 'varchar')
+        .execute();
+    } catch {
+      // Column already exists — expected for fresh databases
+    }
+  }
+}

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

@@ -9,6 +9,7 @@ import {
 import { awsLog } from '~codeyam/utils';
 import { Commit } from '~codeyam/types';
 import { ScenariosTableColumns } from './kysely/tables/scenariosTable';
+import { CommitsTableColumnsLite } from './kysely/tables/commitsTable';
 import { sql, ExpressionBuilder } from 'kysely';
 
 interface LoadCommitsArgs {
@@ -150,25 +151,35 @@ export default async function loadCommits({
   const startTime = Date.now();
 
   try {
-    let query = db
-      .selectFrom('commits')
-      .selectAll('commits')
-      .select((eb: ExpressionBuilder<any, any>) => [
-        jsonObjectFrom(
-          eb
-            .selectFrom('github_users')
-            .select([
-              'username',
-              'preferred_username as preferredUsername',
-              'avatar_url as avatarUrl',
-            ])
-            .where(
-              'github_users.username',
-              '=',
-              eb.ref('commits.author_github_username'),
-            ),
-        ).as('author'),
-      ]);
+    // When skipRelations is true, use lite columns (excludes 'files' which can be 1MB+ per commit)
+    // and skip the author subquery for maximum efficiency
+    let query: any;
+    if (skipRelations) {
+      const liteColumns = CommitsTableColumnsLite.map(
+        (col) => `commits.${col}` as any,
+      );
+      query = db.selectFrom('commits').select(liteColumns);
+    } else {
+      query = db
+        .selectFrom('commits')
+        .selectAll('commits')
+        .select((eb: ExpressionBuilder<any, any>) => [
+          jsonObjectFrom(
+            eb
+              .selectFrom('github_users')
+              .select([
+                'username',
+                'preferred_username as preferredUsername',
+                'avatar_url as avatarUrl',
+              ])
+              .where(
+                'github_users.username',
+                '=',
+                eb.ref('commits.author_github_username'),
+              ),
+          ).as('author'),
+        ]);
+    }
 
     if (projectId) {
       query = query.where('project_id', '=', projectId);
@@ -215,7 +226,7 @@ export default async function loadCommits({
 
     // DEBUG: Log slow queries (includes files column which can be 1MB+)
     if (queryTime > 100) {
-      const totalFilesSize = commits.reduce((sum, c: any) => {
+      const totalFilesSize = commits.reduce((sum: number, c: any) => {
         return sum + (c.files ? JSON.stringify(c.files).length : 0);
       }, 0);
       console.log(

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

@@ -48,11 +48,6 @@ export default async function loadReadyToBeCapturedAnalyses(
       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'`,
     );
 
   if (projectId) {

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

@@ -24,157 +24,173 @@ export default async function updateCommitMetadata({
   archiveCurrentRun,
   updateCallback,
 }: UpdateCommitMetadataArgs): Promise<CommitMetadata | null> {
-  try {
-    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')
-          .select(['id', 'metadata'])
-          .$if(!!commitId, (qb: any) => qb.where('id', '=', commitId))
-          .$if(!!commitSha, (qb: any) => qb.where('sha', '=', commitSha))
-          .executeTakeFirst();
-
-        if (!commit) {
-          awsLog(
-            `CodeYam Error: updateCommitMetadata(): Commit ${commitId} not found`,
-          );
-          return null;
-        }
-
-        // Initialize metadata if it doesn't exist (metadata is already parsed from DB)
-        const currentMetadata: CommitMetadata = commit.metadata || {};
-
-        // if the convenience parameter for latest run was supplied, merge it in
-        if (runStatusUpdate) {
-          runStatusUpdate.lastUpdatedAt ??= new Date().toISOString();
-
-          if (runStatusUpdate.currentEntityShas !== undefined) {
+  const MAX_RETRIES = 4;
+  const BASE_DELAY_MS = 250;
+
+  for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+    try {
+      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')
+            .select(['id', 'metadata'])
+            .$if(!!commitId, (qb: any) => qb.where('id', '=', commitId))
+            .$if(!!commitSha, (qb: any) => qb.where('sha', '=', commitSha))
+            .executeTakeFirst();
+
+          if (!commit) {
+            awsLog(
+              `CodeYam Error: updateCommitMetadata(): Commit ${commitId} not found`,
+            );
+            return null;
+          }
+
+          // Initialize metadata if it doesn't exist (metadata is already parsed from DB)
+          const currentMetadata: CommitMetadata = commit.metadata || {};
+
+          // if the convenience parameter for latest run was supplied, merge it in
+          if (runStatusUpdate) {
+            runStatusUpdate.lastUpdatedAt ??= new Date().toISOString();
+
+            if (runStatusUpdate.currentEntityShas !== undefined) {
+              console.log(
+                `[updateCommitMetadata] Updating currentRun.currentEntityShas`,
+              );
+              console.log(`[updateCommitMetadata] Commit SHA: ${commitSha}`);
+              console.log(
+                `[updateCommitMetadata] Previous entity SHAs:`,
+                currentMetadata.currentRun?.currentEntityShas,
+              );
+              console.log(
+                `[updateCommitMetadata] New entity SHAs:`,
+                runStatusUpdate.currentEntityShas,
+              );
+              console.log(
+                `[updateCommitMetadata] Archive flag:`,
+                archiveCurrentRun,
+              );
+            }
+
+            metadataUpdate = deepMerge(metadataUpdate ?? {}, {
+              currentRun: runStatusUpdate,
+            });
+          } else if (!metadataUpdate && !updateCallback) {
+            return currentMetadata; // nothing to update
+          }
+
+          // Deep merge the baseline status updates
+          const updatedMetadata: CommitMetadata = metadataUpdate
+            ? deepMerge(currentMetadata, metadataUpdate)
+            : currentMetadata;
+
+          // Archive current run if requested
+          if (archiveCurrentRun && updatedMetadata.currentRun) {
             console.log(
-              `[updateCommitMetadata] Updating currentRun.currentEntityShas`,
+              `[updateCommitMetadata] ========================================`,
             );
+            console.log(`[updateCommitMetadata] ARCHIVING CURRENT RUN`);
             console.log(`[updateCommitMetadata] Commit SHA: ${commitSha}`);
             console.log(
-              `[updateCommitMetadata] Previous entity SHAs:`,
-              currentMetadata.currentRun?.currentEntityShas,
+              `[updateCommitMetadata] Current run entity SHAs:`,
+              updatedMetadata.currentRun.currentEntityShas,
+            );
+            console.log(
+              `[updateCommitMetadata] Current run PIDs: analyzer=${updatedMetadata.currentRun.analyzerPid}, capture=${updatedMetadata.currentRun.capturePid}`,
             );
             console.log(
-              `[updateCommitMetadata] New entity SHAs:`,
-              runStatusUpdate.currentEntityShas,
+              `[updateCommitMetadata] Current run completed: analyses=${updatedMetadata.currentRun.analysesCompleted}, captures=${updatedMetadata.currentRun.capturesCompleted}`,
             );
             console.log(
-              `[updateCommitMetadata] Archive flag:`,
-              archiveCurrentRun,
+              `[updateCommitMetadata] Historical runs before archiving: ${updatedMetadata.historicalRuns?.length || 0}`,
+            );
+
+            const runToArchive: CommitRunStatus = {
+              ...updatedMetadata.currentRun,
+              archivedAt: new Date().toISOString(),
+            };
+
+            console.log(
+              `[updateCommitMetadata] Run to archive:`,
+              JSON.stringify(runToArchive, null, 2),
+            );
+
+            updatedMetadata.historicalRuns = [
+              ...(updatedMetadata.historicalRuns || []),
+              runToArchive,
+            ];
+
+            console.log(
+              `[updateCommitMetadata] Historical runs after archiving: ${updatedMetadata.historicalRuns.length}`,
+            );
+            console.log(
+              `[updateCommitMetadata] All historical runs:`,
+              JSON.stringify(
+                updatedMetadata.historicalRuns.map((r) => ({
+                  entityShas: r.currentEntityShas,
+                  archivedAt: r.archivedAt,
+                  completed: {
+                    analyses: r.analysesCompleted,
+                    captures: r.capturesCompleted,
+                  },
+                })),
+                null,
+                2,
+              ),
+            );
+            console.log(
+              `[updateCommitMetadata] ========================================`,
             );
           }
 
-          metadataUpdate = deepMerge(metadataUpdate ?? {}, {
-            currentRun: runStatusUpdate,
-          });
-        } else if (!metadataUpdate && !updateCallback) {
-          return currentMetadata; // nothing to update
-        }
-
-        // Deep merge the baseline status updates
-        const updatedMetadata: CommitMetadata = metadataUpdate
-          ? deepMerge(currentMetadata, metadataUpdate)
-          : currentMetadata;
-
-        // Archive current run if requested
-        if (archiveCurrentRun && updatedMetadata.currentRun) {
-          console.log(
-            `[updateCommitMetadata] ========================================`,
-          );
-          console.log(`[updateCommitMetadata] ARCHIVING CURRENT RUN`);
-          console.log(`[updateCommitMetadata] Commit SHA: ${commitSha}`);
-          console.log(
-            `[updateCommitMetadata] Current run entity SHAs:`,
-            updatedMetadata.currentRun.currentEntityShas,
-          );
-          console.log(
-            `[updateCommitMetadata] Current run PIDs: analyzer=${updatedMetadata.currentRun.analyzerPid}, capture=${updatedMetadata.currentRun.capturePid}`,
-          );
-          console.log(
-            `[updateCommitMetadata] Current run completed: analyses=${updatedMetadata.currentRun.analysesCompleted}, captures=${updatedMetadata.currentRun.capturesCompleted}`,
-          );
-          console.log(
-            `[updateCommitMetadata] Historical runs before archiving: ${updatedMetadata.historicalRuns?.length || 0}`,
-          );
-
-          const runToArchive: CommitRunStatus = {
-            ...updatedMetadata.currentRun,
-            archivedAt: new Date().toISOString(),
-          };
-
-          console.log(
-            `[updateCommitMetadata] Run to archive:`,
-            JSON.stringify(runToArchive, null, 2),
-          );
-
-          updatedMetadata.historicalRuns = [
-            ...(updatedMetadata.historicalRuns || []),
-            runToArchive,
-          ];
-
-          console.log(
-            `[updateCommitMetadata] Historical runs after archiving: ${updatedMetadata.historicalRuns.length}`,
-          );
-          console.log(
-            `[updateCommitMetadata] All historical runs:`,
-            JSON.stringify(
-              updatedMetadata.historicalRuns.map((r) => ({
-                entityShas: r.currentEntityShas,
-                archivedAt: r.archivedAt,
-                completed: {
-                  analyses: r.analysesCompleted,
-                  captures: r.capturesCompleted,
-                },
-              })),
-              null,
-              2,
-            ),
-          );
-          console.log(
-            `[updateCommitMetadata] ========================================`,
-          );
-        }
-
-        // Allow callback to perform complex atomic updates
-        if (updateCallback) {
-          await updateCallback(updatedMetadata);
-        }
-
-        try {
-          const result = await trx
-            .updateTable('commits')
-            .set({ metadata: JSON.stringify(updatedMetadata) })
-            .where('id', '=', commit.id)
-            .returning(['id']) // Don't return all columns - files can be 1MB+
-            .executeTakeFirst();
+          // Allow callback to perform complex atomic updates
+          if (updateCallback) {
+            await updateCallback(updatedMetadata);
+          }
 
-          if (!result) {
+          try {
+            const result = await trx
+              .updateTable('commits')
+              .set({ metadata: JSON.stringify(updatedMetadata) })
+              .where('id', '=', commit.id)
+              .returning(['id']) // Don't return all columns - files can be 1MB+
+              .executeTakeFirst();
+
+            if (!result) {
+              awsLog(
+                `CodeYam Error: updateCommitMetadata(): Failed to update commit ${commitId}`,
+              );
+              return currentMetadata;
+            }
+
+            return updatedMetadata;
+          } catch (error) {
             awsLog(
               `CodeYam Error: updateCommitMetadata(): Failed to update commit ${commitId}`,
+              error,
             );
             return currentMetadata;
           }
-
-          return updatedMetadata;
-        } catch (error) {
-          awsLog(
-            `CodeYam Error: updateCommitMetadata(): Failed to update commit ${commitId}`,
-            error,
-          );
-          return currentMetadata;
-        }
-      });
-  } catch (error) {
-    awsLog(
-      `CodeYam Error: updateCommitMetadata(): Transaction failed for commit ${commitId}`,
-      error,
-    );
-    return null;
+        });
+    } catch (error) {
+      const isBusy =
+        error instanceof Error && error.message.includes('database is locked');
+
+      if (isBusy && attempt < MAX_RETRIES) {
+        const delay = BASE_DELAY_MS * Math.pow(2, attempt);
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        continue;
+      }
+
+      awsLog(
+        `CodeYam Error: updateCommitMetadata(): Transaction failed for commit ${commitId}${isBusy ? ` after ${attempt + 1} attempts` : ''}`,
+        error,
+      );
+      return null;
+    }
   }
+
+  return null;
 }

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

@@ -12,53 +12,69 @@ export default async function updateFreshAnalysisStatus(
   fn: (status: AnalysisStatus, analysis: ReadonlyAnalysis) => void,
   source = 'capture',
 ): Promise<AnalysisStatus | null> {
-  try {
-    return await getDatabase()
-      .transaction()
-      .execute(async (trx) => {
-        const dbAnalysis = await trx
-          .selectFrom('analyses')
-          .selectAll()
-          .where('id', '=', id)
-          .executeTakeFirst();
+  const MAX_RETRIES = 4;
+  const BASE_DELAY_MS = 250;
 
-        if (!dbAnalysis) {
-          awsLog(
-            `CodeYam Error: updateFreshAnalysisStatus(): Analysis ${id} not found (source: ${source})`,
-            null,
-            { analysisId: id, source },
-          );
-          return null;
-        }
+  for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+    try {
+      return await getDatabase()
+        .transaction()
+        .execute(async (trx) => {
+          const dbAnalysis = await trx
+            .selectFrom('analyses')
+            .selectAll()
+            .where('id', '=', id)
+            .executeTakeFirst();
 
-        const analysis = dbToAnalysis(dbAnalysis);
+          if (!dbAnalysis) {
+            awsLog(
+              `CodeYam Error: updateFreshAnalysisStatus(): Analysis ${id} not found (source: ${source})`,
+              null,
+              { analysisId: id, source },
+            );
+            return null;
+          }
 
-        fn(analysis.status, analysis);
+          const analysis = dbToAnalysis(dbAnalysis);
 
-        const result = await trx
-          .updateTable('analyses')
-          .set({ status: JSON.stringify(analysis.status) })
-          .where('id', '=', id)
-          .returningAll()
-          .executeTakeFirst();
+          fn(analysis.status, analysis);
 
-        if (!result) {
-          awsLog(
-            `CodeYam Error: updateFreshAnalysisStatus(): Failed to update analysis ${id} (source: ${source})`,
-            null,
-            { analysisId: id, source },
-          );
-          return null;
-        }
+          const result = await trx
+            .updateTable('analyses')
+            .set({ status: JSON.stringify(analysis.status) })
+            .where('id', '=', id)
+            .returningAll()
+            .executeTakeFirst();
 
-        return analysis.status;
-      });
-  } catch (error) {
-    awsLog(
-      `CodeYam Error: updateFreshAnalysisStatus(): Transaction failed for analysis ${id} (source: ${source})`,
-      error,
-      { analysisId: id, source },
-    );
-    return null;
+          if (!result) {
+            awsLog(
+              `CodeYam Error: updateFreshAnalysisStatus(): Failed to update analysis ${id} (source: ${source})`,
+              null,
+              { analysisId: id, source },
+            );
+            return null;
+          }
+
+          return analysis.status;
+        });
+    } catch (error) {
+      const isBusy =
+        error instanceof Error && error.message.includes('database is locked');
+
+      if (isBusy && attempt < MAX_RETRIES) {
+        const delay = BASE_DELAY_MS * Math.pow(2, attempt);
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        continue;
+      }
+
+      awsLog(
+        `CodeYam Error: updateFreshAnalysisStatus(): Transaction failed for analysis ${id} (source: ${source})${isBusy ? ` after ${attempt + 1} attempts` : ''}`,
+        error,
+        { analysisId: id, source },
+      );
+      return null;
+    }
   }
+
+  return null;
 }