@polagram/core 0.0.3 → 0.0.4

package/dist/src/parser/languages/plantuml/parser.test.js

@@ -0,0 +1,236 @@
+import { describe, expect, it } from 'vitest';
+import { Lexer } from './lexer';
+import { Parser } from './parser';
+describe('PlantUML Parser', () => {
+    const parse = (input) => {
+        const lexer = new Lexer(input);
+        const parser = new Parser(lexer);
+        return parser.parse();
+    };
+    describe('Basic Document Structure', () => {
+        it('should parse @startuml/@enduml block', () => {
+            const input = `
+@startuml
+@enduml
+`;
+            const ast = parse(input);
+            expect(ast.kind).toBe('root');
+            expect(ast.meta.source).toBe('plantuml');
+        });
+        it('should parse title', () => {
+            const input = `
+@startuml
+title My Diagram
+@enduml
+`;
+            const ast = parse(input);
+            expect(ast.meta.title).toBe('My Diagram');
+        });
+    });
+    describe('Participants & Types', () => {
+        it('should parse various participant types', () => {
+            const input = `
+@startuml
+actor User
+database DB
+participant "Service Wrapper" as Svc
+@enduml
+`;
+            const ast = parse(input);
+            expect(ast.participants).toHaveLength(3);
+            expect(ast.participants[0]).toMatchObject({ id: 'User', name: 'User', type: 'actor' });
+            expect(ast.participants[1]).toMatchObject({ id: 'DB', name: 'DB', type: 'database' });
+            expect(ast.participants[2]).toMatchObject({ id: 'Svc', name: 'Service Wrapper', type: 'participant' });
+        });
+    });
+    describe('Messages & Arrows', () => {
+        it('should parse sync and reply messages', () => {
+            const input = `
+@startuml
+A -> B : Sync Call
+B --> A : Reply
+A -> A : Internal
+@enduml
+`;
+            const ast = parse(input);
+            expect(ast.events).toHaveLength(3);
+            expect(ast.events[0]).toMatchObject({
+                kind: 'message',
+                from: 'A',
+                to: 'B',
+                text: 'Sync Call',
+                type: 'sync',
+                style: { line: 'solid', head: 'arrow' }
+            });
+            expect(ast.events[1]).toMatchObject({
+                kind: 'message',
+                from: 'B',
+                to: 'A',
+                text: 'Reply',
+                type: 'reply',
+                style: { line: 'dotted', head: 'arrow' } // PlantUML --> is dotted arrow
+            });
+            expect(ast.events[2]).toMatchObject({
+                kind: 'message',
+                from: 'A',
+                to: 'A',
+                text: 'Internal'
+            });
+        });
+    });
+    describe('Lifecycle', () => {
+        it('should parse activate and deactivate', () => {
+            const input = `
+@startuml
+activate A
+A -> B
+deactivate A
+@enduml
+`;
+            const ast = parse(input);
+            expect(ast.events).toHaveLength(3);
+            expect(ast.events[0]).toMatchObject({ kind: 'activation', participantId: 'A', action: 'activate' });
+            expect(ast.events[1]).toMatchObject({ kind: 'message', from: 'A', to: 'B' });
+            expect(ast.events[2]).toMatchObject({ kind: 'activation', participantId: 'A', action: 'deactivate' });
+        });
+    });
+    describe('Notes', () => {
+        it('should parse notes with position', () => {
+            const input = `
+@startuml
+note left of A : Note Left
+note right of A : Note Right
+note over A : Note Over
+note over A, B : Shared Note
+@enduml
+`;
+            const ast = parse(input);
+            expect(ast.events).toHaveLength(4);
+            expect(ast.events[0]).toMatchObject({ kind: 'note', position: 'left', participantIds: ['A'], text: 'Note Left' });
+            expect(ast.events[1]).toMatchObject({ kind: 'note', position: 'right', participantIds: ['A'], text: 'Note Right' });
+            expect(ast.events[2]).toMatchObject({ kind: 'note', position: 'over', participantIds: ['A'], text: 'Note Over' });
+            expect(ast.events[3]).toMatchObject({ kind: 'note', position: 'over', participantIds: ['A', 'B'], text: 'Shared Note' });
+        });
+    });
+    describe('Fragments', () => {
+        it('should parse alt/else/end', () => {
+            const input = `
+@startuml
+alt success
+  A -> B : OK
+else failure
+  A -> B : Fail
+end
+@enduml
+`;
+            const ast = parse(input);
+            expect(ast.events).toHaveLength(1);
+            const fragment = ast.events[0];
+            expect(fragment.kind).toBe('fragment');
+            expect(fragment.operator).toBe('alt');
+            expect(fragment.branches).toHaveLength(2);
+            expect(fragment.branches[0].condition).toBe('success');
+            expect(fragment.branches[0].events).toHaveLength(1);
+            expect(fragment.branches[1].condition).toBe('failure');
+            expect(fragment.branches[1].events).toHaveLength(1);
+        });
+        it('should parse opt/loop', () => {
+            const input = `
+@startuml
+opt maybe
+  A -> B : Maybe
+end
+loop forever
+  A -> B : Repeat
+end
+@enduml
+`;
+            const ast = parse(input);
+            expect(ast.events).toHaveLength(2);
+            expect(ast.events[0].kind).toBe('fragment');
+            expect(ast.events[0].operator).toBe('opt');
+            expect(ast.events[1].kind).toBe('fragment');
+            expect(ast.events[1].operator).toBe('loop');
+        });
+    });
+    describe('Grouping', () => {
+        it('should parse box with participants', () => {
+            const input = `
+@startuml
+box "Internal Service" #LightBlue
+  participant A
+  participant B
+end box
+participant C
+@enduml
+`;
+            const ast = parse(input);
+            expect(ast.groups).toHaveLength(1);
+            const box = ast.groups[0];
+            expect(box.kind).toBe('group');
+            expect(box.name).toBe('Internal Service');
+            expect(box.style?.backgroundColor).toBe('#LightBlue');
+            expect(box.participantIds).toEqual(['A', 'B']);
+            expect(ast.participants).toHaveLength(3);
+        });
+    });
+    describe('Edge Cases', () => {
+        it('should ignore single line comments', () => {
+            const input = `
+@startuml
+' This is a comment
+A -> B : Hello ' Another comment? No, this is part of string usually?
+' Comment line
+@enduml
+`;
+            const ast = parse(input);
+            expect(ast.events).toHaveLength(1);
+            expect(ast.events[0]).toMatchObject({ text: "Hello ' Another comment? No, this is part of string usually?" });
+        });
+        it('should parse nested fragments', () => {
+            const input = `
+@startuml
+alt outer
+  A -> B : Outer
+  loop inner
+    A -> B : Inner
+  end
+end
+@enduml
+`;
+            const ast = parse(input);
+            expect(ast.events).toHaveLength(1);
+            const outer = ast.events[0];
+            expect(outer.operator).toBe('alt');
+            const outerEvents = outer.branches[0].events;
+            expect(outerEvents).toHaveLength(2);
+            expect(outerEvents[0].kind).toBe('message');
+            const inner = outerEvents[1];
+            expect(inner.kind).toBe('fragment');
+            expect(inner.operator).toBe('loop');
+            expect(inner.branches[0].events).toHaveLength(1);
+        });
+        it('should parse multi-line notes', () => {
+            const input = `
+@startuml
+note left of A
+  Line 1
+  Line 2
+end note
+@enduml
+`;
+            const ast = parse(input);
+            expect(ast.events).toHaveLength(1);
+            expect(ast.events[0]).toMatchObject({
+                kind: 'note',
+                position: 'left',
+                participantIds: ['A'],
+                // text should contain lines. trim() might remove leading/trailing.
+                // We probably want to preserve internal newlines.
+            });
+            const text = ast.events[0].text;
+            expect(text).toContain('Line 1');
+            expect(text).toContain('Line 2');
+        });
+    });
+});

