project-iris 0.0.1

package/src/iris_bundle/frameworks/iris-core/vs-code-extension/src/test/sidebar/types.test.ts

@@ -0,0 +1,239 @@
+import * as assert from 'assert';
+import {
+    TreeNode,
+    TreeNodeKind,
+    NODE_ICONS,
+    STATUS_INDICATORS,
+    CollapsibleState,
+    getCollapsibleState,
+    isRootNode,
+    isIntentNode,
+    isUnitNode
+} from '../../sidebar/types';
+import { ArtifactStatus } from '../../parser/types';
+
+suite('Sidebar Types Test Suite', () => {
+
+    suite('NODE_ICONS', () => {
+
+        test('should have icon for all node kinds', () => {
+            const kinds: TreeNodeKind[] = [
+                'root-intents',
+                'root-bolts',
+                'root-standards',
+                'intent',
+                'unit',
+                'story',
+                'bolt',
+                'bolt-stages-group',
+                'bolt-stage',
+                'bolt-stories-group',
+                'bolt-story',
+                'standard'
+            ];
+
+            for (const kind of kinds) {
+                assert.ok(NODE_ICONS[kind], `Missing icon for ${kind}`);
+            }
+        });
+
+        test('should use folder-library for intents root', () => {
+            assert.strictEqual(NODE_ICONS['root-intents'], 'folder-library');
+        });
+
+        test('should use tools for bolts root', () => {
+            assert.strictEqual(NODE_ICONS['root-bolts'], 'tools');
+        });
+
+        test('should use law for standards root', () => {
+            assert.strictEqual(NODE_ICONS['root-standards'], 'law');
+        });
+    });
+
+    suite('STATUS_INDICATORS', () => {
+
+        test('should have indicator for complete status', () => {
+            assert.strictEqual(STATUS_INDICATORS[ArtifactStatus.Complete], '\u2713');
+        });
+
+        test('should have indicator for in-progress status', () => {
+            assert.strictEqual(STATUS_INDICATORS[ArtifactStatus.InProgress], '\u25CF');
+        });
+
+        test('should have indicator for draft status', () => {
+            assert.strictEqual(STATUS_INDICATORS[ArtifactStatus.Draft], '\u25CB');
+        });
+
+        test('should have empty indicator for unknown status', () => {
+            assert.strictEqual(STATUS_INDICATORS[ArtifactStatus.Unknown], '');
+        });
+    });
+
+    suite('getCollapsibleState', () => {
+
+        test('should return Expanded for root-intents', () => {
+            const node: TreeNode = {
+                kind: 'root-intents',
+                label: 'Intents',
+                id: 'root-intents'
+            };
+            assert.strictEqual(getCollapsibleState(node), CollapsibleState.Expanded);
+        });
+
+        test('should return Expanded for root-bolts', () => {
+            const node: TreeNode = {
+                kind: 'root-bolts',
+                label: 'Bolts',
+                id: 'root-bolts'
+            };
+            assert.strictEqual(getCollapsibleState(node), CollapsibleState.Expanded);
+        });
+
+        test('should return Collapsed for intent with units', () => {
+            const node: TreeNode = {
+                kind: 'intent',
+                label: '001-test-intent',
+                id: 'intent-001-test-intent',
+                data: {
+                    name: 'test-intent',
+                    number: '001',
+                    path: '/test/path',
+                    status: ArtifactStatus.Draft,
+                    units: [{ name: 'unit1', intentName: '001-test-intent', path: '/test', status: ArtifactStatus.Draft, stories: [] }]
+                }
+            };
+            assert.strictEqual(getCollapsibleState(node), CollapsibleState.Collapsed);
+        });
+
+        test('should return None for intent without units', () => {
+            const node: TreeNode = {
+                kind: 'intent',
+                label: '001-test-intent',
+                id: 'intent-001-test-intent',
+                data: {
+                    name: 'test-intent',
+                    number: '001',
+                    path: '/test/path',
+                    status: ArtifactStatus.Draft,
+                    units: []
+                }
+            };
+            assert.strictEqual(getCollapsibleState(node), CollapsibleState.None);
+        });
+
+        test('should return None for story', () => {
+            const node: TreeNode = {
+                kind: 'story',
+                label: '001-test-story',
+                id: 'story-001-test-story',
+                data: {
+                    id: '001',
+                    title: 'test-story',
+                    unitName: 'test-unit',
+                    intentName: 'test-intent',
+                    path: '/test/path',
+                    status: ArtifactStatus.Draft,
+                    priority: 'must'
+                }
+            };
+            assert.strictEqual(getCollapsibleState(node), CollapsibleState.None);
+        });
+
+        test('should return Collapsed for bolt (always expandable)', () => {
+            const node: TreeNode = {
+                kind: 'bolt',
+                label: 'bolt-test-1',
+                id: 'bolt-bolt-test-1',
+                data: {
+                    id: 'bolt-test-1',
+                    unit: 'test-unit',
+                    intent: 'test-intent',
+                    type: 'simple-construction-bolt',
+                    status: ArtifactStatus.Draft,
+                    currentStage: null,
+                    stages: [],
+                    stagesCompleted: [],
+                    stories: [],
+                    path: '/test/path',
+                    filePath: '/test/path/bolt.md',
+                    requiresBolts: [],
+                    enablesBolts: [],
+                    isBlocked: false,
+                    blockedBy: [],
+                    unblocksCount: 0
+                }
+            };
+            // Bolts are always Collapsed to show stages/stories groups
+            assert.strictEqual(getCollapsibleState(node), CollapsibleState.Collapsed);
+        });
+    });
+
+    suite('Type Guards', () => {
+
+        test('isRootNode should return true for root-intents', () => {
+            const node: TreeNode = {
+                kind: 'root-intents',
+                label: 'Intents',
+                id: 'root-intents'
+            };
+            assert.strictEqual(isRootNode(node), true);
+        });
+
+        test('isRootNode should return true for root-bolts', () => {
+            const node: TreeNode = {
+                kind: 'root-bolts',
+                label: 'Bolts',
+                id: 'root-bolts'
+            };
+            assert.strictEqual(isRootNode(node), true);
+        });
+
+        test('isRootNode should return false for intent', () => {
+            const node: TreeNode = {
+                kind: 'intent',
+                label: '001-test',
+                id: 'intent-001-test',
+                data: {
+                    name: 'test',
+                    number: '001',
+                    path: '/test',
+                    status: ArtifactStatus.Draft,
+                    units: []
+                }
+            };
+            assert.strictEqual(isRootNode(node), false);
+        });
+
+        test('isIntentNode should return true for intent', () => {
+            const node: TreeNode = {
+                kind: 'intent',
+                label: '001-test',
+                id: 'intent-001-test',
+                data: {
+                    name: 'test',
+                    number: '001',
+                    path: '/test',
+                    status: ArtifactStatus.Draft,
+                    units: []
+                }
+            };
+            assert.strictEqual(isIntentNode(node), true);
+        });
+
+        test('isUnitNode should return true for unit', () => {
+            const node: TreeNode = {
+                kind: 'unit',
+                label: 'test-unit',
+                id: 'unit-001-test-test-unit',
+                data: {
+                    name: 'test-unit',
+                    intentName: '001-test',
+                    path: '/test',
+                    status: ArtifactStatus.Draft,
+                    stories: []
+                }
+            };
+            assert.strictEqual(isUnitNode(node), true);
+        });
+    });
+});

