@principal-ai/subsystems-core 0.29.0 → 0.30.0

package/src/utils/GraphConverter.test.ts

@@ -1,322 +0,0 @@
-import { describe, expect, test, afterAll } from 'bun:test';
-import { GraphConverter } from './GraphConverter';
-import type { PathBasedGraphConfiguration } from '../types/path-based-config';
-import {
-  startTestSpan,
-  addEvent,
-  endSpan,
-  markTestPassed,
-  markTestFailed,
-  exportSpans,
-} from '../../test/otel-setup';
-
-describe('GraphConverter', () => {
-  // Export spans after all tests complete
-  afterAll(() => {
-    exportSpans('graph-converter-test-execution.json');
-  });
-
-  test('should convert simple config to nodes and edges', () => {
-    const testSpan = startTestSpan('should convert simple config to nodes and edges', {
-      'test.file': 'GraphConverter.test.ts',
-      'test.suite': 'GraphConverter',
-    });
-
-    try {
-      // Setup - record as event
-      addEvent(testSpan, 'setup.started', {
-        description: 'Creating test configuration with 2 nodes and 1 edge',
-      });
-
-      const config: PathBasedGraphConfiguration = {
-        metadata: {
-          name: 'Test Config',
-          version: '1.0.0',
-        },
-        nodeTypes: {
-          'node-a': {
-            shape: 'circle',
-            icon: 'user',
-            color: '#3b82f6',
-            dataSchema: {},
-          },
-          'node-b': {
-            shape: 'rectangle',
-            icon: 'server',
-            color: '#8b5cf6',
-            dataSchema: {},
-          },
-        },
-        edgeTypes: {
-          connection: {
-            style: 'solid',
-            color: '#64748b',
-            width: 2,
-            directed: true,
-          },
-        },
-        allowedConnections: [
-          {
-            from: 'node-a',
-            to: 'node-b',
-            via: 'connection',
-          },
-        ],
-      };
-
-      addEvent(testSpan, 'setup.complete', {
-        'config.nodes': 2,
-        'config.edges': 1,
-      });
-
-      // Execution - record as event
-      // Note: execution happens in GraphConverter.ts, not the test file
-      addEvent(testSpan, 'execution.started', {
-        action: 'GraphConverter.configToGraph()',
-        'code.filepath': 'GraphConverter.ts', // Override: code under test
-        'code.lineno': 15,
-      });
-
-      const result = GraphConverter.configToGraph(config);
-
-      addEvent(testSpan, 'execution.complete', {
-        'result.nodes.count': result.nodes.length,
-        'result.edges.count': result.edges.length,
-        'code.filepath': 'GraphConverter.ts', // Override: code under test
-        'code.lineno': 43,
-      });
-
-      // Assertions - record as event
-      addEvent(testSpan, 'assertion.started', {
-        assertions: 'Verifying nodes and edges structure',
-      });
-
-      expect(result.nodes).toHaveLength(2);
-      expect(result.edges).toHaveLength(1);
-
-      // Check nodes
-      expect(result.nodes[0].id).toBe('node-a');
-      expect(result.nodes[0].type).toBe('node-a');
-      expect(result.nodes[0].data.shape).toBe('circle');
-      expect(result.nodes[0].data.icon).toBe('user');
-
-      expect(result.nodes[1].id).toBe('node-b');
-      expect(result.nodes[1].type).toBe('node-b');
-      expect(result.nodes[1].data.shape).toBe('rectangle');
-
-      // Check edges
-      expect(result.edges[0].from).toBe('node-a');
-      expect(result.edges[0].to).toBe('node-b');
-      expect(result.edges[0].type).toBe('connection');
-      expect(result.edges[0].data.style).toBe('solid');
-
-      addEvent(testSpan, 'assertion.complete', {
-        'assertions.passed': 11,
-        'assertions.failed': 0,
-      });
-
-      markTestPassed(testSpan);
-    } catch (error) {
-      addEvent(testSpan, 'test.failed', {
-        error: (error as Error).message,
-      });
-      markTestFailed(testSpan, error as Error);
-      throw error;
-    } finally {
-      endSpan(testSpan);
-    }
-  });
-
-  test('should extract manual positions from node types', () => {
-    const testSpan = startTestSpan('should extract manual positions from node types', {
-      'test.file': 'GraphConverter.test.ts',
-      'test.suite': 'GraphConverter',
-    });
-
-    try {
-      addEvent(testSpan, 'setup.started', {
-        description: 'Creating config with manual node positions',
-      });
-
-      const config: PathBasedGraphConfiguration = {
-        metadata: {
-          name: 'Test Config',
-          version: '1.0.0',
-        },
-        nodeTypes: {
-          'node-a': {
-            shape: 'circle',
-            color: '#3b82f6',
-            dataSchema: {},
-            position: { x: 100, y: 200 },
-          },
-          'node-b': {
-            shape: 'rectangle',
-            color: '#8b5cf6',
-            dataSchema: {},
-            position: { x: 300, y: 400 },
-          },
-        },
-        edgeTypes: {},
-        allowedConnections: [],
-      };
-
-      addEvent(testSpan, 'setup.complete', {
-        'config.nodes': 2,
-        'positions.defined': true,
-      });
-
-      addEvent(testSpan, 'execution.started', {
-        action: 'GraphConverter.configToGraph()',
-        'code.filepath': 'GraphConverter.ts',
-        'code.lineno': 15,
-      });
-
-      const result = GraphConverter.configToGraph(config);
-
-      addEvent(testSpan, 'execution.complete', {
-        'result.nodes.count': result.nodes.length,
-        'code.filepath': 'GraphConverter.ts',
-        'code.lineno': 43,
-      });
-
-      addEvent(testSpan, 'assertion.started', {
-        assertions: 'Verifying positions preserved',
-      });
-
-      expect(result.nodes[0].position).toEqual({ x: 100, y: 200 });
-      expect(result.nodes[1].position).toEqual({ x: 300, y: 400 });
-
-      addEvent(testSpan, 'assertion.complete', {
-        'assertions.passed': 2,
-        'assertions.failed': 0,
-      });
-
-      markTestPassed(testSpan);
-    } catch (error) {
-      addEvent(testSpan, 'test.failed', {
-        error: (error as Error).message,
-      });
-      markTestFailed(testSpan, error as Error);
-      throw error;
-    } finally {
-      endSpan(testSpan);
-    }
-  });
-
-  test('should handle nodes without positions', () => {
-    const testSpan = startTestSpan('should handle nodes without positions', {
-      'test.file': 'GraphConverter.test.ts',
-      'test.suite': 'GraphConverter',
-    });
-
-    try {
-      addEvent(testSpan, 'setup.started', {
-        description: 'Creating config without positions',
-      });
-
-      const config: PathBasedGraphConfiguration = {
-        metadata: {
-          name: 'Test Config',
-          version: '1.0.0',
-        },
-        nodeTypes: {
-          'node-a': {
-            shape: 'circle',
-            color: '#3b82f6',
-            dataSchema: {},
-          },
-        },
-        edgeTypes: {},
-        allowedConnections: [],
-      };
-
-      addEvent(testSpan, 'setup.complete', {
-        'config.nodes': 1,
-        'positions.defined': false,
-      });
-
-      addEvent(testSpan, 'execution.started', {
-        action: 'GraphConverter.configToGraph()',
-        'code.filepath': 'GraphConverter.ts',
-        'code.lineno': 15,
-      });
-
-      const result = GraphConverter.configToGraph(config);
-
-      addEvent(testSpan, 'execution.complete', {
-        'result.nodes.count': result.nodes.length,
-        'code.filepath': 'GraphConverter.ts',
-        'code.lineno': 43,
-      });
-
-      addEvent(testSpan, 'assertion.started', {
-        assertions: 'Verifying position is undefined',
-      });
-
-      expect(result.nodes[0].position).toBeUndefined();
-
-      addEvent(testSpan, 'assertion.complete', {
-        'assertions.passed': 1,
-        'assertions.failed': 0,
-      });
-
-      markTestPassed(testSpan);
-    } catch (error) {
-      addEvent(testSpan, 'test.failed', {
-        error: (error as Error).message,
-      });
-      markTestFailed(testSpan, error as Error);
-      throw error;
-    } finally {
-      endSpan(testSpan);
-    }
-  });
-
-  test('should handle edge animation config', () => {
-    const config: PathBasedGraphConfiguration = {
-      metadata: {
-        name: 'Test Config',
-        version: '1.0.0',
-      },
-      nodeTypes: {
-        'node-a': {
-          shape: 'circle',
-          color: '#3b82f6',
-          dataSchema: {},
-        },
-        'node-b': {
-          shape: 'rectangle',
-          color: '#8b5cf6',
-          dataSchema: {},
-        },
-      },
-      edgeTypes: {
-        'animated-flow': {
-          style: 'solid',
-          color: '#3b82f6',
-          width: 3,
-          animation: {
-            type: 'flow',
-            duration: 1500,
-            color: '#60a5fa',
-          },
-        },
-      },
-      allowedConnections: [
-        {
-          from: 'node-a',
-          to: 'node-b',
-          via: 'animated-flow',
-        },
-      ],
-    };
-
-    const result = GraphConverter.configToGraph(config);
-
-    expect(result.edges[0].data.animation).toBeDefined();
-    expect(result.edges[0].data.animation?.type).toBe('flow');
-    expect(result.edges[0].data.animation?.duration).toBe(1500);
-    expect(result.edges[0].data.animation?.color).toBe('#60a5fa');
-  });
-});