package/dist/src/parser/languages/plantuml/tokens.d.ts

@@ -0,0 +1,9 @@
+export type TokenType = 'START_UML' | 'END_UML' | 'NEWLINE' | 'EOF' | 'UNKNOWN' | 'IDENTIFIER' | 'STRING' | 'TITLE' | 'PARTICIPANT' | 'ACTOR' | 'DATABASE' | 'ACTIVATE' | 'DEACTIVATE' | 'NOTE' | 'OF' | 'LEFT' | 'RIGHT' | 'OVER' | 'ALT' | 'OPT' | 'LOOP' | 'ELSE' | 'END' | 'BOX' | 'AS' | 'ARROW' | 'COLON' | 'COMMA';
+export interface Token {
+    type: TokenType;
+    literal: string;
+    line: number;
+    column: number;
+    start: number;
+    end: number;
+}

package/dist/src/parser/languages/plantuml/tokens.js

@@ -0,0 +1 @@
+export {};

package/dist/src/transformer/orchestration/engine.test.js

@@ -1,4 +1,4 @@
-import { describe, expect, it } from 'vitest';
+import { describe, expect, it, vi } from 'vitest';
 import { TransformationEngine } from './engine';
 describe('TransformationEngine (Pipeline Integration)', () => {
     const createAst = (participants, events) => ({
@@ -38,4 +38,15 @@ describe('TransformationEngine (Pipeline Integration)', () => {
         // 3. Cleaner (Unused) should have removed C and D
         expect(result.participants.map(p => p.id).sort()).toEqual(['A0', 'B0']);
     });
+    it('handles unknown actions gracefully (identity)', () => {
+        const root = createAst([pA], [msgAB]);
+        const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => { });
+        // @ts-ignore - purposefully passing invalid action
+        const result = new TransformationEngine().transform(root, [{ action: 'invalid' }]);
+        expect(result).toEqual(root); // Logic remains identity, but object reference changes due to CoW cleaners
+        // Actually structure cleaner typically returns new object.
+        // But main point is it didn't crash.
+        expect(warnSpy).toHaveBeenCalledWith('Unknown action: invalid');
+        warnSpy.mockRestore();
+    });
 });

package/dist/src/transformer/selector/matcher.test.js

@@ -50,4 +50,21 @@ describe('Matcher', () => {
             expect(matcher.matchMessage(msg, { kind: 'message', to: 'db' })).toBe(false);
         });
     });
