@codeyam/codeyam-cli 0.1.0-staging.73a4bf4 → 0.1.0-staging.78c1cad

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

@@ -11,15 +11,15 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@aws-sdk/client-codebuild": "^3.948.0",
-    "@aws-sdk/client-cloudwatch-logs": "^3.980.0",
-    "@aws-sdk/client-dynamodb": "^3.956.0",
-    "@aws-sdk/client-ecr": "^3.948.0",
-    "@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.975.0",
-    "@aws-sdk/s3-request-presigner": "^3.940.0",
-    "@aws-sdk/util-dynamodb": "^3.971.0"
+    "@aws-sdk/client-codebuild": "^3.1014.0",
+    "@aws-sdk/client-cloudwatch-logs": "^3.990.0",
+    "@aws-sdk/client-dynamodb": "^3.990.0",
+    "@aws-sdk/client-ecr": "^3.990.0",
+    "@aws-sdk/client-ecs": "^3.1009.0",
+    "@aws-sdk/client-s3": "^3.990.0",
+    "@aws-sdk/client-sqs": "^3.990.0",
+    "@aws-sdk/lib-storage": "^3.990.0",
+    "@aws-sdk/s3-request-presigner": "^3.990.0",
+    "@aws-sdk/util-dynamodb": "^3.990.0"
   }
 }

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/package.json

@@ -13,10 +13,10 @@
   "license": "ISC",
   "dependencies": {
     "@supabase/supabase-js": "2.88.0",
-    "better-sqlite3": "^12.4.1",
+    "better-sqlite3": "^12.6.2",
     "fetch-retry": "^6.0.0",
-    "kysely": "^0.28.11",
-    "pg": "^8.16.3"
+    "kysely": "^0.28.14",
+    "pg": "^8.20.0"
   },
   "jest": {
     "preset": "ts-jest",
@@ -25,7 +25,7 @@
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.13",
     "@types/jest": "^30.0.0",
-    "@types/pg": "^8.15.5",
+    "@types/pg": "^8.18.0",
     "@types/ws": "^8.18.1"
   }
 }

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,164 @@
+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>(),
+  url: schemaField<string | null>(),
+  type: schemaField<string | null>(),
+  screenshot_path: schemaField<string | null>(),
+  viewport_width: schemaField<number | null>(),
+  viewport_height: schemaField<number | null>(),
+  dimensions: schemaField<string | null>(),
+  screenshot_paths: schemaField<string | null>(),
+  page_file_path: schemaField<string | null>(),
+  entity_sha: schemaField<string | null>(),
+  display_name: 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('url', 'varchar')
+    .addColumn('type', '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',
+    'url',
+    'type',
+    'screenshot_path',
+  ] as const) {
+    try {
+      await db.schema
+        .alterTable('editor_scenarios')
+        .addColumn(col, 'varchar')
+        .execute();
+    } catch {
+      // Column already exists — expected for fresh databases
+    }
+  }
+
+  // Integer columns for viewport dimensions
+  for (const col of ['viewport_width', 'viewport_height'] as const) {
+    try {
+      await db.schema
+        .alterTable('editor_scenarios')
+        .addColumn(col, 'integer')
+        .execute();
+    } catch {
+      // Column already exists — expected for fresh databases
+    }
+  }
+
+  // Multi-dimension support: JSON array of dimension names and map of screenshot paths
+  for (const col of ['dimensions', 'screenshot_paths'] as const) {
+    try {
+      await db.schema
+        .alterTable('editor_scenarios')
+        .addColumn(col, 'text')
+        .execute();
+    } catch {
+      // Column already exists — expected for fresh databases
+    }
+  }
+
+  // Route tracking: page file path for application scenarios
+  // Entity association: SHA links scenario to entity, display_name is the human label
+  for (const col of ['page_file_path', 'entity_sha', 'display_name'] as const) {
+    try {
+      await db.schema
+        .alterTable('editor_scenarios')
+        .addColumn(col, 'varchar')
+        .execute();
+    } catch {
+      // Column already exists — expected for fresh databases
+    }
+  }
+
+  // Legacy backfill: migrate old `dimension` column (single string) into `dimensions`
+  // JSON array. Only runs on databases that have the legacy column — new databases
+  // won't have it. Separated from the screenshot_paths backfill below so that
+  // a missing column doesn't skip both migrations.
+  try {
+    const rows = await db
+      .selectFrom('editor_scenarios')
+      .select(['id', 'dimension', 'dimensions'] as any)
+      .execute();
+    for (const row of rows) {
+      const r = row as any;
+      if (r.dimension && !r.dimensions) {
+        await db
+          .updateTable('editor_scenarios')
+          .set({ dimensions: JSON.stringify([r.dimension]) })
+          .where('id', '=', r.id)
+          .execute();
+      }
+    }
+  } catch {
+    // Column doesn't exist (new DB) or other error — skip
+  }
+
+  // Backfill: wrap existing single screenshot_path into screenshot_paths object
+  try {
+    const rows = await db
+      .selectFrom('editor_scenarios')
+      .select(['id', 'screenshot_path', 'screenshot_paths', 'dimensions'])
+      .execute();
+    for (const row of rows) {
+      const r = row as any;
+      if (r.screenshot_path && !r.screenshot_paths) {
+        let dimName = 'Default';
+        try {
+          const dims = r.dimensions ? JSON.parse(r.dimensions) : null;
+          if (Array.isArray(dims) && dims.length > 0) dimName = dims[0];
+        } catch {
+          /* ignore */
+        }
+        await db
+          .updateTable('editor_scenarios')
+          .set({
+            screenshot_paths: JSON.stringify({ [dimName]: r.screenshot_path }),
+          })
+          .where('id', '=', r.id)
+          .execute();
+      }
+    }
+  } catch {
+    // Backfill is best-effort
+  }
+}

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