package/src/utils/GraphConverter.ts

@@ -1,84 +0,0 @@
-/**
- * Utility for converting PathBasedGraphConfiguration to nodes and edges
- */
-
-import type { PathBasedGraphConfiguration } from '../types/path-based-config';
-import type { NodeState, EdgeState, JsonValue } from '../types';
-
-/**
- * Converts PathBasedGraphConfiguration to graph state (nodes and edges)
- */
-export class GraphConverter {
-  /**
-   * Convert configuration to nodes and edges
-   */
-  static configToGraph(config: PathBasedGraphConfiguration): {
-    nodes: NodeState[];
-    edges: EdgeState[];
-  } {
-    const nodes: NodeState[] = [];
-    const edges: EdgeState[] = [];
-    const now = Date.now();
-
-    // Create nodes from nodeTypes
-    Object.entries(config.nodeTypes).forEach(([id, nodeType]) => {
-      // Build data object, filtering out undefined values
-      const data: Record<string, JsonValue> = {
-        label: id,
-        sources: nodeType.sources || [],
-        // actions removed - legacy path-based
-      };
-
-      // Add optional properties only if defined
-      if (nodeType.shape !== undefined) data.shape = nodeType.shape;
-      if (nodeType.icon !== undefined) data.icon = nodeType.icon;
-      if (nodeType.color !== undefined) data.color = nodeType.color;
-      if (nodeType.size !== undefined) data.size = nodeType.size;
-
-      // Merge in data schema
-      Object.assign(data, nodeType.dataSchema);
-
-      nodes.push({
-        id,
-        type: id,
-        name: id,
-        data,
-        // Extract position if provided in manual layout mode
-        position: nodeType.position,
-        state: 'idle',
-        createdAt: now,
-        updatedAt: now,
-      });
-    });
-
-    // Create edges from allowedConnections
-    if (config.allowedConnections) {
-      config.allowedConnections.forEach((connection, index) => {
-        const edgeType = config.edgeTypes?.[connection.via];
-
-        // Build data object, filtering out undefined values
-        const data: Record<string, JsonValue> = {
-          label: connection.via,
-          style: edgeType?.style || 'solid',
-        };
-
-        // Add optional properties only if defined
-        if (edgeType?.color !== undefined) data.color = edgeType.color;
-        if (edgeType?.width !== undefined) data.width = edgeType.width;
-        if (edgeType?.animation !== undefined) data.animation = edgeType.animation as JsonValue;
-
-        edges.push({
-          id: `${connection.from}-${connection.to}-${index}`,
-          type: connection.via,
-          from: connection.from,
-          to: connection.to,
-          data,
-          createdAt: now,
-          updatedAt: now,
-        });
-      });
-    }
-
-    return { nodes, edges };
-  }
-}

