@principal-ai/subsystems-react 0.21.1 → 0.23.0

package/src/subsystem/formatDeclaration.ts

@@ -39,8 +39,6 @@ export function generateDeclarationString(component: SubsystemComponent): string
     case 'type_alias':
     case 'enum':
       return generateType(name, component.construct, declaration);
-    case 'module':
-      return generateModule(declaration);
     case 'store':
       return generateStore(name, declaration);
     case 'external':
@@ -175,23 +173,6 @@ function generateType(
   }
 }
 
-function generateModule(declaration?: GraphifyComponentDetail): string {
-  const mod = declaration?.kind === 'module' ? declaration : undefined;
-  if (!mod) return 'module {}';
-
-  const parts: string[] = [];
-
-  for (const imp of mod.imports ?? []) {
-    parts.push(`import '${imp.name}';`);
-  }
-
-  if ((mod.exports ?? []).length > 0) {
-    parts.push(`export { ${mod.exports!.join(', ')} };`);
-  }
-
-  return parts.join('\n') || `module {}`;
-}
-
 /**
  * A store renders as its retained state — ambient `declare const` lines for
  * the state members, never a class/method stub. The node's name labels the

package/src/subsystem/model.test.ts

@@ -4,7 +4,9 @@ import {
   convertSubsystemToEdges,
   convertSubsystemToGroups,
   getSubsystemRegions,
+  getSubsystemModuleRegions,
   processGroupNodeId,
+  moduleGroupNodeId,
   buildSubsystemGraph,
   deriveNameFromSymbol,
   constructBadgeLabel,
@@ -94,10 +96,10 @@ describe('subsystem graph model', () => {
   });
 
   test('deriveNameFromSymbol is consistent per kind', () => {
-    // brace-bodied constructs wear {}; classes render bare; module uses the symbol as-is.
+    // brace-bodied constructs wear {}; classes render bare.
     expect(deriveNameFromSymbol('SessionReader', 'class')).toBe('SessionReader');
     expect(deriveNameFromSymbol('SessionRecord', 'type_alias')).toBe('SessionRecord {}');
-    expect(deriveNameFromSymbol('transcript', 'module')).toBe('transcript');
+    expect(deriveNameFromSymbol('transcript', 'function')).toBe('transcript()');
     // falls back to existing name when no symbol (class stays bare).
     expect(deriveNameFromSymbol(undefined, 'class', 'SessionReader')).toBe('SessionReader');
     expect(deriveNameFromSymbol('', 'external', 'principal-studio-host')).toBe('principal-studio-host');
@@ -187,13 +189,13 @@ describe('subsystem graph model', () => {
     expect(rightBadgeLabel({ role: 'service', proposed: true })).toBe('proposed');
   });
 
-  test('deriveNameFromSymbol falls back to file basename for modules', () => {
-    expect(deriveNameFromSymbol(undefined, 'module', undefined, 'transcript.ts')).toBe('transcript');
-    expect(deriveNameFromSymbol(undefined, 'module', undefined, 'src/event-processors/index.ts')).toBe('index');
-    // Symbol wins over file basename.
-    expect(deriveNameFromSymbol('CodexRolloutRecord', 'module', undefined, 'transcript.ts')).toBe('CodexRolloutRecord');
-    // File basename wins over a supplied name for modules (derivation precedence).
-    expect(deriveNameFromSymbol(undefined, 'module', 'MyModule', 'x.ts')).toBe('x');
+  test('deriveNameFromSymbol falls back to existing name when no symbol', () => {
+    expect(deriveNameFromSymbol(undefined, 'class', undefined, 'transcript.ts')).toBe('untitled');
+    expect(deriveNameFromSymbol(undefined, 'function', 'MyFn', 'x.ts')).toBe('MyFn()');
+    // Symbol wins over a supplied name.
+    expect(deriveNameFromSymbol('CodexRolloutRecord', 'function', undefined, 'transcript.ts')).toBe(
+      'CodexRolloutRecord()',
+    );
   });
 
   test('formatPurl renders the human identity', () => {
@@ -216,9 +218,49 @@ describe('subsystem graph model', () => {
       ],
     });
     expect(regions.map((r) => r.key)).toEqual(['app/host', 'app/renderer']);
+    expect(regions.every((r) => r.kind === 'process')).toBe(true);
     expect(regions[0]!.memberIds).toEqual(['a', 'b']);
   });
 
+  test('getSubsystemModuleRegions groups by module, skipping module-less nodes', () => {
+    const regions = getSubsystemModuleRegions({
+      components: [
+        { id: 'a', name: 'a', construct: 'function', file: 'transcript.ts', purl: 'pkg:github/acme/app', module: 'src/session/transcript.ts' },
+        { id: 'b', name: 'b', construct: 'type_alias', file: 'transcript.ts', purl: 'pkg:github/acme/app', module: 'src/session/transcript.ts' },
+        { id: 'c', name: 'c', construct: 'function', file: 'paths.ts', purl: 'pkg:github/acme/app', module: 'src/session/paths.ts' },
+        { id: 'd', name: 'd', construct: 'function', file: 'other.ts', purl: 'pkg:github/acme/app' },
+      ],
+    });
+    expect(regions.map((r) => r.key)).toEqual([
+      'src/session/transcript.ts',
+      'src/session/paths.ts',
+    ]);
+    expect(regions.every((r) => r.kind === 'module')).toBe(true);
+    expect(regions[0]!.memberIds).toEqual(['a', 'b']);
+  });
+
+  test('convertSubsystemToNodes prefers module parentId over process', () => {
+    const nodes = convertSubsystemToNodes({
+      components: [
+        {
+          id: 'a',
+          name: 'a',
+          construct: 'function',
+          file: 'a.ts',
+          purl: 'pkg:github/acme/app',
+          process: 'app/host',
+          module: 'src/a.ts',
+        },
+        { id: 'd', name: 'd', construct: 'function', file: 'd.ts', purl: 'pkg:github/acme/app' },
+      ],
+      relations: [],
+    });
+    expect((nodes.find((n) => n.id === 'a') as { parentId?: string }).parentId).toBe(
+      moduleGroupNodeId('src/a.ts'),
+    );
+    expect((nodes.find((n) => n.id === 'd') as { parentId?: string }).parentId).toBeUndefined();
+  });
+
   test('convertSubsystemToNodes stamps parentId for process members only', () => {
     const nodes = convertSubsystemToNodes({
       components: [
@@ -245,6 +287,103 @@ describe('subsystem graph model', () => {
     expect(groups[0]!.type).toBe('subsystem-group');
   });
 
+  test('convertSubsystemToGroups nests module frames under a shared process', () => {
+    const groups = convertSubsystemToGroups({
+      components: [
+        {
+          id: 'a',
+          name: 'a',
+          construct: 'function',
+          file: 'a.ts',
+          purl: 'pkg:github/acme/app',
+          process: 'app/host',
+          module: 'src/a.ts',
+        },
+        {
+          id: 'b',
+          name: 'b',
+          construct: 'function',
+          file: 'a.ts',
+          purl: 'pkg:github/acme/app',
+          process: 'app/host',
+          module: 'src/a.ts',
+        },
+      ],
+    });
+    expect(groups.map((g) => g.id).sort()).toEqual(
+      [moduleGroupNodeId('src/a.ts'), processGroupNodeId('app/host')].sort(),
+    );
+    const mod = groups.find((g) => g.id === moduleGroupNodeId('src/a.ts'));
+    expect((mod as { parentId?: string }).parentId).toBe(processGroupNodeId('app/host'));
+    const proc = groups.find((g) => g.id === processGroupNodeId('app/host'));
+    expect((proc as { parentId?: string }).parentId).toBeUndefined();
+  });
+
+  test('buildSubsystemGraph nests module frames inside process frames', async () => {
+    const { nodes, regions } = await buildSubsystemGraph({
+      components: [
+        {
+          id: 'boot',
+          name: 'boot',
+          construct: 'function',
+          file: 'main.ts',
+          purl: 'pkg:github/acme/app',
+          process: 'app/host',
+          module: 'src/main.ts',
+          symbol: 'boot',
+        },
+        {
+          id: 'create',
+          name: 'createHost',
+          construct: 'function',
+          file: 'main.ts',
+          purl: 'pkg:github/acme/app',
+          process: 'app/host',
+          module: 'src/main.ts',
+          symbol: 'createHost',
+        },
+        {
+          id: 'write',
+          name: 'writeSession',
+          construct: 'function',
+          file: 'store.ts',
+          purl: 'pkg:github/acme/app',
+          process: 'app/host',
+          module: 'src/store.ts',
+          symbol: 'writeSession',
+        },
+        {
+          id: 'store',
+          name: 'SessionStore',
+          construct: 'store',
+          file: 'store.ts',
+          purl: 'pkg:github/acme/app',
+          process: 'app/host',
+          module: 'src/store.ts',
+          symbol: 'SessionStore',
+        },
+      ],
+      relations: [],
+    });
+    expect(regions.map((r) => r.key).sort()).toEqual(
+      ['app/host', 'src/main.ts', 'src/store.ts'].sort(),
+    );
+    const processNode = nodes.find((n) => n.id === processGroupNodeId('app/host'));
+    const mainMod = nodes.find((n) => n.id === moduleGroupNodeId('src/main.ts'));
+    const storeMod = nodes.find((n) => n.id === moduleGroupNodeId('src/store.ts'));
+    expect(processNode).toBeDefined();
+    expect(mainMod).toBeDefined();
+    expect(storeMod).toBeDefined();
+    expect((mainMod as { parentId?: string }).parentId).toBe(processGroupNodeId('app/host'));
+    expect((storeMod as { parentId?: string }).parentId).toBe(processGroupNodeId('app/host'));
+    expect((nodes.find((n) => n.id === 'boot') as { parentId?: string }).parentId).toBe(
+      moduleGroupNodeId('src/main.ts'),
+    );
+    expect((nodes.find((n) => n.id === 'store') as { parentId?: string }).parentId).toBe(
+      moduleGroupNodeId('src/store.ts'),
+    );
+  });
+
   test('buildSubsystemGraph drops singleton process frames (no parentId, no group)', async () => {
     const { nodes, regions } = await buildSubsystemGraph({
       components: [
@@ -264,6 +403,48 @@ describe('subsystem graph model', () => {
     expect(nodes.find((n) => n.id === processGroupNodeId('app/lonely'))).toBeUndefined();
   });
 
+  test('buildSubsystemGraph frames multi-member modules', async () => {
+    const { nodes, regions } = await buildSubsystemGraph({
+      components: [
+        {
+          id: 'rec',
+          name: 'CodexRolloutRecord',
+          construct: 'type_alias',
+          file: 'transcript.ts',
+          purl: 'pkg:github/acme/app',
+          module: 'src/session/transcript.ts',
+          symbol: 'CodexRolloutRecord',
+        },
+        {
+          id: 'parse',
+          name: 'parseTranscript',
+          construct: 'function',
+          file: 'transcript.ts',
+          purl: 'pkg:github/acme/app',
+          module: 'src/session/transcript.ts',
+          symbol: 'parseTranscript',
+        },
+        {
+          id: 'solo',
+          name: 'lonely',
+          construct: 'function',
+          file: 'solo.ts',
+          purl: 'pkg:github/acme/app',
+          module: 'src/solo.ts',
+          symbol: 'lonely',
+        },
+      ],
+      relations: [],
+    });
+    expect(regions.map((r) => r.key)).toEqual(['src/session/transcript.ts']);
+    expect(regions[0]!.kind).toBe('module');
+    expect((nodes.find((n) => n.id === 'rec') as { parentId?: string }).parentId).toBe(
+      moduleGroupNodeId('src/session/transcript.ts'),
+    );
+    expect((nodes.find((n) => n.id === 'solo') as { parentId?: string }).parentId).toBeUndefined();
+    expect(nodes.find((n) => n.id === moduleGroupNodeId('src/session/transcript.ts'))).toBeDefined();
+  });
+
   test('subsystemGraphLayoutKey ignores declarationRef-only changes', () => {
     const base = doc;
     const withRef = {