+    describe('Branch Matching', () => {
+        const branch = { id: 'b1', condition: 'valid', events: [] };
+        it('matches by operator', () => {
+            // Operator matching is against the PARENT fragment's operator
+            expect(matcher.matchBranch(branch, { kind: 'fragment', operator: 'alt' }, 'alt')).toBe(true);
+            expect(matcher.matchBranch(branch, { kind: 'fragment', operator: 'loop' }, 'alt')).toBe(false);
+            expect(matcher.matchBranch(branch, { kind: 'fragment', operator: ['alt', 'opt'] }, 'alt')).toBe(true);
+        });
+        it('matches by condition', () => {
+            expect(matcher.matchBranch(branch, { kind: 'fragment', condition: 'valid' }, 'alt')).toBe(true);
+            expect(matcher.matchBranch(branch, { kind: 'fragment', condition: 'invalid' }, 'alt')).toBe(false);
+        });
+        it('returns false if branch has no condition but selector requires one', () => {
+            const noCondBranch = { id: 'b2', events: [] };
+            expect(matcher.matchBranch(noCondBranch, { kind: 'fragment', condition: 'needed' }, 'alt')).toBe(false);
+        });
+    });
 });

package/dist/src/transformer/traverse/walker.test.js

@@ -2,6 +2,33 @@ import { describe, expect, it } from 'vitest';
 import { Walker } from './walker';
 class IdentityWalker extends Walker {
 }