package/src/utils/PathMatcher.test.ts

@@ -1,139 +0,0 @@
-import { describe, it, expect } from 'bun:test';
-import { PathMatcher } from './PathMatcher';
-
-describe('PathMatcher', () => {
-  describe('exact matches', () => {
-    it('should match exact paths', () => {
-      expect(PathMatcher.matches('lib/lock-manager.ts', 'lib/lock-manager.ts')).toBe(true);
-      expect(PathMatcher.matches('lib/lock-manager.ts', 'lib/github-api.ts')).toBe(false);
-    });
-
-    it('should normalize path separators', () => {
-      expect(PathMatcher.matches('lib\\lock-manager.ts', 'lib/lock-manager.ts')).toBe(true);
-      expect(PathMatcher.matches('lib/lock-manager.ts', 'lib\\lock-manager.ts')).toBe(true);
-    });
-  });
-
-  describe('wildcard patterns', () => {
-    it('should match * (single segment wildcard)', () => {
-      expect(PathMatcher.matches('lib/lock-manager.ts', 'lib/*.ts')).toBe(true);
-      expect(PathMatcher.matches('lib/github-api.ts', 'lib/*.ts')).toBe(true);
-      expect(PathMatcher.matches('lib/foo/bar.ts', 'lib/*.ts')).toBe(false); // * doesn't cross directories
-    });
-
-    it('should match ** (recursive wildcard)', () => {
-      expect(PathMatcher.matches('lib/lock-manager.ts', 'lib/**/*.ts')).toBe(true);
-      expect(PathMatcher.matches('lib/foo/bar.ts', 'lib/**/*.ts')).toBe(true);
-      expect(PathMatcher.matches('lib/foo/baz/qux.ts', 'lib/**/*.ts')).toBe(true);
-      expect(PathMatcher.matches('src/index.ts', 'lib/**/*.ts')).toBe(false);
-    });
-
-    it('should match ? (single character)', () => {
-      expect(PathMatcher.matches('lib/a.ts', 'lib/?.ts')).toBe(true);
-      expect(PathMatcher.matches('lib/b.ts', 'lib/?.ts')).toBe(true);
-      expect(PathMatcher.matches('lib/ab.ts', 'lib/?.ts')).toBe(false);
-    });
-  });
-
-  describe('character sets', () => {
-    it('should match [abc] patterns', () => {
-      expect(PathMatcher.matches('lib/a.ts', 'lib/[abc].ts')).toBe(true);
-      expect(PathMatcher.matches('lib/b.ts', 'lib/[abc].ts')).toBe(true);
-      expect(PathMatcher.matches('lib/c.ts', 'lib/[abc].ts')).toBe(true);
-      expect(PathMatcher.matches('lib/d.ts', 'lib/[abc].ts')).toBe(false);
-    });
-
-    it('should match [a-z] range patterns', () => {
-      expect(PathMatcher.matches('lib/a.ts', 'lib/[a-z].ts')).toBe(true);
-      expect(PathMatcher.matches('lib/m.ts', 'lib/[a-z].ts')).toBe(true);
-      expect(PathMatcher.matches('lib/z.ts', 'lib/[a-z].ts')).toBe(true);
-      expect(PathMatcher.matches('lib/A.ts', 'lib/[a-z].ts')).toBe(false);
-    });
-  });
-
-  describe('alternatives', () => {
-    it('should match {a,b,c} alternatives', () => {
-      expect(PathMatcher.matches('lib/foo.ts', 'lib/{foo,bar,baz}.ts')).toBe(true);
-      expect(PathMatcher.matches('lib/bar.ts', 'lib/{foo,bar,baz}.ts')).toBe(true);
-      expect(PathMatcher.matches('lib/baz.ts', 'lib/{foo,bar,baz}.ts')).toBe(true);
-      expect(PathMatcher.matches('lib/qux.ts', 'lib/{foo,bar,baz}.ts')).toBe(false);
-    });
-
-    it('should match nested alternatives', () => {
-      expect(PathMatcher.matches('lib/services/api.ts', '{lib,src}/**/*.ts')).toBe(true);
-      expect(PathMatcher.matches('src/components/App.tsx', '{lib,src}/**/*.{ts,tsx}')).toBe(true);
-    });
-  });
-
-  describe('complex patterns', () => {
-    it('should match combined patterns', () => {
-      const pattern = 'lib/{services,utils}/**/*.{ts,js}';
-      expect(PathMatcher.matches('lib/services/api.ts', pattern)).toBe(true);
-      expect(PathMatcher.matches('lib/utils/helper.js', pattern)).toBe(true);
-      expect(PathMatcher.matches('lib/models/user.ts', pattern)).toBe(false);
-    });
-  });
-
-  describe('findMatches', () => {
-    it('should return all matching patterns', () => {
-      const patterns = ['lib/lock-manager.ts', 'lib/*.ts', 'lib/**/*.ts', 'src/**/*.ts'];
-
-      const matches = PathMatcher.findMatches('lib/lock-manager.ts', patterns);
-      expect(matches).toEqual(['lib/lock-manager.ts', 'lib/*.ts', 'lib/**/*.ts']);
-    });
-
-    it('should return empty array when no patterns match', () => {
-      const patterns = ['src/**/*.ts', 'test/**/*.ts'];
-      const matches = PathMatcher.findMatches('lib/lock-manager.ts', patterns);
-      expect(matches).toEqual([]);
-    });
-  });
-
-  describe('isGlob', () => {
-    it('should detect glob patterns', () => {
-      expect(PathMatcher.isGlob('lib/*.ts')).toBe(true);
-      expect(PathMatcher.isGlob('lib/**/*.ts')).toBe(true);
-      expect(PathMatcher.isGlob('lib/?.ts')).toBe(true);
-      expect(PathMatcher.isGlob('lib/[abc].ts')).toBe(true);
-      expect(PathMatcher.isGlob('lib/{a,b}.ts')).toBe(true);
-    });
-
-    it('should not detect non-glob patterns', () => {
-      expect(PathMatcher.isGlob('lib/lock-manager.ts')).toBe(false);
-      expect(PathMatcher.isGlob('lib/services/api.ts')).toBe(false);
-    });
-  });
-
-  describe('getBaseDir', () => {
-    it('should extract base directory from glob patterns', () => {
-      expect(PathMatcher.getBaseDir('lib/**/*.ts')).toBe('lib');
-      expect(PathMatcher.getBaseDir('lib/services/**/*.ts')).toBe('lib/services');
-      expect(PathMatcher.getBaseDir('lib/*.ts')).toBe('lib');
-      expect(PathMatcher.getBaseDir('**/*.ts')).toBe('');
-    });
-
-    it('should handle non-glob patterns', () => {
-      expect(PathMatcher.getBaseDir('lib/lock-manager.ts')).toBe('lib');
-      expect(PathMatcher.getBaseDir('lib/services/api.ts')).toBe('lib/services');
-    });
-  });
-
-  describe('edge cases', () => {
-    it('should handle empty paths', () => {
-      expect(PathMatcher.matches('', '')).toBe(true);
-      expect(PathMatcher.matches('lib/foo.ts', '')).toBe(false);
-      expect(PathMatcher.matches('', '**')).toBe(true);
-    });
-
-    it('should handle special characters in paths', () => {
-      expect(PathMatcher.matches('lib/foo-bar.ts', 'lib/*.ts')).toBe(true);
-      expect(PathMatcher.matches('lib/foo_bar.ts', 'lib/*.ts')).toBe(true);
-      expect(PathMatcher.matches('lib/foo.bar.ts', 'lib/*.ts')).toBe(true);
-    });
-
-    it('should not match across directory boundaries with *', () => {
-      expect(PathMatcher.matches('lib/services/api.ts', 'lib/*.ts')).toBe(false);
-      expect(PathMatcher.matches('lib/services/api.ts', 'lib/**/*.ts')).toBe(true);
-    });
-  });
-});