@codeyam/codeyam-cli 0.1.13 → 0.1.15

package/codeyam-cli/src/utils/__tests__/editorAudit.test.js

@@ -1,6 +1,6 @@
 import Database from 'better-sqlite3';
 import { Kysely, SqliteDialect } from 'kysely';
-import { isComponent, classifyGlossaryEntries, computeAudit, filterGlossaryByChangeStatus, resolveAuditSessionScope, queryScenarioCounts, queryIncompleteEntities, queryMiscategorizedScenarios, isOnlyIncompleteEntities, isAutoRemediable, } from "../editorAudit.js";
+import { isComponent, classifyGlossaryEntries, computeAudit, filterGlossaryByChangeStatus, resolveAuditSessionScope, queryScenarioCounts, queryPageScenarioCounts, queryIncompleteEntities, queryMiscategorizedScenarios, isOnlyIncompleteEntities, isAutoRemediable, identifyScenariosNeedingRecapture, } from "../editorAudit.js";
 describe('editorAudit', () => {
     describe('isComponent', () => {
         it('should return true for JSX.Element return type', () => {
@@ -290,6 +290,29 @@ describe('editorAudit', () => {
             expect(result.functions[0].testsPassing).toBe(false);
             expect(result.functions[0].testsVisibleInUi).toBe(true);
         });
+        it('should distinguish runner errors from test failures and include error message', () => {
+            const result = computeAudit({
+                components: [],
+                functions: [
+                    {
+                        name: 'getTimeAgo',
+                        filePath: 'src/lib/format.ts',
+                        testFile: 'src/lib/format.test.ts',
+                    },
+                ],
+                scenarioCounts: {},
+                testFileExistence: { 'src/lib/format.test.ts': true },
+                testResults: {
+                    'src/lib/format.test.ts': {
+                        passing: false,
+                        hasEntityNameDescribe: false,
+                        errorMessage: 'Error: Cannot find module "@/lib/format" from "src/lib/format.test.ts"',
+                    },
+                },
+            });
+            expect(result.functions[0].status).toBe('runner_error');
+            expect(result.functions[0].errorMessage).toBe('Error: Cannot find module "@/lib/format" from "src/lib/format.test.ts"');
+        });
         it('should mark function as name_mismatch when tests pass but no describe matches', () => {
             const result = computeAudit({
                 components: [],
@@ -983,6 +1006,158 @@ describe('editorAudit', () => {
             expect(counts).toEqual({ ArticleCard: 1, ArticleRow: 1 });
         });
     });
+    // ── queryPageScenarioCounts ──────────────────────────────────────────
+    describe('queryPageScenarioCounts', () => {
+        let db;
+        let rawDb;
+        const projectId = 'test-project-id';
+        beforeEach(async () => {
+            rawDb = new Database(':memory:');
+            db = new Kysely({ dialect: new SqliteDialect({ database: rawDb }) });
+            await db.schema
+                .createTable('editor_scenarios')
+                .addColumn('id', 'varchar', (col) => col.primaryKey())
+                .addColumn('project_id', 'varchar', (col) => col.notNull())
+                .addColumn('name', 'varchar', (col) => col.notNull())
+                .addColumn('description', 'text')
+                .addColumn('component_name', 'varchar')
+                .addColumn('component_path', 'varchar')
+                .addColumn('page_file_path', 'varchar')
+                .addColumn('url', 'varchar')
+                .addColumn('type', 'varchar')
+                .addColumn('screenshot_path', 'varchar')
+                .addColumn('viewport_width', 'integer')
+                .addColumn('viewport_height', 'integer')
+                .addColumn('dimension', 'varchar')
+                .addColumn('created_at', 'datetime')
+                .addColumn('updated_at', 'datetime')
+                .execute();
+        });
+        afterEach(async () => {
+            await db.destroy();
+        });
+        it('should count app-level scenarios by page_file_path', async () => {
+            // App-level scenario: has page_file_path but no component_name
+            await db
+                .insertInto('editor_scenarios')
+                .values({
+                id: 'sc-1',
+                project_id: projectId,
+                name: 'Library - Default',
+                component_name: null,
+                page_file_path: 'app/library/page.tsx',
+                created_at: '2026-03-12 13:00:00',
+            })
+                .execute();
+            await db
+                .insertInto('editor_scenarios')
+                .values({
+                id: 'sc-2',
+                project_id: projectId,
+                name: 'Library - Empty',
+                component_name: null,
+                page_file_path: 'app/library/page.tsx',
+                created_at: '2026-03-12 13:05:00',
+            })
+                .execute();
+            const counts = await queryPageScenarioCounts(db, projectId, null);
+            expect(counts).toEqual({ 'app/library/page.tsx': 2 });
+        });
+        it('should not count component scenarios (those have component_name)', async () => {
+            // Component scenario — should NOT appear in page counts
+            await db
+                .insertInto('editor_scenarios')
+                .values({
+                id: 'sc-1',
+                project_id: projectId,
+                name: 'ArticleRow - Default',
+                component_name: 'ArticleRow',
+                page_file_path: null,
+                created_at: '2026-03-12 13:00:00',
+            })
+                .execute();
+            const counts = await queryPageScenarioCounts(db, projectId, null);
+            expect(counts).toEqual({});
+        });
+        it('should respect featureStartedAt filter', async () => {
+            await db
+                .insertInto('editor_scenarios')
+                .values({
+                id: 'sc-1',
+                project_id: projectId,
+                name: 'Library - Old',
+                component_name: null,
+                page_file_path: 'app/library/page.tsx',
+                created_at: '2026-03-12 13:00:00',
+            })
+                .execute();
+            await db
+                .insertInto('editor_scenarios')
+                .values({
+                id: 'sc-2',
+                project_id: projectId,
+                name: 'Library - New',
+                component_name: null,
+                page_file_path: 'app/library/page.tsx',
+                created_at: '2026-03-12 15:00:00',
+            })
+                .execute();
+            const counts = await queryPageScenarioCounts(db, projectId, '2026-03-12T14:01:31.291Z');
+            expect(counts).toEqual({ 'app/library/page.tsx': 1 });
+        });
+        it('should count re-registered page scenarios via updated_at', async () => {
+            await db
+                .insertInto('editor_scenarios')
+                .values({
+                id: 'sc-1',
+                project_id: projectId,
+                name: 'Library - Default',
+                component_name: null,
+                page_file_path: 'app/library/page.tsx',
+                created_at: '2026-03-12 13:00:00',
+                updated_at: '2026-03-12 15:00:00',
+            })
+                .execute();
+            const counts = await queryPageScenarioCounts(db, projectId, '2026-03-12T14:01:31.291Z');
+            expect(counts).toEqual({ 'app/library/page.tsx': 1 });
+        });
+        it('should group counts by page_file_path across multiple pages', async () => {
+            await db
+                .insertInto('editor_scenarios')
+                .values([
+                {
+                    id: 'sc-1',
+                    project_id: projectId,
+                    name: 'Library - Default',
+                    component_name: null,
+                    page_file_path: 'app/library/page.tsx',
+                    created_at: '2026-03-12 13:00:00',
+                },
+                {
+                    id: 'sc-2',
+                    project_id: projectId,
+                    name: 'Library - Rich',
+                    component_name: null,
+                    page_file_path: 'app/library/page.tsx',
+                    created_at: '2026-03-12 13:00:00',
+                },
+                {
+                    id: 'sc-3',
+                    project_id: projectId,
+                    name: 'Collections - Default',
+                    component_name: null,
+                    page_file_path: 'app/library/collections/page.tsx',
+                    created_at: '2026-03-12 13:00:00',
+                },
+            ])
+                .execute();
+            const counts = await queryPageScenarioCounts(db, projectId, null);
+            expect(counts).toEqual({
+                'app/library/page.tsx': 2,
+                'app/library/collections/page.tsx': 1,
+            });
+        });
+    });
     // ── Audit + entity completeness integration ─────────────────────────
     describe('audit should catch incomplete entities (bug reproduction)', () => {
         let db;
@@ -1856,6 +2031,84 @@ describe('editorAudit', () => {
             const result = await queryIncompleteEntities(db, projectId, null);
             expect(result).toEqual([]);
         });
+        it('should not flag entities when a sibling version (same name+filePath) has analyses', async () => {
+            // Old entity version WITH analysis
+            await db
+                .insertInto('entities')
+                .values({
+                sha: 'sha-btn-v1',
+                name: 'OpenLibraryButton',
+                entity_type: 'visual',
+                file_path: 'src/components/OpenLibraryButton.tsx',
+            })
+                .execute();
+            await db
+                .insertInto('analyses')
+                .values({
+                id: 'a-btn-v1',
+                entity_sha: 'sha-btn-v1',
+                entity_name: 'OpenLibraryButton',
+                project_id: projectId,
+            })
+                .execute();
+            // New entity version WITHOUT analysis (created by file watcher)
+            await db
+                .insertInto('entities')
+                .values({
+                sha: 'sha-btn-v2',
+                name: 'OpenLibraryButton',
+                entity_type: 'visual',
+                file_path: 'src/components/OpenLibraryButton.tsx',
+            })
+                .execute();
+            // Scenario points to the NEW version (backfilled after file watcher)
+            await db
+                .insertInto('editor_scenarios')
+                .values({
+                id: 'sc-btn',
+                project_id: projectId,
+                name: 'OpenLibraryButton - Default',
+                component_name: 'OpenLibraryButton',
+                entity_sha: 'sha-btn-v2',
+                created_at: '2026-03-16 23:00:00',
+            })
+                .execute();
+            // Should NOT flag as incomplete — sibling version has analyses
+            const result = await queryIncompleteEntities(db, projectId, null);
+            expect(result).toEqual([]);
+        });
+        it('should still flag entities when no sibling version has analyses', async () => {
+            // Only one version, no analyses
+            await db
+                .insertInto('entities')
+                .values({
+                sha: 'sha-icon',
+                name: 'ExternalLinkIcon',
+                entity_type: 'visual',
+                file_path: 'src/components/ExternalLinkIcon.tsx',
+            })
+                .execute();
+            await db
+                .insertInto('editor_scenarios')
+                .values({
+                id: 'sc-icon',
+                project_id: projectId,
+                name: 'ExternalLinkIcon - Default',
+                component_name: 'ExternalLinkIcon',
+                entity_sha: 'sha-icon',
+                created_at: '2026-03-16 23:00:00',
+            })
+                .execute();
+            // Should flag as incomplete — no version has analyses
+            const result = await queryIncompleteEntities(db, projectId, null);
+            expect(result).toEqual([
+                {
+                    entitySha: 'sha-icon',
+                    name: 'ExternalLinkIcon',
+                    scenarioCount: 1,
+                },
+            ]);
+        });
         it('should use entity name from entities table, falling back to component_name', async () => {
             // Scenario has entity_sha but entity record doesn't exist
             await db
@@ -1875,5 +2128,191 @@ describe('editorAudit', () => {
             ]);
         });
     });
+    // ── identifyScenariosNeedingRecapture ──────────────────────────────
+    describe('identifyScenariosNeedingRecapture', () => {
+        // Reproduces the Margo bug: Feature 1 built app-level popup scenarios,
+        // Feature 2 edited LibraryView (used by App), but app-level scenarios
+        // were never flagged for recapture because the audit only checked
+        // component scenario existence — not whether app-level scenarios are stale.
+        //
+        // Each scenario's entityName is resolved by the caller via
+        // entity_sha → entities.name (the default export for app-level scenarios).
+        it('should flag app-level scenario when its entity is impacted by transitive dependency change', () => {
+            // LibraryView was edited → App is impacted (imports LibraryView)
+            // App-level scenario "Library - Rich Library" has entity_sha pointing to App
+            // It was NOT recaptured during Feature 2 → should be flagged
+            const entityChangeStatus = {
+                LibraryView: { status: 'edited' },
+                App: {
+                    status: 'impacted',
+                    impactedBy: [
+                        {
+                            name: 'LibraryView',
+                            filePath: 'src/components/LibraryView.tsx',
+                            changeType: 'edited',
+                        },
+                    ],
+                },
+            };
+            const result = identifyScenariosNeedingRecapture({
+                scenarios: [
+                    {
+                        name: 'Library - Rich Library',
+                        entityName: 'App', // resolved from entity_sha → entities.name
+                        updatedInSession: false,
+                    },
+                ],
+                entityChangeStatus,
+            });
+            expect(result).toHaveLength(1);
+            expect(result[0].scenarioName).toBe('Library - Rich Library');
+            expect(result[0].entityName).toBe('App');
+            expect(result[0].status.status).toBe('impacted');
+        });
+        it('should flag component scenario when its entity is directly edited and not recaptured', () => {
+            const entityChangeStatus = {
+                LibraryView: { status: 'edited' },
+            };
+            const result = identifyScenariosNeedingRecapture({
+                scenarios: [
+                    {
+                        name: 'LibraryView - Empty',
+                        entityName: 'LibraryView',
+                        updatedInSession: false,
+                    },
+                ],
+                entityChangeStatus,
+            });
+            expect(result).toHaveLength(1);
+            expect(result[0].scenarioName).toBe('LibraryView - Empty');
+            expect(result[0].entityName).toBe('LibraryView');
+            expect(result[0].status.status).toBe('edited');
+        });
+        it('should NOT flag scenario that was already recaptured in the current session', () => {
+            const entityChangeStatus = {
+                App: {
+                    status: 'impacted',
+                    impactedBy: [
+                        {
+                            name: 'LibraryView',
+                            filePath: 'src/components/LibraryView.tsx',
+                            changeType: 'edited',
+                        },
+                    ],
+                },
+            };
+            const result = identifyScenariosNeedingRecapture({
+                scenarios: [
+                    {
+                        name: 'App - Default',
+                        entityName: 'App',
+                        updatedInSession: true, // re-registered during Feature 2
+                    },
+                ],
+                entityChangeStatus,
+            });
+            expect(result).toHaveLength(0);
+        });
+        it('should NOT flag scenario whose entity has no change status', () => {
+            const entityChangeStatus = {
+                LibraryView: { status: 'edited' },
+            };
+            const result = identifyScenariosNeedingRecapture({
+                scenarios: [
+                    {
+                        name: 'WelcomeScreen - Default',
+                        entityName: 'WelcomeScreen',
+                        updatedInSession: false,
+                    },
+                ],
+                entityChangeStatus,
+            });
+            expect(result).toHaveLength(0);
+        });
+        it('should return empty array when entityChangeStatus is undefined', () => {
+            const result = identifyScenariosNeedingRecapture({
+                scenarios: [
+                    {
+                        name: 'Library - Rich Library',
+                        entityName: 'App',
+                        updatedInSession: false,
+                    },
+                ],
+                entityChangeStatus: undefined,
+            });
+            expect(result).toHaveLength(0);
+        });
+        it('should return empty array when entityChangeStatus is empty', () => {
+            const result = identifyScenariosNeedingRecapture({
+                scenarios: [
+                    {
+                        name: 'Library - Rich Library',
+                        entityName: 'App',
+                        updatedInSession: false,
+                    },
+                ],
+                entityChangeStatus: {},
+            });
+            expect(result).toHaveLength(0);
+        });
+        it('should flag multiple app-level scenarios sharing the same impacted entity', () => {
+            const entityChangeStatus = {
+                LibraryView: { status: 'edited' },
+                App: {
+                    status: 'impacted',
+                    impactedBy: [
+                        {
+                            name: 'LibraryView',
+                            filePath: 'src/components/LibraryView.tsx',
+                            changeType: 'edited',
+                        },
+                    ],
+                },
+            };
+            const result = identifyScenariosNeedingRecapture({
+                scenarios: [
+                    {
+                        name: 'Library - Empty',
+                        entityName: 'App',
+                        updatedInSession: false,
+                    },
+                    {
+                        name: 'Library - Rich Library',
+                        entityName: 'App',
+                        updatedInSession: false,
+                    },
+                    {
+                        name: 'First Article Saved',
+                        entityName: 'App',
+                        updatedInSession: false,
+                    },
+                ],
+                entityChangeStatus,
+            });
+            expect(result).toHaveLength(3);
+            expect(result.map((r) => r.scenarioName).sort()).toEqual([
+                'First Article Saved',
+                'Library - Empty',
+                'Library - Rich Library',
+            ]);
+            expect(result.every((r) => r.entityName === 'App')).toBe(true);
+        });
+        it('should skip scenarios with null entityName (no entity_sha set)', () => {
+            const entityChangeStatus = {
+                App: { status: 'edited' },
+            };
+            const result = identifyScenariosNeedingRecapture({
+                scenarios: [
+                    {
+                        name: 'Mystery Scenario',
+                        entityName: null, // no entity_sha → no entity name
+                        updatedInSession: false,
+                    },
+                ],
+                entityChangeStatus,
+            });
+            expect(result).toHaveLength(0);
+        });
+    });
 });
 //# sourceMappingURL=editorAudit.test.js.map