@codeyam/codeyam-cli 0.1.0-staging.b8f4f94 → 0.1.0-staging.ba3f279

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

@@ -1,4 +1,8 @@
-import { buildReverseDependencyGraph, classifyDirectChanges, computeEntityChangeStatus, buildChangedFilesMap, pageNameFromUrl, buildEntityInfosFromScenarios, filterGroupsByChangeStatus, } from "../entityChangeStatus.js";
+import { buildReverseDependencyGraph, classifyDirectChanges, computeEntityChangeStatus, buildChangedFilesMap, pageNameFromUrl, isIsolationUrl, scenarioEntityName, buildEntityInfosFromScenarios, buildEntityInfosFromGlossary, filterGroupsByChangeStatus, filterGlossaryByChangeStatus, filterScenarioScreenshotsByChangeStatus, } from "../entityChangeStatus.js";
+import { scanPageFilePaths, detectFirstFeature, readFeatureStartedAt, readEditorStep, readEditorSessionId, readSavedActiveScenarioId, } from "../entityChangeStatus.server.js";
+import * as fsModule from 'fs';
+import * as pathModule from 'path';
+import * as os from 'os';
 // ── Helpers ──────────────────────────────────────────────────────────────
 /** Shorthand to build an EntityInfo with importedBy metadata */
 function entity(name, filePath, importedBy) {
@@ -124,10 +128,20 @@ describe('entityChangeStatus', () => {
             // This is an edge case — empty string is falsy so returns Home
             expect(pageNameFromUrl('')).toBe('Home');
         });
+        it('should return Home for root path with query string', () => {
+            expect(pageNameFromUrl('/?demo=empty')).toBe('Home');
+            expect(pageNameFromUrl('/?state=seeded')).toBe('Home');
+            expect(pageNameFromUrl('/?tab=overview&sort=date')).toBe('Home');
+        });
         it('should handle dynamic route segments', () => {
             expect(pageNameFromUrl('/drinks/[id]')).toBe('Drinks');
             expect(pageNameFromUrl('/users/[userId]/posts')).toBe('Users');
         });
+        it('should strip file extensions from URL segments', () => {
+            expect(pageNameFromUrl('/library.html')).toBe('Library');
+            expect(pageNameFromUrl('/about.htm')).toBe('About');
+            expect(pageNameFromUrl('/library.html?article=a1')).toBe('Library');
+        });
     });
     // ── buildEntityInfosFromScenarios ─────────────────────────────────────
     describe('buildEntityInfosFromScenarios', () => {
@@ -1040,6 +1054,34 @@ describe('entityChangeStatus', () => {
             expect(result).toHaveLength(1);
             expect(result[0].importedBy).toBeDefined();
         });
+        it('should use displayName for non-app/ pageFilePath instead of collapsing to Home', () => {
+            // Margo bug: Chrome extension has two entry points:
+            //   "/" → src/popup/App.tsx (Home)
+            //   "/library.html" → src/library/FullPageLibrary.tsx (Library)
+            // Without displayName, buildRoutePattern('src/library/FullPageLibrary.tsx')
+            // returns '/' since it doesn't start with 'app/', collapsing both to "Home".
+            const scenarios = [
+                {
+                    componentName: null,
+                    componentPath: null,
+                    url: '/',
+                    pageFilePath: 'src/popup/App.tsx',
+                    displayName: 'Home',
+                },
+                {
+                    componentName: null,
+                    componentPath: null,
+                    url: '/library.html',
+                    pageFilePath: 'src/library/FullPageLibrary.tsx',
+                    displayName: 'Library',
+                },
+            ];
+            const result = buildEntityInfosFromScenarios(scenarios, {}, []);
+            expect(result).toHaveLength(2);
+            expect(result.map((e) => e.name).sort()).toEqual(['Home', 'Library']);
+            expect(result.find((e) => e.name === 'Home')?.filePath).toBe('src/popup/App.tsx');
+            expect(result.find((e) => e.name === 'Library')?.filePath).toBe('src/library/FullPageLibrary.tsx');
+        });
     });
     // ── Full pipeline regression tests ───────────────────────────────
     describe('full pipeline regression tests', () => {
@@ -1213,5 +1255,867 @@ describe('entityChangeStatus', () => {
             expect(result).toEqual([]);
         });
     });