package/src/iris_bundle/frameworks/iris-core/vs-code-extension/src/test/sidebar/webviewContent.test.ts

@@ -0,0 +1,67 @@
+import * as assert from 'assert';
+import { getNonce } from '../../webview/utils';
+
+suite('Webview Content Test Suite', () => {
+
+    suite('getNonce', () => {
+
+        test('should return a string of length 32', () => {
+            const nonce = getNonce();
+            assert.strictEqual(nonce.length, 32);
+        });
+
+        test('should only contain alphanumeric characters', () => {
+            const nonce = getNonce();
+            const validChars = /^[A-Za-z0-9]+$/;
+            assert.ok(validChars.test(nonce), `Nonce contains invalid characters: ${nonce}`);
+        });
+
+        test('should generate different nonces on each call', () => {
+            const nonces = new Set<string>();
+            for (let i = 0; i < 100; i++) {
+                nonces.add(getNonce());
+            }
+            // All 100 nonces should be unique (extremely unlikely to collide)
+            assert.strictEqual(nonces.size, 100, 'Generated nonces should be unique');
+        });
+
+        test('should contain uppercase letters', () => {
+            // Run multiple times to ensure we get uppercase letters
+            let hasUppercase = false;
+            for (let i = 0; i < 10; i++) {
+                const nonce = getNonce();
+                if (/[A-Z]/.test(nonce)) {
+                    hasUppercase = true;
+                    break;
+                }
+            }
+            // With 10 tries of 32 chars each from a 62-char alphabet where 26 are uppercase,
+            // probability of no uppercase is essentially zero
+            assert.ok(hasUppercase, 'Nonce should contain uppercase letters');
+        });
+
+        test('should contain lowercase letters', () => {
+            let hasLowercase = false;
+            for (let i = 0; i < 10; i++) {
+                const nonce = getNonce();
+                if (/[a-z]/.test(nonce)) {
+                    hasLowercase = true;
+                    break;
+                }
+            }
+            assert.ok(hasLowercase, 'Nonce should contain lowercase letters');
+        });
+
+        test('should contain digits', () => {
+            let hasDigits = false;
+            for (let i = 0; i < 10; i++) {
+                const nonce = getNonce();
+                if (/[0-9]/.test(nonce)) {
+                    hasDigits = true;
+                    break;
+                }
+            }
+            assert.ok(hasDigits, 'Nonce should contain digits');
+        });
+    });
+});