@@ -173,21 +173,31 @@ export default async function loadAnalysis({
     const queryTime = Date.now() - startTime;
 
     if (!analysis) {
-      awsLog('CodeYam Error: Analysis not found', null, {
-        id,
-        analysisBranchId,
-        projectId,
-        fileId,
-        commitId,
-        entityName,
-        dependencyAnalyzedTreeSha,
-        analyzedTreeSha,
-        includeFile,
-        includeProject,
-        includeCommitAndBranch,
-        includeScenarios,
-        includeBranches,
-      });
+      // When queried by dependencyAnalyzedTreeSha, this is a cache check
+      // (findValidExistingAnalysis pattern). Not finding a cached analysis is
+      // expected for new entities — log as debug, not error.
+      const isExpectedMiss = !!dependencyAnalyzedTreeSha;
+      awsLog(
+        isExpectedMiss
+          ? `CodeYam: Analysis cache miss for dependency tree SHA ${dependencyAnalyzedTreeSha.substring(0, 12)}...`
+          : `CodeYam Error: Analysis not found${entityName ? ` for ${entityName}` : ''}${id ? ` (id=${id})` : ''}`,
+        null,
+        {
+          id,
+          analysisBranchId,
+          projectId,
+          fileId,
+          commitId,
+          entityName,
+          dependencyAnalyzedTreeSha,
+          analyzedTreeSha,
+          includeFile,
+          includeProject,
+          includeCommitAndBranch,
+          includeScenarios,
+          includeBranches,
+        },
+      );
       return null;
     }
 

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/loadEntities.ts

@@ -95,12 +95,6 @@ export default async function loadEntities({
     const entities = await query.execute();
 
     if (!entities || entities.length === 0) {
-      console.log('Load Entities: No entities found', {
-        projectId,
-        fileIds,
-        filePaths,
-        shas,
-      });
       return null;
     }
 

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

@@ -7,6 +7,9 @@ import { getEntityBranchesAsJson } from './loadEntityBranches';
 export interface loadEntityArgs {
   projectId: string;
   sha: string;
+  /** When true, suppress "Entity not found" log. Use when the caller expects
+   *  the entity might not exist (e.g., findOrCreateEntity on fresh databases). */
+  silent?: boolean;
 }
 
 export interface loadEntityByNameAndPathArgs {
@@ -15,7 +18,11 @@ export interface loadEntityByNameAndPathArgs {
   filePath: string;
 }
 
-export default async function loadEntity({ projectId, sha }: loadEntityArgs) {
+export default async function loadEntity({
+  projectId,
+  sha,
+  silent,
+}: loadEntityArgs) {
   const db = getDatabase();
 
   try {
@@ -33,13 +40,17 @@ export default async function loadEntity({ projectId, sha }: loadEntityArgs) {
       .executeTakeFirst();
 
     if (!entity) {
-      // Only log at debug level - Entity not found is expected in E2E baseline mode
-      // where entities are created fresh and don't exist in the database yet
-      if (process.env.CODEYAM_E2E_BASELINE_MODE !== 'true') {
-        awsLog('CodeYam Error: Load Entity: Entity not found', null, {
-          projectId,
-          sha,
-        });
+      // Entity not found is expected in baseline mode (fresh DB) and in
+      // findOrCreateEntity where the caller creates the entity if missing.
+      if (!silent && process.env.CODEYAM_E2E_BASELINE_MODE !== 'true') {
+        awsLog(
+          `CodeYam Error: Load Entity: Entity not found (sha=${sha?.substring(0, 12)})`,
+          null,
+          {
+            projectId,
+            sha,
+          },
+        );
       }
       return null;
     }

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