+    // ── buildEntityInfosFromGlossary ────────────────────────────────────
+    describe('buildEntityInfosFromGlossary', () => {
+        it('should convert glossary entries to EntityInfo with name and filePath', () => {
+            const glossary = [
+                { name: 'pad', filePath: 'app/lib/calendar.ts' },
+                { name: 'formatDate', filePath: 'app/lib/calendar.ts' },
+            ];
+            const result = buildEntityInfosFromGlossary(glossary);
+            expect(result).toEqual([
+                { name: 'pad', filePath: 'app/lib/calendar.ts' },
+                { name: 'formatDate', filePath: 'app/lib/calendar.ts' },
+            ]);
+        });
+        it('should deduplicate by name (first occurrence wins)', () => {
+            const glossary = [
+                { name: 'pad', filePath: 'app/lib/calendar.ts' },
+                { name: 'pad', filePath: 'app/lib/other.ts' },
+            ];
+            const result = buildEntityInfosFromGlossary(glossary);
+            expect(result).toHaveLength(1);
+            expect(result[0].filePath).toBe('app/lib/calendar.ts');
+        });
+        it('should skip entries already present in existingNames set', () => {
+            const glossary = [
+                { name: 'Home', filePath: 'app/lib/calendar.ts' },
+                { name: 'pad', filePath: 'app/lib/calendar.ts' },
+            ];
+            const existing = new Set(['Home']);
+            const result = buildEntityInfosFromGlossary(glossary, existing);
+            expect(result).toHaveLength(1);
+            expect(result[0].name).toBe('pad');
+        });
+        it('should return empty array for empty input', () => {
+            expect(buildEntityInfosFromGlossary([])).toEqual([]);
+        });
+    });
+    // ── filterGlossaryByChangeStatus ──────────────────────────────────────
+    describe('filterGlossaryByChangeStatus', () => {
+        const functions = [
+            {
+                name: 'pad',
+                filePath: 'lib/calendar.ts',
+                description: '',
+                testFile: 'test.ts',
+            },
+            {
+                name: 'formatDate',
+                filePath: 'lib/calendar.ts',
+                description: '',
+                testFile: 'test.ts',
+            },
+            {
+                name: 'getDays',
+                filePath: 'lib/calendar.ts',
+                description: '',
+                testFile: 'test.ts',
+            },
+        ];
+        it('should return all functions when entityChangeStatus is undefined', () => {
+            expect(filterGlossaryByChangeStatus(functions, undefined)).toEqual(functions);
+        });
+        it('should return all functions when entityChangeStatus is empty', () => {
+            expect(filterGlossaryByChangeStatus(functions, {})).toEqual(functions);
+        });
+        it('should filter to only functions with a change status', () => {
+            const status = {
+                pad: { status: 'new' },
+                getDays: { status: 'edited' },
+            };
+            const result = filterGlossaryByChangeStatus(functions, status);
+            expect(result).toHaveLength(2);
+            expect(result.map((f) => f.name)).toEqual(['pad', 'getDays']);
+        });
+        it('should return empty array when no functions match', () => {
+            const status = {
+                SomeOtherThing: { status: 'new' },
+            };
+            const result = filterGlossaryByChangeStatus(functions, status);
+            expect(result).toEqual([]);
+        });
+    });
+    // ── scenarioEntityName ──────────────────────────────────────────────
+    describe('scenarioEntityName', () => {
+        it('should return componentName when set', () => {
+            expect(scenarioEntityName({
+                componentName: 'ReviewCard',
+                url: '/isolated-components/ReviewCard?s=Default',
+            })).toBe('ReviewCard');
+        });
+        it('should return page name from URL when componentName is null', () => {
+            expect(scenarioEntityName({ componentName: null, url: '/drinks/1' })).toBe('Drinks');
+        });
+        it('should return Home for root URL when componentName is null', () => {
+            expect(scenarioEntityName({ componentName: null, url: '/' })).toBe('Home');
+        });
+        it('should return Home when both componentName and url are null', () => {
+            expect(scenarioEntityName({ componentName: null, url: null })).toBe('Home');
+        });
+        it('should return page name when componentName is undefined', () => {
+            expect(scenarioEntityName({ url: '/settings' })).toBe('Settings');
+        });
+        it('should return Home when no fields provided', () => {
+            expect(scenarioEntityName({})).toBe('Home');
+        });
+    });
+    // ── filterScenarioScreenshotsByChangeStatus ───────────────────────────
+    describe('filterScenarioScreenshotsByChangeStatus', () => {
+        it('should return all screenshots when entityChangeStatus is undefined', () => {
+            const screenshots = [
+                { name: 'Busy Month', path: 'busy.png', componentName: null, url: '/' },
+                {
+                    name: 'EventPill - Default',
+                    path: 'pill.png',
+                    componentName: 'EventPill',
+                    url: '/isolated-components/EventPill',
+                },
+            ];
+            expect(filterScenarioScreenshotsByChangeStatus(screenshots, undefined)).toEqual(screenshots);
+        });
+        it('should return all screenshots when entityChangeStatus is empty', () => {
+            const screenshots = [
+                { name: 'Busy Month', path: 'busy.png', componentName: null, url: '/' },
+            ];
+            expect(filterScenarioScreenshotsByChangeStatus(screenshots, {})).toEqual(screenshots);
+        });
+        it('should include component scenarios whose entity has a change status', () => {
+            const screenshots = [
+                {
+                    name: 'EventPill - Default',
+                    path: 'pill.png',
+                    componentName: 'EventPill',
+                    url: '/isolated-components/EventPill',
+                },
+                {
+                    name: 'ErrorState - Server Error',
+                    path: 'error.png',
+                    componentName: 'ErrorState',
+                    url: '/isolated-components/ErrorState',
+                },
+                {
+                    name: 'CalendarGrid - Default',
+                    path: 'grid.png',
+                    componentName: 'CalendarGrid',
+                    url: '/isolated-components/CalendarGrid',
+                },
+            ];
+            const status = {
+                ErrorState: { status: 'new' },
+                EventPill: { status: 'edited' },
+            };
+            const result = filterScenarioScreenshotsByChangeStatus(screenshots, status);
+            expect(result.map((s) => s.name)).toEqual([
+                'EventPill - Default',
+                'ErrorState - Server Error',
+            ]);
+        });
+        it('should include page scenarios whose page entity has a change status', () => {
+            const screenshots = [
+                { name: 'Busy Month', path: 'busy.png', componentName: null, url: '/' },
+                {
+                    name: 'Empty Calendar',
+                    path: 'empty.png',
+                    componentName: null,
+                    url: '/',
+                },
+            ];
+            const status = {
+                Home: { status: 'edited' },
+            };
+            const result = filterScenarioScreenshotsByChangeStatus(screenshots, status);
+            expect(result).toEqual(screenshots);
+        });
+        it('should exclude page scenarios when their page entity has no status', () => {
+            const screenshots = [
+                { name: 'Busy Month', path: 'busy.png', componentName: null, url: '/' },
+                {
+                    name: 'EventPill - Default',
+                    path: 'pill.png',
+                    componentName: 'EventPill',
+                    url: '/isolated-components/EventPill',
+                },
+            ];
+            const status = {
+                SomeComponent: { status: 'new' },
+            };
+            const result = filterScenarioScreenshotsByChangeStatus(screenshots, status);
+            // Home page has no status, so "Busy Month" is excluded
+            // SomeComponent doesn't match EventPill either
+            expect(result).toEqual([]);
+        });
+        it('should include both page and component scenarios when both entities have status', () => {
+            const screenshots = [
+                { name: 'Busy Month', path: 'busy.png', componentName: null, url: '/' },
+                {
+                    name: 'Empty Calendar',
+                    path: 'empty.png',
+                    componentName: null,
+                    url: '/',
+                },
+                {
+                    name: 'EventPill - Default',
+                    path: 'pill.png',
+                    componentName: 'EventPill',
+                    url: '/isolated-components/EventPill',
+                },
+            ];
+            const status = {
+                Home: { status: 'edited' },
+                EventPill: { status: 'new' },
+            };
+            const result = filterScenarioScreenshotsByChangeStatus(screenshots, status);
+            expect(result.map((s) => s.name)).toEqual([
+                'Busy Month',
+                'Empty Calendar',
+                'EventPill - Default',
+            ]);
+        });
+        it('should handle page scenarios with dashes in names using URL, not name parsing', () => {
+            // The original bug: "Drink Detail - Earl Grey" was parsed as component "Drink Detail"
+            const screenshots = [
+                {
+                    name: 'Drink Detail - Earl Grey',
+                    path: 'earl.png',
+                    componentName: null,
+                    url: '/drinks/1',
+                },
+                {
+                    name: 'Drink Detail - No Reviews',
+                    path: 'no-reviews.png',
+                    componentName: null,
+                    url: '/drinks/1',
+                },
+                {
+                    name: 'ReviewCard - Default',
+                    path: 'review.png',
+                    componentName: 'ReviewCard',
+                    url: '/isolated-components/ReviewCard',
+                },
+                {
+                    name: 'Full Catalog',
+                    path: 'catalog.png',
+                    componentName: null,
+                    url: '/',
+                },
+            ];
+            const status = {
+                Drinks: { status: 'new' },
+                ReviewCard: { status: 'new' },
+                Home: { status: 'edited' },
+            };
+            const result = filterScenarioScreenshotsByChangeStatus(screenshots, status);
+            expect(result.map((s) => s.name)).toEqual([
+                'Drink Detail - Earl Grey',
+                'Drink Detail - No Reviews',
+                'ReviewCard - Default',
+                'Full Catalog',
+            ]);
+        });
+        it('should exclude page scenarios for unchanged pages even with dashes in names', () => {
+            const screenshots = [
+                {
+                    name: 'Drink Detail - Earl Grey',
+                    path: 'earl.png',
+                    componentName: null,
+                    url: '/drinks/1',
+                },
+                {
+                    name: 'ReviewCard - Default',
+                    path: 'review.png',
+                    componentName: 'ReviewCard',
+                    url: '/isolated-components/ReviewCard',
+                },
+            ];
+            const status = {
+                ReviewCard: { status: 'edited' },
+            };
+            const result = filterScenarioScreenshotsByChangeStatus(screenshots, status);
+            // Drinks page has no status, so "Drink Detail" page scenarios are excluded
+            expect(result.map((s) => s.name)).toEqual(['ReviewCard - Default']);
+        });
+        it('should use componentName for matching, not the name prefix', () => {
+            const screenshots = [
+                {
+                    name: 'Card Loading State - Spinner',
+                    path: 'spinner.png',
+                    componentName: 'LoadingCard',
+                    url: '/isolated-components/LoadingCard',
+                },
+            ];
+            const status = {
+                LoadingCard: { status: 'new' },
+            };
+            const result = filterScenarioScreenshotsByChangeStatus(screenshots, status);
+            expect(result.map((s) => s.name)).toEqual([
+                'Card Loading State - Spinner',
+            ]);
+        });
+        it('should exclude component scenario when its entity has no status', () => {
+            const screenshots = [
+                {
+                    name: 'Card Loading State - Spinner',
+                    path: 'spinner.png',
+                    componentName: 'LoadingCard',
+                    url: '/isolated-components/LoadingCard',
+                },
+            ];
+            const status = {
+                SomeOtherComponent: { status: 'new' },
+            };
+            const result = filterScenarioScreenshotsByChangeStatus(screenshots, status);
+            expect(result).toEqual([]);
+        });
+        it('should filter per-page independently (not all-or-nothing for pages)', () => {
+            // Only Drinks page changed, not Home — scenarios for each page should be filtered independently
+            const screenshots = [
+                {
+                    name: 'Full Catalog',
+                    path: 'catalog.png',
+                    componentName: null,
+                    url: '/',
+                },
+                {
+                    name: 'Drink Detail - Earl Grey',
+                    path: 'earl.png',
+                    componentName: null,
+                    url: '/drinks/1',
+                },
+            ];
+            const status = {
+                Drinks: { status: 'new' },
+            };
+            const result = filterScenarioScreenshotsByChangeStatus(screenshots, status);
+            // Home page has no status, so "Full Catalog" is excluded
+            // Drinks page has status, so "Drink Detail" is included
+            expect(result.map((s) => s.name)).toEqual(['Drink Detail - Earl Grey']);
+        });
+        it('should fall back to name-based parsing when componentName is not present (backward compat)', () => {
+            const screenshots = [
+                { name: 'EventPill - Default', path: 'pill.png' },
+                { name: 'Full Calendar', path: 'cal.png' },
+            ];
+            const status = {
+                EventPill: { status: 'new' },
+                Home: { status: 'edited' },
+            };
+            const result = filterScenarioScreenshotsByChangeStatus(screenshots, status);
+            expect(result.map((s) => s.name)).toEqual([
+                'EventPill - Default',
+                'Full Calendar',
+            ]);
+        });
+    });
+    // ── scanPageFilePaths ───────────────────────────────────────────────────
+    describe('scanPageFilePaths', () => {
+        let tempDir;
+        beforeEach(() => {
+            tempDir = fsModule.mkdtempSync(pathModule.join(os.tmpdir(), 'scanpages-test-'));
+        });
+        afterEach(() => {
+            fsModule.rmSync(tempDir, { recursive: true, force: true });
+        });
+        it('should find page.tsx files in nested app/ structure', () => {
+            const appDir = pathModule.join(tempDir, 'app');
+            fsModule.mkdirSync(appDir, { recursive: true });
+            fsModule.writeFileSync(pathModule.join(appDir, 'page.tsx'), '');
+            fsModule.mkdirSync(pathModule.join(appDir, 'drinks'), {
+                recursive: true,
+            });
+            fsModule.writeFileSync(pathModule.join(appDir, 'drinks', 'page.tsx'), '');
+            fsModule.mkdirSync(pathModule.join(appDir, 'settings', 'profile'), {
+                recursive: true,
+            });
+            fsModule.writeFileSync(pathModule.join(appDir, 'settings', 'profile', 'page.tsx'), '');
+            const result = scanPageFilePaths(tempDir);
+            expect(result.map).toEqual({
+                Home: 'app/page.tsx',
+                Drinks: 'app/drinks/page.tsx',
+                Settings: 'app/settings/profile/page.tsx',
+            });
+        });
+        it('should find page.js files', () => {
+            const appDir = pathModule.join(tempDir, 'app');
+            fsModule.mkdirSync(appDir, { recursive: true });
+            fsModule.writeFileSync(pathModule.join(appDir, 'page.js'), '');
+            const result = scanPageFilePaths(tempDir);
+            expect(result.map).toEqual({ Home: 'app/page.js' });
+        });
+        it('should skip isolated-components directories', () => {
+            const appDir = pathModule.join(tempDir, 'app');
+            fsModule.mkdirSync(pathModule.join(appDir, 'isolated-components', 'test'), {
+                recursive: true,
+            });
+            fsModule.writeFileSync(pathModule.join(appDir, 'isolated-components', 'test', 'page.tsx'), '');
+            const result = scanPageFilePaths(tempDir);
+            expect(result.map).toEqual({});
+        });
+        it('should return empty map when app/ does not exist', () => {
+            const result = scanPageFilePaths(tempDir);
+            expect(result.map).toEqual({});
+        });
+        // ── Expo Router support ──────────────────────────────────────────────
+        it('should find index.tsx as Home page (Expo Router)', () => {
+            const appDir = pathModule.join(tempDir, 'app');
+            fsModule.mkdirSync(appDir, { recursive: true });
+            fsModule.writeFileSync(pathModule.join(appDir, 'index.tsx'), '');
+            const result = scanPageFilePaths(tempDir);
+            expect(result.map).toEqual({ Home: 'app/index.tsx' });
+        });
+        it('should find named route files as pages (Expo Router)', () => {
+            const appDir = pathModule.join(tempDir, 'app');
+            fsModule.mkdirSync(appDir, { recursive: true });
+            fsModule.writeFileSync(pathModule.join(appDir, 'index.tsx'), '');
+            fsModule.writeFileSync(pathModule.join(appDir, 'add-tea.tsx'), '');
+            fsModule.mkdirSync(pathModule.join(appDir, 'tea'), { recursive: true });
+            fsModule.writeFileSync(pathModule.join(appDir, 'tea', '[id].tsx'), '');
+            const result = scanPageFilePaths(tempDir);
+            expect(result.map).toEqual({
+                Home: 'app/index.tsx',
+                'Add-tea': 'app/add-tea.tsx',
+                Tea: 'app/tea/[id].tsx',
+            });
+        });
+        it('should skip _layout.tsx files (Expo Router)', () => {
+            const appDir = pathModule.join(tempDir, 'app');
+            fsModule.mkdirSync(appDir, { recursive: true });
+            fsModule.writeFileSync(pathModule.join(appDir, '_layout.tsx'), '');
+            fsModule.writeFileSync(pathModule.join(appDir, 'index.tsx'), '');
+            const result = scanPageFilePaths(tempDir);
+            expect(result.map).toEqual({ Home: 'app/index.tsx' });
+        });
+        it('should handle route groups like (tabs) transparently (Expo Router)', () => {
+            const appDir = pathModule.join(tempDir, 'app');
+            const tabsDir = pathModule.join(appDir, '(tabs)');
+            fsModule.mkdirSync(tabsDir, { recursive: true });
+            fsModule.writeFileSync(pathModule.join(tabsDir, '_layout.tsx'), '');
+            fsModule.writeFileSync(pathModule.join(tabsDir, 'index.tsx'), '');
+            fsModule.writeFileSync(pathModule.join(tabsDir, 'settings.tsx'), '');
+            const result = scanPageFilePaths(tempDir);
+            expect(result.map).toEqual({
+                Home: 'app/(tabs)/index.tsx',
+                Settings: 'app/(tabs)/settings.tsx',
+            });
+        });
+        it('should prefer page.tsx over index.tsx when both exist (Next.js priority)', () => {
+            const appDir = pathModule.join(tempDir, 'app');
+            fsModule.mkdirSync(appDir, { recursive: true });
+            fsModule.writeFileSync(pathModule.join(appDir, 'page.tsx'), '');
+            fsModule.writeFileSync(pathModule.join(appDir, 'index.tsx'), '');
+            const result = scanPageFilePaths(tempDir);
+            expect(result.map).toEqual({ Home: 'app/page.tsx' });
+        });
+        it('should include all page files in allFiles when multiple routes share a page name', () => {
+            const appDir = pathModule.join(tempDir, 'app');
+            fsModule.mkdirSync(appDir, { recursive: true });
+            fsModule.writeFileSync(pathModule.join(appDir, 'page.tsx'), '');
+            fsModule.mkdirSync(pathModule.join(appDir, 'feedback', '[id]', 'edit'), {
+                recursive: true,
+            });
+            fsModule.mkdirSync(pathModule.join(appDir, 'feedback', 'new'), {
+                recursive: true,
+            });
+            fsModule.writeFileSync(pathModule.join(appDir, 'feedback', '[id]', 'page.tsx'), '');
+            fsModule.writeFileSync(pathModule.join(appDir, 'feedback', '[id]', 'edit', 'page.tsx'), '');
+            fsModule.writeFileSync(pathModule.join(appDir, 'feedback', 'new', 'page.tsx'), '');
+            const result = scanPageFilePaths(tempDir);
+            // Map picks one canonical file per page name
+            expect(result.map['Home']).toBe('app/page.tsx');
+            expect(result.map['Feedback']).toBeDefined();
+            // allFiles includes ALL page files, even those that collided on page name
+            expect(result.allFiles.sort()).toEqual([
+                'app/feedback/[id]/edit/page.tsx',
+                'app/feedback/[id]/page.tsx',
+                'app/feedback/new/page.tsx',
+                'app/page.tsx',
+            ]);
+        });
+    });
+    // ── detectFirstFeature ─────────────────────────────────────────────────
+    describe('detectFirstFeature', () => {
+        it('should return true when git has 0 or 1 commits', () => {
+            const tempDir = fsModule.mkdtempSync(pathModule.join(os.tmpdir(), 'firstfeat-test-'));
+            try {
+                // Init a git repo with no commits
+                require('child_process').execSync('git init', {
+                    cwd: tempDir,
+                    stdio: 'ignore',
+                });
+                expect(detectFirstFeature(tempDir)).toBe(true);
+            }
+            finally {
+                fsModule.rmSync(tempDir, { recursive: true, force: true });
+            }
+        });
+        it('should return false when git has multiple commits', () => {
+            const tempDir = fsModule.mkdtempSync(pathModule.join(os.tmpdir(), 'firstfeat-test-'));
+            try {
+                require('child_process').execSync('git init && git config user.email "test@test.com" && git config user.name "test" && git commit --allow-empty -m "first" && git commit --allow-empty -m "second"', { cwd: tempDir, stdio: 'ignore' });
+                expect(detectFirstFeature(tempDir)).toBe(false);
+            }
+            finally {
+                fsModule.rmSync(tempDir, { recursive: true, force: true });
+            }
+        });
+        it('should return true when not a git repo', () => {
+            const tempDir = fsModule.mkdtempSync(pathModule.join(os.tmpdir(), 'firstfeat-test-'));
+            try {
+                expect(detectFirstFeature(tempDir)).toBe(true);
+            }
+            finally {
+                fsModule.rmSync(tempDir, { recursive: true, force: true });
+            }
+        });
+    });
+    // ── readFeatureStartedAt ───────────────────────────────────────────────
+    describe('readFeatureStartedAt', () => {
+        let tempDir;
+        beforeEach(() => {
+            tempDir = fsModule.mkdtempSync(pathModule.join(os.tmpdir(), 'featurets-test-'));
+            fsModule.mkdirSync(pathModule.join(tempDir, '.codeyam'), {
+                recursive: true,
+            });
+        });
+        afterEach(() => {
+            fsModule.rmSync(tempDir, { recursive: true, force: true });
+        });
+        it('should return featureStartedAt from editor-step.json', () => {
+            fsModule.writeFileSync(pathModule.join(tempDir, '.codeyam', 'editor-step.json'), JSON.stringify({ featureStartedAt: '2026-03-01T10:00:00.000Z' }));
+            expect(readFeatureStartedAt(tempDir)).toBe('2026-03-01T10:00:00.000Z');
+        });
+        it('should return null when file does not exist', () => {
+            expect(readFeatureStartedAt(tempDir)).toBeNull();
+        });
+        it('should return null when featureStartedAt is not set', () => {
+            fsModule.writeFileSync(pathModule.join(tempDir, '.codeyam', 'editor-step.json'), JSON.stringify({ step: 5 }));
+            expect(readFeatureStartedAt(tempDir)).toBeNull();
+        });
+        it('should return null for invalid JSON', () => {
+            fsModule.writeFileSync(pathModule.join(tempDir, '.codeyam', 'editor-step.json'), 'not json');
+            expect(readFeatureStartedAt(tempDir)).toBeNull();
+        });
+    });
+    // ── readEditorStep ──────────────────────────────────────────────────────
+    describe('readEditorStep', () => {
+        let tempDir;
+        beforeEach(() => {
+            tempDir = fsModule.mkdtempSync(pathModule.join(os.tmpdir(), 'editorstep-test-'));
+            fsModule.mkdirSync(pathModule.join(tempDir, '.codeyam'), {
+                recursive: true,
+            });
+        });
+        afterEach(() => {
+            fsModule.rmSync(tempDir, { recursive: true, force: true });
+        });
+        it('should return step and label from editor-step.json', () => {
+            fsModule.writeFileSync(pathModule.join(tempDir, '.codeyam', 'editor-step.json'), JSON.stringify({ step: 3, label: 'Confirm', feature: 'Add login' }));
+            expect(readEditorStep(tempDir)).toEqual({ step: 3, label: 'Confirm' });
+        });
+        it('should return null when file does not exist', () => {
+            expect(readEditorStep(tempDir)).toBeNull();
+        });
+        it('should return null when step field is missing', () => {
+            fsModule.writeFileSync(pathModule.join(tempDir, '.codeyam', 'editor-step.json'), JSON.stringify({ feature: 'Add login' }));
+            expect(readEditorStep(tempDir)).toBeNull();
+        });
+        it('should return null for invalid JSON', () => {
+            fsModule.writeFileSync(pathModule.join(tempDir, '.codeyam', 'editor-step.json'), 'not json');
+            expect(readEditorStep(tempDir)).toBeNull();
+        });
+    });
+    // ── readEditorSessionId ─────────────────────────────────────────────────
+    describe('readEditorSessionId', () => {
+        let tempDir;
+        beforeEach(() => {
+            tempDir = fsModule.mkdtempSync(pathModule.join(os.tmpdir(), 'sessionid-test-'));
+            fsModule.mkdirSync(pathModule.join(tempDir, '.codeyam'), {
+                recursive: true,
+            });
+        });
+        afterEach(() => {
+            fsModule.rmSync(tempDir, { recursive: true, force: true });
+        });
+        it('should return session ID from claude-session-id.txt', () => {
+            const uuid = '550e8400-e29b-41d4-a716-446655440000';
+            fsModule.writeFileSync(pathModule.join(tempDir, '.codeyam', 'claude-session-id.txt'), uuid);
+            expect(readEditorSessionId(tempDir)).toBe(uuid);
+        });
+        it('should trim whitespace from session ID', () => {
+            fsModule.writeFileSync(pathModule.join(tempDir, '.codeyam', 'claude-session-id.txt'), '  abc-123  \n');
+            expect(readEditorSessionId(tempDir)).toBe('abc-123');
+        });
+        it('should return null when file does not exist', () => {
+            expect(readEditorSessionId(tempDir)).toBeNull();
+        });
+        it('should return null when file is empty', () => {
+            fsModule.writeFileSync(pathModule.join(tempDir, '.codeyam', 'claude-session-id.txt'), '');
+            expect(readEditorSessionId(tempDir)).toBeNull();
+        });
+    });
+    describe('isIsolationUrl', () => {
+        it('should return true for /isolated-components/ URLs', () => {
+            expect(isIsolationUrl('/isolated-components/Foo')).toBe(true);
+            expect(isIsolationUrl('/isolated-components/Foo?s=Default')).toBe(true);
+        });
+        it('should return true for /codeyam-isolate/ URLs', () => {
+            expect(isIsolationUrl('/codeyam-isolate/Foo')).toBe(true);
+            expect(isIsolationUrl('/codeyam-isolate/Foo?s=Default')).toBe(true);
+        });
+        it('should return false for regular page URLs', () => {
+            expect(isIsolationUrl('/library')).toBe(false);
+            expect(isIsolationUrl('/drinks/1')).toBe(false);
+            expect(isIsolationUrl('/')).toBe(false);
+        });
+        it('should return false for null/undefined', () => {
+            expect(isIsolationUrl(null)).toBe(false);
+            expect(isIsolationUrl(undefined)).toBe(false);
+        });
+    });
+    // ── buildReverseDependencyGraph: filePath-based importer resolution ────
+    describe('buildReverseDependencyGraph — filePath-based resolution', () => {
+        it('should resolve importer via filePath when DB name differs from display name', () => {
+            // In Margo Reader: ArticleTable's importedBy lists "LibraryPage" as importer name
+            // under filePath "app/library/page.tsx". But the entity list has name "Library"
+            // with filePath "app/library/page.tsx". The reverse graph should map
+            // ArticleTable → {"Library"} (not "LibraryPage").
+            const entities = [
+                {
+                    name: 'ArticleTable',
+                    filePath: 'app/components/ArticleTable.tsx',
+                    importedBy: {
+                        'app/library/page.tsx': {
+                            LibraryPage: { shas: ['sha1'] },
+                        },
+                    },
+                },
+                {
+                    name: 'Library',
+                    filePath: 'app/library/page.tsx',
+                },
+            ];
+            const graph = buildReverseDependencyGraph(entities);
+            expect(graph.get('ArticleTable')).toEqual(new Set(['Library']));
+        });
+        it('should fall back to DB importer name when filePath has no matching entity', () => {
+            // When the importer filePath doesn't match any entity in the list,
+            // fall back to the DB's importer name.
+            const entities = [
+                {
+                    name: 'Button',
+                    filePath: 'components/Button.tsx',
+                    importedBy: {
+                        'components/UnknownPage.tsx': {
+                            SomeComponent: { shas: ['sha1'] },
+                        },
+                    },
+                },
+            ];
+            const graph = buildReverseDependencyGraph(entities);
+            expect(graph.get('Button')).toEqual(new Set(['SomeComponent']));
+        });
+        it('should resolve multiple importers via filePath correctly', () => {
+            const entities = [
+                {
+                    name: 'ArticleTableRow',
+                    filePath: 'app/components/ArticleTableRow.tsx',
+                    importedBy: {
+                        'app/components/ArticleTable.tsx': {
+                            ArticleTable: { shas: ['sha1'] },
+                        },
+                        'app/library/page.tsx': {
+                            LibraryPage: { shas: ['sha2'] },
+                        },
+                    },
+                },
+                {
+                    name: 'ArticleTable',
+                    filePath: 'app/components/ArticleTable.tsx',
+                },
+                {
+                    name: 'Library',
+                    filePath: 'app/library/page.tsx',
+                },
+            ];
+            const graph = buildReverseDependencyGraph(entities);
+            expect(graph.get('ArticleTableRow')).toEqual(new Set(['ArticleTable', 'Library']));
+        });
+    });
+    // ── buildEntityInfosFromScenarios: filePath-based metadata matching ────
+    describe('buildEntityInfosFromScenarios — filePath-based metadata matching', () => {
+        it('should attach importedBy metadata when entity names differ but filePaths match', () => {
+            // Page scenario with displayName "Library" but DB entity named "LibraryPage"
+            // with filePath "app/library/page.tsx". The metadata lookup should match by
+            // filePath and attach importedBy.
+            const scenarios = [
+                {
+                    componentName: null,
+                    componentPath: null,
+                    pageFilePath: 'app/library/page.tsx',
+                    url: '/library',
+                    displayName: 'Library',
+                },
+            ];
+            const entitiesWithMetadata = [
+                {
+                    name: 'LibraryPage',
+                    filePath: 'app/library/page.tsx',
+                    metadata: {
+                        importedBy: {
+                            'app/layout.tsx': {
+                                RootLayout: { shas: ['sha1'] },
+                            },
+                        },
+                    },
+                },
+            ];
+            const result = buildEntityInfosFromScenarios(scenarios, {}, entitiesWithMetadata);
+            expect(result).toHaveLength(1);
+            expect(result[0].name).toBe('Library');
+            expect(result[0].importedBy).toEqual({
+                'app/layout.tsx': {
+                    RootLayout: { shas: ['sha1'] },
+                },
+            });
+        });
+        it('should prefer name match over filePath match in multi-entity files', () => {
+            // Bug: app/components/ArticleTable.tsx exports both Props (rowid 33) and
+            // ArticleTable (rowid 34). find() with OR condition matches Props first
+            // via filePath, so ArticleTable gets Props' importedBy (missing the
+            // critical ArticleTable → LibraryPage edge). Fix: try name match first.
+            const scenarios = [
+                {
+                    componentName: 'ArticleTable',
+                    componentPath: 'app/components/ArticleTable.tsx',
+                },
+            ];
+            const entitiesWithMetadata = [
+                {
+                    name: 'Props',
+                    filePath: 'app/components/ArticleTable.tsx',
+                    metadata: {
+                        importedBy: {
+                            'app/components/ArticleTable.tsx': {
+                                ArticleTable: { shas: ['sha-internal'] },
+                            },
+                        },
+                    },
+                },
+                {
+                    name: 'ArticleTable',
+                    filePath: 'app/components/ArticleTable.tsx',
+                    metadata: {
+                        importedBy: {
+                            'app/library/page.tsx': {
+                                LibraryPage: { shas: ['sha1'] },
+                            },
+                        },
+                    },
+                },
+            ];
+            const result = buildEntityInfosFromScenarios(scenarios, {}, entitiesWithMetadata);
+            expect(result).toHaveLength(1);
+            expect(result[0].name).toBe('ArticleTable');
+            // Must get ArticleTable's importedBy (LibraryPage), NOT Props' importedBy
+            expect(result[0].importedBy).toEqual({
+                'app/library/page.tsx': {
+                    LibraryPage: { shas: ['sha1'] },
+                },
+            });
+        });
+        it('should still match by name when names are identical', () => {
+            const scenarios = [
+                {
+                    componentName: 'ArticleTable',
+                    componentPath: 'app/components/ArticleTable.tsx',
+                },
+            ];
+            const entitiesWithMetadata = [
+                {
+                    name: 'ArticleTable',
+                    filePath: 'app/components/ArticleTable.tsx',
+                    metadata: {
+                        importedBy: {
+                            'app/library/page.tsx': {
+                                LibraryPage: { shas: ['sha1'] },
+                            },
+                        },
+                    },
+                },
+            ];
+            const result = buildEntityInfosFromScenarios(scenarios, {}, entitiesWithMetadata);
+            expect(result[0].importedBy).toBeDefined();
+        });
+    });
+    // ── End-to-end: filePath resolution enables impact propagation ────
+    describe('end-to-end: filePath resolution enables page impact detection', () => {
+        it('should detect Library page as impacted when ArticleTable is edited', () => {
+            // This is the Margo Reader bug: ArticleTable is edited, Library page
+            // should be detected as impacted because ArticleTable's importedBy
+            // metadata shows it's imported by "app/library/page.tsx" → "Library".
+            const changedFiles = new Map([
+                ['app/components/ArticleTable.tsx', 'edited'],
+            ]);
+            const entities = [
+                {
+                    name: 'ArticleTable',
+                    filePath: 'app/components/ArticleTable.tsx',
+                    importedBy: {
+                        'app/library/page.tsx': {
+                            LibraryPage: { shas: ['sha1'] },
+                        },
+                    },
+                },
+                {
+                    name: 'Library',
+                    filePath: 'app/library/page.tsx',
+                },
+            ];
+            const result = computeEntityChangeStatus(changedFiles, entities);
+            expect(result['ArticleTable']).toEqual({ status: 'edited' });
+            expect(result['Library']).toEqual({
+                status: 'impacted',
+                impactedBy: [
+                    {
+                        name: 'ArticleTable',
+                        filePath: 'app/components/ArticleTable.tsx',
+                        changeType: 'edited',
+                    },
+                ],
+            });
+        });
+    });
+    // ── readSavedActiveScenarioId ─────────────────────────────────────────
+    describe('readSavedActiveScenarioId', () => {
+        let tempDir;
+        beforeEach(() => {
+            tempDir = fsModule.mkdtempSync(pathModule.join(os.tmpdir(), 'activescenario-test-'));
+            fsModule.mkdirSync(pathModule.join(tempDir, '.codeyam'), {
+                recursive: true,
+            });
+        });
+        afterEach(() => {
+            fsModule.rmSync(tempDir, { recursive: true, force: true });
+        });
+        it('should return scenarioId from valid active-scenario.json', () => {
+            fsModule.writeFileSync(pathModule.join(tempDir, '.codeyam', 'active-scenario.json'), JSON.stringify({
+                scenarioSlug: 'my-scenario',
+                scenarioId: 'abc-123',
+                type: 'application',
+            }));
+            expect(readSavedActiveScenarioId(tempDir)).toBe('abc-123');
+        });
+        it('should return null when file does not exist', () => {
+            expect(readSavedActiveScenarioId(tempDir)).toBeNull();
+        });
+        it('should return null when scenarioId field is missing', () => {
+            fsModule.writeFileSync(pathModule.join(tempDir, '.codeyam', 'active-scenario.json'), JSON.stringify({ scenarioSlug: 'my-scenario', type: 'application' }));
+            expect(readSavedActiveScenarioId(tempDir)).toBeNull();
+        });
+        it('should return null for malformed JSON', () => {
+            fsModule.writeFileSync(pathModule.join(tempDir, '.codeyam', 'active-scenario.json'), 'not json{{');
+            expect(readSavedActiveScenarioId(tempDir)).toBeNull();
+        });
+    });
 });
 //# sourceMappingURL=entityChangeStatus.test.js.map