package/src/iris_bundle/frameworks/iris-core/vs-code-extension/src/test/sidebar/webviewMessaging.test.ts

@@ -0,0 +1,369 @@
+import * as assert from 'assert';
+import {
+    TabId,
+    DEFAULT_TAB,
+    TAB_STATE_KEY,
+    FOCUS_EXPANDED_KEY,
+    ACTIVITY_FILTER_KEY,
+    ACTIVITY_HEIGHT_KEY,
+    DEFAULT_ACTIVITY_FILTER,
+    DEFAULT_ACTIVITY_HEIGHT,
+    MIN_ACTIVITY_HEIGHT,
+    MAX_ACTIVITY_HEIGHT,
+    ActivityFilter,
+    WebviewData,
+    ActiveBoltData,
+    QueuedBoltData,
+    ActivityEventData
+} from '../../sidebar/webviewMessaging';
+
+suite('Webview Messaging Test Suite', () => {
+
+    suite('Constants', () => {
+
+        test('DEFAULT_TAB should be bolts', () => {
+            assert.strictEqual(DEFAULT_TAB, 'bolts');
+        });
+
+        test('TAB_STATE_KEY should be irismd.activeTab', () => {
+            assert.strictEqual(TAB_STATE_KEY, 'irismd.activeTab');
+        });
+
+        test('FOCUS_EXPANDED_KEY should be irismd.focusCardExpanded', () => {
+            assert.strictEqual(FOCUS_EXPANDED_KEY, 'irismd.focusCardExpanded');
+        });
+
+        test('ACTIVITY_FILTER_KEY should be irismd.activityFilter', () => {
+            assert.strictEqual(ACTIVITY_FILTER_KEY, 'irismd.activityFilter');
+        });
+
+        test('ACTIVITY_HEIGHT_KEY should be irismd.activityHeight', () => {
+            assert.strictEqual(ACTIVITY_HEIGHT_KEY, 'irismd.activityHeight');
+        });
+
+        test('DEFAULT_ACTIVITY_FILTER should be all', () => {
+            assert.strictEqual(DEFAULT_ACTIVITY_FILTER, 'all');
+        });
+
+        test('DEFAULT_ACTIVITY_HEIGHT should be 200', () => {
+            assert.strictEqual(DEFAULT_ACTIVITY_HEIGHT, 200);
+        });
+
+        test('MIN_ACTIVITY_HEIGHT should be 120', () => {
+            assert.strictEqual(MIN_ACTIVITY_HEIGHT, 120);
+        });
+
+        test('MAX_ACTIVITY_HEIGHT should be 500', () => {
+            assert.strictEqual(MAX_ACTIVITY_HEIGHT, 500);
+        });
+    });
+
+    suite('ActivityFilter type', () => {
+
+        test('all should be valid ActivityFilter', () => {
+            const filter: ActivityFilter = 'all';
+            assert.strictEqual(filter, 'all');
+        });
+
+        test('stages should be valid ActivityFilter', () => {
+            const filter: ActivityFilter = 'stages';
+            assert.strictEqual(filter, 'stages');
+        });
+
+        test('bolts should be valid ActivityFilter', () => {
+            const filter: ActivityFilter = 'bolts';
+            assert.strictEqual(filter, 'bolts');
+        });
+    });
+
+    suite('TabId type', () => {
+
+        test('bolts should be valid TabId', () => {
+            const tab: TabId = 'bolts';
+            assert.strictEqual(tab, 'bolts');
+        });
+
+        test('specs should be valid TabId', () => {
+            const tab: TabId = 'specs';
+            assert.strictEqual(tab, 'specs');
+        });
+
+        test('overview should be valid TabId', () => {
+            const tab: TabId = 'overview';
+            assert.strictEqual(tab, 'overview');
+        });
+    });
+
+    suite('WebviewData interface', () => {
+
+        test('should accept empty data structure', () => {
+            const data: WebviewData = {
+                currentIntent: null,
+                stats: { active: 0, queued: 0, done: 0, blocked: 0 },
+                activeBolts: [],
+                upNextQueue: [],
+                completedBolts: [],
+                activityEvents: [],
+                intents: [],
+                standards: [],
+                nextActions: [],
+                focusCardExpanded: false,
+                activityFilter: 'all',
+                activityHeight: 200,
+                specsFilter: 'all',
+                availableStatuses: []
+            };
+
+            assert.strictEqual(data.currentIntent, null);
+            assert.strictEqual(data.stats.active, 0);
+            assert.strictEqual(data.activeBolts.length, 0);
+            assert.strictEqual(data.upNextQueue.length, 0);
+            assert.strictEqual(data.focusCardExpanded, false);
+            assert.strictEqual(data.activityFilter, 'all');
+            assert.strictEqual(data.activityHeight, 200);
+        });
+
+        test('should track UI state properties', () => {
+            const data: WebviewData = {
+                currentIntent: null,
+                stats: { active: 0, queued: 0, done: 0, blocked: 0 },
+                activeBolts: [],
+                upNextQueue: [],
+                completedBolts: [],
+                activityEvents: [],
+                intents: [],
+                standards: [],
+                nextActions: [],
+                focusCardExpanded: true,
+                activityFilter: 'stages',
+                activityHeight: 350,
+                specsFilter: 'active',
+                availableStatuses: ['draft', 'in-progress', 'complete']
+            };
+
+            assert.strictEqual(data.focusCardExpanded, true);
+            assert.strictEqual(data.activityFilter, 'stages');
+            assert.strictEqual(data.activityHeight, 350);
+        });
+
+        test('should accept complete data structure', () => {
+            const data: WebviewData = {
+                currentIntent: { name: 'Test Intent', number: '001' },
+                stats: { active: 1, queued: 3, done: 5, blocked: 2 },
+                activeBolts: [{
+                    id: 'bolt-1',
+                    name: 'Test Bolt',
+                    type: 'DDD',
+                    currentStage: 'implement',
+                    stagesComplete: 2,
+                    stagesTotal: 5,
+                    storiesComplete: 1,
+                    storiesTotal: 3,
+                    stages: [
+                        { name: 'spec', status: 'complete' },
+                        { name: 'implement', status: 'active' }
+                    ],
+                    stories: [
+                        { id: '001', name: 'Story 1', status: 'complete' }
+                    ],
+                    path: '/test/bolts/bolt-1',
+                    files: []
+                }],
+                upNextQueue: [
+                    {
+                        id: 'bolt-2',
+                        name: 'Next Bolt',
+                        type: 'Simple',
+                        storiesCount: 2,
+                        isBlocked: false,
+                        blockedBy: [],
+                        unblocksCount: 1,
+                        stages: [],
+                        stories: []
+                    }
+                ],
+                completedBolts: [],
+                activityEvents: [
+                    {
+                        id: 'evt-1',
+                        type: 'bolt-start',
+                        text: 'Started bolt',
+                        target: 'bolt-1',
+                        tag: 'bolt',
+                        relativeTime: '5m ago',
+                        exactTime: 'Thu, Dec 26, 2024, 10:00:00 AM'
+                    }
+                ],
+                intents: [
+                    {
+                        name: 'Test Intent',
+                        number: '001',
+                        path: '/test/path',
+                        storiesComplete: 3,
+                        storiesTotal: 5,
+                        units: []
+                    }
+                ],
+                standards: [
+                    { name: 'coding-standards', path: '/standards/coding.md' }
+                ],
+                nextActions: [],
+                focusCardExpanded: true,
+                activityFilter: 'bolts',
+                activityHeight: 300,
+                specsFilter: 'complete',
+                availableStatuses: ['complete', 'in-progress']
+            };
+
+            assert.strictEqual(data.currentIntent?.name, 'Test Intent');
+            assert.strictEqual(data.stats.active, 1);
+            assert.strictEqual(data.activeBolts[0]?.currentStage, 'implement');
+            assert.strictEqual(data.upNextQueue.length, 1);
+            assert.strictEqual(data.activityEvents.length, 1);
+        });
+    });
+
+    suite('ActiveBoltData interface', () => {
+
+        test('should track stage progress', () => {
+            const bolt: ActiveBoltData = {
+                id: 'bolt-test',
+                name: 'Test Bolt',
+                type: 'DDD',
+                currentStage: 'implement',
+                stagesComplete: 2,
+                stagesTotal: 5,
+                storiesComplete: 1,
+                storiesTotal: 3,
+                stages: [
+                    { name: 'discover', status: 'complete' },
+                    { name: 'spec', status: 'complete' },
+                    { name: 'implement', status: 'active' },
+                    { name: 'test', status: 'pending' },
+                    { name: 'integrate', status: 'pending' }
+                ],
+                stories: [],
+                path: '/test/bolts/bolt-test',
+                files: [
+                    { name: 'walkthrough.md', path: '/test/bolts/bolt-test/walkthrough.md', type: 'walkthrough' }
+                ]
+            };
+
+            assert.strictEqual(bolt.stagesComplete, 2);
+            assert.strictEqual(bolt.stagesTotal, 5);
+            assert.strictEqual(bolt.stages.filter(s => s.status === 'complete').length, 2);
+            assert.strictEqual(bolt.stages.filter(s => s.status === 'active').length, 1);
+        });
+
+        test('should handle null currentStage', () => {
+            const bolt: ActiveBoltData = {
+                id: 'bolt-test',
+                name: 'Test Bolt',
+                type: 'Simple',
+                currentStage: null,
+                stagesComplete: 0,
+                stagesTotal: 3,
+                storiesComplete: 0,
+                storiesTotal: 2,
+                stages: [],
+                stories: [],
+                path: '/test/bolts/bolt-test',
+                files: []
+            };
+
+            assert.strictEqual(bolt.currentStage, null);
+        });
+    });
+
+    suite('QueuedBoltData interface', () => {
+
+        test('should track blocked status', () => {
+            const bolt: QueuedBoltData = {
+                id: 'bolt-blocked',
+                name: 'Blocked Bolt',
+                type: 'DDD',
+                storiesCount: 3,
+                isBlocked: true,
+                blockedBy: ['bolt-dep-1', 'bolt-dep-2'],
+                unblocksCount: 0,
+                stages: [],
+                stories: []
+            };
+
+            assert.strictEqual(bolt.isBlocked, true);
+            assert.strictEqual(bolt.blockedBy.length, 2);
+            assert.ok(bolt.blockedBy.includes('bolt-dep-1'));
+        });
+
+        test('should track unblocks count', () => {
+            const bolt: QueuedBoltData = {
+                id: 'bolt-key',
+                name: 'Key Bolt',
+                type: 'Simple',
+                storiesCount: 1,
+                isBlocked: false,
+                blockedBy: [],
+                unblocksCount: 5,
+                stages: [],
+                stories: []
+            };
+
+            assert.strictEqual(bolt.unblocksCount, 5);
+        });
+    });
+
+    suite('ActivityEventData interface', () => {
+
+        test('should accept bolt-created event', () => {
+            const event: ActivityEventData = {
+                id: 'evt-1',
+                type: 'bolt-created',
+                text: 'Bolt created',
+                target: 'bolt-1',
+                tag: 'bolt',
+                relativeTime: '2h ago',
+                exactTime: 'Thu, Dec 26, 2024, 08:00:00 AM'
+            };
+
+            assert.strictEqual(event.type, 'bolt-created');
+            assert.strictEqual(event.tag, 'bolt');
+        });
+
+        test('should accept stage-complete event', () => {
+            const event: ActivityEventData = {
+                id: 'evt-2',
+                type: 'stage-complete',
+                text: 'spec stage completed',
+                target: 'bolt-1',
+                tag: 'stage',
+                relativeTime: '30m ago',
+                exactTime: 'Thu, Dec 26, 2024, 09:30:00 AM'
+            };
+
+            assert.strictEqual(event.type, 'stage-complete');
+            assert.strictEqual(event.tag, 'stage');
+        });
+
+        test('should accept all event types', () => {
+            const types: ActivityEventData['type'][] = [
+                'bolt-created',
+                'bolt-start',
+                'stage-complete',
+                'bolt-complete'
+            ];
+
+            for (const type of types) {
+                const event: ActivityEventData = {
+                    id: `evt-${type}`,
+                    type,
+                    text: `Event ${type}`,
+                    target: 'bolt-1',
+                    tag: type.includes('stage') ? 'stage' : 'bolt',
+                    relativeTime: 'now',
+                    exactTime: 'Thu, Dec 26, 2024, 10:00:00 AM'
+                };
+                assert.strictEqual(event.type, type);
+            }
+        });
+    });
+});