@auto-engineer/narrative 1.139.0 → 1.140.0

package/src/{getNarratives.cache.specs.ts → getScenes.cache.specs.ts}

@@ -3,7 +3,7 @@ import gql from 'graphql-tag';
 import { beforeEach, describe, expect, it } from 'vitest';
 import * as dataBuilders from './data-narrative-builders';
 import * as fluent from './fluent-builder';
-import { clearGetNarrativesCache, getNarratives } from './getNarratives';
+import { clearGetScenesCache, getScenes } from './getScenes';
 import * as flowApi from './narrative';
 import * as typesApi from './types';
 
@@ -17,13 +17,13 @@ const importMap = {
 
 const pattern = /\.(narrative)\.(ts)$/;
 
-describe('getNarratives caching', { timeout: 30_000 }, () => {
+describe('getScenes caching', { timeout: 30_000 }, () => {
   let vfs: IFileStore;
   const root = '/test';
 
   beforeEach(() => {
     vfs = new InMemoryFileStore();
-    clearGetNarrativesCache();
+    clearGetScenesCache();
   });
 
   it('should rebuild cache when a helper file is modified', async () => {
@@ -33,10 +33,10 @@ describe('getNarratives caching', { timeout: 30_000 }, () => {
       }
     `;
     const flowContent = `
-      import { narrative } from '../narrative';
+      import { scene } from '../narrative';
       import { formatName } from './helper';
       
-      narrative('TestFlow', () => {
+      scene('TestFlow', () => {
         const name = formatName('test');
       });
     `;
@@ -44,7 +44,7 @@ describe('getNarratives caching', { timeout: 30_000 }, () => {
     await vfs.write('/test/helper.ts', new TextEncoder().encode(helperContent1));
     await vfs.write('/test/test.narrative.ts', new TextEncoder().encode(flowContent));
 
-    const firstCallResult = await getNarratives({ vfs, root, pattern, fastFsScan: true, importMap });
+    const firstCallResult = await getScenes({ vfs, root, pattern, fastFsScan: true, importMap });
     const hash1 = firstCallResult.vfsFiles.sort().join(',');
 
     const helperContent2 = `
@@ -54,30 +54,30 @@ describe('getNarratives caching', { timeout: 30_000 }, () => {
     `;
     await vfs.write('/test/helper.ts', new TextEncoder().encode(helperContent2));
 
-    const secondCallResult = await getNarratives({ vfs, root, pattern, fastFsScan: true, importMap });
+    const secondCallResult = await getScenes({ vfs, root, pattern, fastFsScan: true, importMap });
 
     const hash2 = secondCallResult.vfsFiles.sort().join(',');
     expect(hash1).toBe(hash2);
-    expect(secondCallResult.narratives).toBeDefined();
+    expect(secondCallResult.scenes).toBeDefined();
   });
 
   it('should rebuild cache when import map changes', async () => {
     const flowContent = `
-      import { narrative } from '../narrative';
+      import { scene } from '../narrative';
       
-      narrative('TestFlow', () => {
+      scene('TestFlow', () => {
         const x = 1;
       });
     `;
     await vfs.write('/test/test.narrative.ts', new TextEncoder().encode(flowContent));
 
     const importMap1 = { 'test-module': { default: 'value1' } };
-    const result1 = await getNarratives({ vfs, root, importMap: importMap1, pattern, fastFsScan: true });
+    const result1 = await getScenes({ vfs, root, importMap: importMap1, pattern, fastFsScan: true });
     const importMap2 = { 'test-module': { default: 'value2' } };
 
-    const result2 = await getNarratives({ vfs, root, importMap: importMap2, pattern, fastFsScan: true });
+    const result2 = await getScenes({ vfs, root, importMap: importMap2, pattern, fastFsScan: true });
 
-    expect(result1.narratives.length).toBe(result2.narratives.length);
+    expect(result1.scenes.length).toBe(result2.scenes.length);
   });
 
   it('should rebuild cache when a new dependency is added', async () => {
@@ -87,10 +87,10 @@ describe('getNarratives caching', { timeout: 30_000 }, () => {
       }
     `;
     const flowContent = `
-      import { narrative } from '../narrative';
+      import { scene } from '../narrative';
       import { getValue } from './helper';
       
-      narrative('TestFlow', () => {
+      scene('TestFlow', () => {
         const val = getValue();
       });
     `;
@@ -98,7 +98,7 @@ describe('getNarratives caching', { timeout: 30_000 }, () => {
     await vfs.write('/test/helper.ts', new TextEncoder().encode(helperContent1));
     await vfs.write('/test/test.narrative.ts', new TextEncoder().encode(flowContent));
 
-    const firstCallResult = await getNarratives({ vfs, root, pattern, fastFsScan: true, importMap });
+    const firstCallResult = await getScenes({ vfs, root, pattern, fastFsScan: true, importMap });
     const filesCount1 = firstCallResult.vfsFiles.length;
 
     const transitiveContent = `
@@ -117,7 +117,7 @@ describe('getNarratives caching', { timeout: 30_000 }, () => {
     await vfs.write('/test/transitive.ts', new TextEncoder().encode(transitiveContent));
     await vfs.write('/test/helper.ts', new TextEncoder().encode(helperContent2));
 
-    const secondCallResult = await getNarratives({ vfs, root, pattern, fastFsScan: true, importMap });
+    const secondCallResult = await getScenes({ vfs, root, pattern, fastFsScan: true, importMap });
 
     const filesCount2 = secondCallResult.vfsFiles.length;
     expect(filesCount2).toBeGreaterThan(filesCount1);
@@ -126,9 +126,9 @@ describe('getNarratives caching', { timeout: 30_000 }, () => {
 
   it('should not rebuild cache when an unrelated file is touched', async () => {
     const flowContent = `
-      import { narrative } from '../narrative';
+      import { scene } from '../narrative';
       
-      narrative('TestFlow', () => {
+      scene('TestFlow', () => {
         const x = 1;
       });
     `;
@@ -136,11 +136,11 @@ describe('getNarratives caching', { timeout: 30_000 }, () => {
     await vfs.write('/test/test.narrative.ts', new TextEncoder().encode(flowContent));
     await vfs.write('/test/unrelated.txt', new TextEncoder().encode('initial content'));
 
-    const firstCallResult = await getNarratives({ vfs, root, pattern, fastFsScan: true, importMap });
+    const firstCallResult = await getScenes({ vfs, root, pattern, fastFsScan: true, importMap });
 
     await vfs.write('/test/unrelated.txt', new TextEncoder().encode('modified content'));
 
-    const secondCallResult = await getNarratives({ vfs, root, pattern, fastFsScan: true, importMap });
+    const secondCallResult = await getScenes({ vfs, root, pattern, fastFsScan: true, importMap });
 
     expect(secondCallResult.vfsFiles.some((f) => f.includes('unrelated.txt'))).toBe(false);
     expect(firstCallResult.vfsFiles).toEqual(secondCallResult.vfsFiles);
@@ -148,16 +148,16 @@ describe('getNarratives caching', { timeout: 30_000 }, () => {
 
   it('should rebuild cache when a file is deleted from the graph', async () => {
     const flowContent1 = `
-      import { narrative } from '../narrative';
+      import { scene } from '../narrative';
       
-      narrative('TestFlow1', () => {
+      scene('TestFlow1', () => {
         const x = 1;
       });
     `;
     const flowContent2 = `
-      import { narrative } from '../narrative';
+      import { scene } from '../narrative';
       
-      narrative('TestFlow2', () => {
+      scene('TestFlow2', () => {
         const x = 2;
       });
     `;
@@ -165,29 +165,29 @@ describe('getNarratives caching', { timeout: 30_000 }, () => {
     await vfs.write('/test/test.narrative.ts', new TextEncoder().encode(flowContent1));
     await vfs.write('/test/test2.narrative.ts', new TextEncoder().encode(flowContent2));
 
-    const firstCallResult = await getNarratives({ vfs, root, pattern, fastFsScan: true, importMap });
-    expect(firstCallResult.narratives.length).toBeGreaterThanOrEqual(2);
+    const firstCallResult = await getScenes({ vfs, root, pattern, fastFsScan: true, importMap });
+    expect(firstCallResult.scenes.length).toBeGreaterThanOrEqual(2);
 
     await vfs.remove('/test/test2.narrative.ts');
 
-    const secondCallResult = await getNarratives({ vfs, root, pattern, fastFsScan: true, importMap });
+    const secondCallResult = await getScenes({ vfs, root, pattern, fastFsScan: true, importMap });
 
-    expect(secondCallResult.narratives.length).toBeLessThan(firstCallResult.narratives.length);
+    expect(secondCallResult.scenes.length).toBeLessThan(firstCallResult.scenes.length);
     expect(secondCallResult.vfsFiles.length).toBeLessThan(firstCallResult.vfsFiles.length);
   });
 
   it('should rebuild cache when a file is renamed', async () => {
     const flowContent = `
-      import { narrative } from '../narrative';
+      import { scene } from '../narrative';
       
-      narrative('TestFlow', () => {
+      scene('TestFlow', () => {
         const x = 1;
       });
     `;
 
     await vfs.write('/test/test.narrative.ts', new TextEncoder().encode(flowContent));
 
-    const firstCallResult = await getNarratives({ vfs, root, pattern, fastFsScan: true, importMap });
+    const firstCallResult = await getScenes({ vfs, root, pattern, fastFsScan: true, importMap });
     expect(firstCallResult.vfsFiles.some((f) => f.includes('test.narrative.ts'))).toBe(true);
 
     const content = await vfs.read('/test/test.narrative.ts');
@@ -196,7 +196,7 @@ describe('getNarratives caching', { timeout: 30_000 }, () => {
       await vfs.remove('/test/test.narrative.ts');
     }
 
-    const secondCallResult = await getNarratives({ vfs, root, pattern, fastFsScan: true });
+    const secondCallResult = await getScenes({ vfs, root, pattern, fastFsScan: true });
 
     expect(secondCallResult.vfsFiles.some((f) => f.includes('renamed.narrative.ts'))).toBe(true);
     expect(secondCallResult.vfsFiles.some((f) => f.includes('test.narrative.ts'))).toBe(false);
@@ -209,9 +209,9 @@ describe('getNarratives caching', { timeout: 30_000 }, () => {
       }
     `;
     const flowContent = `
-      import { narrative } from '../narrative';
+      import { scene } from '../narrative';
       
-      narrative('TestFlow', () => {
+      scene('TestFlow', () => {
         const x: string = 'test';
       });
     `;
@@ -219,16 +219,16 @@ describe('getNarratives caching', { timeout: 30_000 }, () => {
     await vfs.write('/test/types.d.ts', new TextEncoder().encode(dtsContent));
     await vfs.write('/test/test.narrative.ts', new TextEncoder().encode(flowContent));
 
-    const result = await getNarratives({ vfs, root, pattern, fastFsScan: true, importMap });
+    const result = await getScenes({ vfs, root, pattern, fastFsScan: true, importMap });
 
     expect(result.vfsFiles.some((f) => f.endsWith('.d.ts'))).toBe(false);
   });
 
   it('should rebuild when import map keys change even with same values', async () => {
     const flowContent = `
-      import { narrative } from '../narrative';
+      import { scene } from '../narrative';
       
-      narrative('TestFlow', () => {
+      scene('TestFlow', () => {
         const x = 1;
       });
     `;
@@ -236,12 +236,12 @@ describe('getNarratives caching', { timeout: 30_000 }, () => {
     await vfs.write('/test/test.narrative.ts', new TextEncoder().encode(flowContent));
 
     const importMap1 = { 'module-a': 'value', 'module-b': 'value' };
-    const result1 = await getNarratives({ vfs, root, importMap: importMap1, pattern, fastFsScan: true });
+    const result1 = await getScenes({ vfs, root, importMap: importMap1, pattern, fastFsScan: true });
     const importMap2 = { 'module-c': 'value', 'module-d': 'value' };
 
-    const result2 = await getNarratives({ vfs, root, importMap: importMap2, pattern, fastFsScan: true });
+    const result2 = await getScenes({ vfs, root, importMap: importMap2, pattern, fastFsScan: true });
 
-    expect(result1.narratives).toEqual(result2.narratives); // Same flows
+    expect(result1.scenes).toEqual(result2.scenes); // Same flows
   });
 
   it('should handle complex transitive dependency chains', async () => {
@@ -257,10 +257,10 @@ describe('getNarratives caching', { timeout: 30_000 }, () => {
       export const TOP_VALUE = MID_VALUE + '-top';
     `;
     const flowContent = `
-      import { narrative } from '../narrative';
+      import { scene } from '../narrative';
       import { TOP_VALUE } from './chain1';
       
-      narrative('TestFlow', () => {
+      scene('TestFlow', () => {
         const val = TOP_VALUE;
       });
     `;
@@ -270,7 +270,7 @@ describe('getNarratives caching', { timeout: 30_000 }, () => {
     await vfs.write('/test/chain1.ts', new TextEncoder().encode(chain1Content));
     await vfs.write('/test/test.narrative.ts', new TextEncoder().encode(flowContent));
 
-    const result1 = await getNarratives({ vfs, root, pattern, fastFsScan: true, importMap });
+    const result1 = await getScenes({ vfs, root, pattern, fastFsScan: true, importMap });
 
     expect(result1.vfsFiles.some((f) => f.includes('chain1'))).toBe(true);
     expect(result1.vfsFiles.some((f) => f.includes('chain2'))).toBe(true);
@@ -281,7 +281,7 @@ describe('getNarratives caching', { timeout: 30_000 }, () => {
     `;
     await vfs.write('/test/chain3.ts', new TextEncoder().encode(modifiedChain3Content));
 
-    const result2 = await getNarratives({ vfs, root, pattern, fastFsScan: true, importMap });
+    const result2 = await getScenes({ vfs, root, pattern, fastFsScan: true, importMap });
     expect(result2.vfsFiles.length).toBe(result1.vfsFiles.length);
   });
 });