+class FilteringWalker extends Walker {
+    // Removes messages starting with 'DROP'
+    visitEvent(node) {
+        if (node.kind === 'message' && node.text.startsWith('DROP')) {
+            return [];
+        }
+        return super.visitEvent(node);
+    }
+}
+class MutatingWalker extends Walker {
+    // Uppercases message text
+    visitEvent(node) {
+        if (node.kind === 'message') {
+            return [{ ...node, text: node.text.toUpperCase() }];
+        }
+        return super.visitEvent(node);
+    }
+}
+class ExpandingWalker extends Walker {
+    // Duplicates messages
+    visitEvent(node) {
+        if (node.kind === 'message') {
+            return [node, { ...node, id: node.id + '_copy', text: node.text + ' (Copy)' }];
+        }
+        return super.visitEvent(node);
+    }
+}
 describe('Walker (Base Traversal)', () => {
     const createAst = (events) => ({
         kind: 'root',
@@ -11,7 +38,7 @@ describe('Walker (Base Traversal)', () => {
         events
     });
     const msg = {
-        kind: 'message', id: 'm1', text: 'M', from: 'A', to: 'B',
+        kind: 'message', id: 'm1', text: 'hello', from: 'A', to: 'B',
         type: 'sync', style: { line: 'solid', head: 'arrow' }
     };
     it('returns events as is by default', () => {
@@ -20,7 +47,7 @@ describe('Walker (Base Traversal)', () => {
         expect(result.events).toHaveLength(1);
         expect(result.events[0].id).toBe('m1');
     });
-    it('recursively traverses fragments (Deep Identiy)', () => {
+    it('recursively traverses fragments (Deep Identity)', () => {
         const fragment = {
             kind: 'fragment', id: 'f1', operator: 'alt',
             branches: [
@@ -33,7 +60,7 @@ describe('Walker (Base Traversal)', () => {
         expect(resFrag.branches[0].events).toHaveLength(1);
         expect(resFrag.branches[0].events[0].id).toBe('m1');
     });
-    it('does not mutate original AST (simple check)', () => {
+    it('does not mutate original AST', () => {
         const fragment = {
             kind: 'fragment', id: 'f1', operator: 'alt',
             branches: [
@@ -41,8 +68,44 @@ describe('Walker (Base Traversal)', () => {
             ]
         };
         const root = createAst([fragment]);
-        const result = new IdentityWalker().transform(root); // Should create new ref if we were being strict about CoW, but standard map returns new array.
+        const result = new IdentityWalker().transform(root);
         expect(result).not.toBe(root); // Root object is new
         expect(result.events).not.toBe(root.events); // Events array is new (map)
     });
+    describe('Subclass Behaviors', () => {
+        it('supports filtering (removing nodes)', () => {
+            const dropMsg = { ...msg, id: 'm2', text: 'DROP me' };
+            const root = createAst([msg, dropMsg]);
+            const result = new FilteringWalker().transform(root);
+            expect(result.events).toHaveLength(1);
+            expect(result.events[0].id).toBe('m1');
+        });
+        it('supports mutation (modifying nodes)', () => {
+            const root = createAst([msg]);
+            const result = new MutatingWalker().transform(root);
+            expect(result.events[0].text).toBe('HELLO');
+        });
+        it('supports expansion (1->N nodes)', () => {
+            const root = createAst([msg]);
+            const result = new ExpandingWalker().transform(root);
+            expect(result.events).toHaveLength(2);
+            expect(result.events[0].text).toBe('hello');
+            expect(result.events[1].text).toBe('hello (Copy)');
+        });
+        it('handles nested mutations/filtering', () => {
+            const dropMsg = { ...msg, id: 'm2', text: 'DROP nested' };
+            const fragment = {
+                kind: 'fragment', id: 'f1', operator: 'loop',
+                branches: [
+                    { id: 'b1', events: [msg, dropMsg] }
+                ]
+            };
+            const root = createAst([fragment]);
+            // Should filter inside the fragment
+            const result = new FilteringWalker().transform(root);
+            const resFrag = result.events[0];
+            expect(resFrag.branches[0].events).toHaveLength(1);
+            expect(resFrag.branches[0].events[0].text).toBe('hello');
+        });
+    });
 });