project-iris 0.0.1

package/src/iris_bundle/frameworks/iris-core/vs-code-extension/src/test/parser/dependencyComputation.test.ts

@@ -0,0 +1,288 @@
+import * as assert from 'assert';
+import {
+    computeBoltDependencies,
+    getUpNextBolts,
+    isBoltBlocked,
+    getBlockingBolts,
+    countUnblocks
+} from '../../parser/dependencyComputation';
+import { Bolt, ArtifactStatus } from '../../parser/types';
+
+/**
+ * Creates a minimal mock bolt for testing.
+ */
+function createMockBolt(overrides: Partial<Bolt>): Bolt {
+    return {
+        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,
+        ...overrides
+    };
+}
+
+suite('Dependency Computation Test Suite', () => {
+
+    suite('computeBoltDependencies', () => {
+
+        test('should compute isBlocked=false for bolt with no dependencies', () => {
+            const bolts = [createMockBolt({ id: 'bolt-1' })];
+            const result = computeBoltDependencies(bolts);
+
+            assert.strictEqual(result[0].isBlocked, false);
+            assert.deepStrictEqual(result[0].blockedBy, []);
+        });
+
+        test('should compute isBlocked=true when required bolt is incomplete', () => {
+            const bolts = [
+                createMockBolt({ id: 'bolt-dep', status: ArtifactStatus.Draft }),
+                createMockBolt({ id: 'bolt-main', requiresBolts: ['bolt-dep'] })
+            ];
+            const result = computeBoltDependencies(bolts);
+
+            const mainBolt = result.find(b => b.id === 'bolt-main');
+            assert.strictEqual(mainBolt?.isBlocked, true);
+            assert.deepStrictEqual(mainBolt?.blockedBy, ['bolt-dep']);
+        });
+
+        test('should compute isBlocked=false when required bolt is complete', () => {
+            const bolts = [
+                createMockBolt({ id: 'bolt-dep', status: ArtifactStatus.Complete }),
+                createMockBolt({ id: 'bolt-main', requiresBolts: ['bolt-dep'] })
+            ];
+            const result = computeBoltDependencies(bolts);
+
+            const mainBolt = result.find(b => b.id === 'bolt-main');
+            assert.strictEqual(mainBolt?.isBlocked, false);
+            assert.deepStrictEqual(mainBolt?.blockedBy, []);
+        });
+
+        test('should compute unblocksCount correctly', () => {
+            const bolts = [
+                createMockBolt({ id: 'bolt-foundation', status: ArtifactStatus.Draft }),
+                createMockBolt({ id: 'bolt-a', requiresBolts: ['bolt-foundation'] }),
+                createMockBolt({ id: 'bolt-b', requiresBolts: ['bolt-foundation'] }),
+                createMockBolt({ id: 'bolt-c', requiresBolts: ['bolt-foundation'] })
+            ];
+            const result = computeBoltDependencies(bolts);
+
+            const foundationBolt = result.find(b => b.id === 'bolt-foundation');
+            assert.strictEqual(foundationBolt?.unblocksCount, 3);
+        });
+
+        test('should set status to Blocked when draft bolt is blocked', () => {
+            const bolts = [
+                createMockBolt({ id: 'bolt-dep', status: ArtifactStatus.Draft }),
+                createMockBolt({ id: 'bolt-main', status: ArtifactStatus.Draft, requiresBolts: ['bolt-dep'] })
+            ];
+            const result = computeBoltDependencies(bolts);
+
+            const mainBolt = result.find(b => b.id === 'bolt-main');
+            assert.strictEqual(mainBolt?.status, ArtifactStatus.Blocked);
+        });
+
+        test('should not change status for complete bolt even if requirements incomplete', () => {
+            const bolts = [
+                createMockBolt({ id: 'bolt-dep', status: ArtifactStatus.Draft }),
+                createMockBolt({ id: 'bolt-main', status: ArtifactStatus.Complete, requiresBolts: ['bolt-dep'] })
+            ];
+            const result = computeBoltDependencies(bolts);
+
+            const mainBolt = result.find(b => b.id === 'bolt-main');
+            assert.strictEqual(mainBolt?.status, ArtifactStatus.Complete);
+            assert.strictEqual(mainBolt?.isBlocked, false);
+        });
+
+        test('should handle non-existent required bolt as blocking', () => {
+            const bolts = [
+                createMockBolt({ id: 'bolt-main', requiresBolts: ['bolt-nonexistent'] })
+            ];
+            const result = computeBoltDependencies(bolts);
+
+            assert.strictEqual(result[0].isBlocked, true);
+            assert.deepStrictEqual(result[0].blockedBy, ['bolt-nonexistent']);
+        });
+
+        test('should handle multiple dependencies with mixed statuses', () => {
+            const bolts = [
+                createMockBolt({ id: 'bolt-a', status: ArtifactStatus.Complete }),
+                createMockBolt({ id: 'bolt-b', status: ArtifactStatus.Draft }),
+                createMockBolt({ id: 'bolt-c', status: ArtifactStatus.Complete }),
+                createMockBolt({ id: 'bolt-main', requiresBolts: ['bolt-a', 'bolt-b', 'bolt-c'] })
+            ];
+            const result = computeBoltDependencies(bolts);
+
+            const mainBolt = result.find(b => b.id === 'bolt-main');
+            assert.strictEqual(mainBolt?.isBlocked, true);
+            assert.deepStrictEqual(mainBolt?.blockedBy, ['bolt-b']);
+        });
+    });
+
+    suite('getUpNextBolts', () => {
+
+        test('should return only draft and blocked bolts', () => {
+            const bolts = [
+                createMockBolt({ id: 'bolt-complete', status: ArtifactStatus.Complete }),
+                createMockBolt({ id: 'bolt-wip', status: ArtifactStatus.InProgress }),
+                createMockBolt({ id: 'bolt-draft', status: ArtifactStatus.Draft }),
+                createMockBolt({ id: 'bolt-blocked', status: ArtifactStatus.Blocked })
+            ];
+            const result = getUpNextBolts(bolts);
+
+            assert.strictEqual(result.length, 2);
+            const ids = result.map(b => b.id);
+            assert.ok(ids.includes('bolt-draft'));
+            assert.ok(ids.includes('bolt-blocked'));
+        });
+
+        test('should sort unblocked bolts before blocked bolts', () => {
+            const bolts = [
+                createMockBolt({ id: 'bolt-blocked', status: ArtifactStatus.Draft, isBlocked: true }),
+                createMockBolt({ id: 'bolt-unblocked', status: ArtifactStatus.Draft, isBlocked: false })
+            ];
+            const result = getUpNextBolts(bolts);
+
+            assert.strictEqual(result[0].id, 'bolt-unblocked');
+            assert.strictEqual(result[1].id, 'bolt-blocked');
+        });
+
+        test('should sort by unblocksCount within unblocked bolts', () => {
+            const bolts = [
+                createMockBolt({ id: 'bolt-low', status: ArtifactStatus.Draft, isBlocked: false, unblocksCount: 1 }),
+                createMockBolt({ id: 'bolt-high', status: ArtifactStatus.Draft, isBlocked: false, unblocksCount: 5 }),
+                createMockBolt({ id: 'bolt-mid', status: ArtifactStatus.Draft, isBlocked: false, unblocksCount: 3 })
+            ];
+            const result = getUpNextBolts(bolts);
+
+            assert.strictEqual(result[0].id, 'bolt-high');
+            assert.strictEqual(result[1].id, 'bolt-mid');
+            assert.strictEqual(result[2].id, 'bolt-low');
+        });
+
+        test('should sort by id for equal priority', () => {
+            const bolts = [
+                createMockBolt({ id: 'bolt-z', status: ArtifactStatus.Draft, isBlocked: false, unblocksCount: 0 }),
+                createMockBolt({ id: 'bolt-a', status: ArtifactStatus.Draft, isBlocked: false, unblocksCount: 0 })
+            ];
+            const result = getUpNextBolts(bolts);
+
+            assert.strictEqual(result[0].id, 'bolt-a');
+            assert.strictEqual(result[1].id, 'bolt-z');
+        });
+
+        test('should return empty array for all complete bolts', () => {
+            const bolts = [
+                createMockBolt({ id: 'bolt-1', status: ArtifactStatus.Complete }),
+                createMockBolt({ id: 'bolt-2', status: ArtifactStatus.Complete })
+            ];
+            const result = getUpNextBolts(bolts);
+
+            assert.strictEqual(result.length, 0);
+        });
+    });
+
+    suite('isBoltBlocked', () => {
+
+        test('should return false for complete bolt', () => {
+            const bolt = createMockBolt({ status: ArtifactStatus.Complete, requiresBolts: ['bolt-incomplete'] });
+            const allBolts = [
+                bolt,
+                createMockBolt({ id: 'bolt-incomplete', status: ArtifactStatus.Draft })
+            ];
+
+            assert.strictEqual(isBoltBlocked(bolt, allBolts), false);
+        });
+
+        test('should return false for bolt with no requirements', () => {
+            const bolt = createMockBolt({ requiresBolts: [] });
+
+            assert.strictEqual(isBoltBlocked(bolt, [bolt]), false);
+        });
+
+        test('should return true when any required bolt is incomplete', () => {
+            const bolt = createMockBolt({ id: 'bolt-main', requiresBolts: ['bolt-dep'] });
+            const allBolts = [
+                bolt,
+                createMockBolt({ id: 'bolt-dep', status: ArtifactStatus.Draft })
+            ];
+
+            assert.strictEqual(isBoltBlocked(bolt, allBolts), true);
+        });
+
+        test('should return false when all required bolts are complete', () => {
+            const bolt = createMockBolt({ id: 'bolt-main', requiresBolts: ['bolt-dep'] });
+            const allBolts = [
+                bolt,
+                createMockBolt({ id: 'bolt-dep', status: ArtifactStatus.Complete })
+            ];
+
+            assert.strictEqual(isBoltBlocked(bolt, allBolts), false);
+        });
+    });
+
+    suite('getBlockingBolts', () => {
+
+        test('should return empty array for complete bolt', () => {
+            const bolt = createMockBolt({ status: ArtifactStatus.Complete, requiresBolts: ['bolt-dep'] });
+            const allBolts = [
+                bolt,
+                createMockBolt({ id: 'bolt-dep', status: ArtifactStatus.Draft })
+            ];
+
+            assert.deepStrictEqual(getBlockingBolts(bolt, allBolts), []);
+        });
+
+        test('should return IDs of incomplete required bolts', () => {
+            const bolt = createMockBolt({
+                id: 'bolt-main',
+                requiresBolts: ['bolt-a', 'bolt-b', 'bolt-c']
+            });
+            const allBolts = [
+                bolt,
+                createMockBolt({ id: 'bolt-a', status: ArtifactStatus.Complete }),
+                createMockBolt({ id: 'bolt-b', status: ArtifactStatus.Draft }),
+                createMockBolt({ id: 'bolt-c', status: ArtifactStatus.InProgress })
+            ];
+
+            const result = getBlockingBolts(bolt, allBolts);
+            assert.strictEqual(result.length, 2);
+            assert.ok(result.includes('bolt-b'));
+            assert.ok(result.includes('bolt-c'));
+        });
+    });
+
+    suite('countUnblocks', () => {
+
+        test('should count bolts that require this bolt', () => {
+            const allBolts = [
+                createMockBolt({ id: 'bolt-foundation' }),
+                createMockBolt({ id: 'bolt-a', requiresBolts: ['bolt-foundation'] }),
+                createMockBolt({ id: 'bolt-b', requiresBolts: ['bolt-foundation'] }),
+                createMockBolt({ id: 'bolt-c', requiresBolts: ['bolt-other'] })
+            ];
+
+            assert.strictEqual(countUnblocks('bolt-foundation', allBolts), 2);
+        });
+
+        test('should return 0 for bolt with no dependents', () => {
+            const allBolts = [
+                createMockBolt({ id: 'bolt-leaf' }),
+                createMockBolt({ id: 'bolt-other' })
+            ];
+
+            assert.strictEqual(countUnblocks('bolt-leaf', allBolts), 0);
+        });
+    });
+});

package/src/iris_bundle/frameworks/iris-core/vs-code-extension/src/test/parser/frontmatterParser.test.ts

@@ -0,0 +1,191 @@
+import * as assert from 'assert';
+import { parseFrontmatter, normalizeStatus, extractStatus } from '../../parser/frontmatterParser';
+import { ArtifactStatus } from '../../parser/types';
+
+suite('Frontmatter Parser Test Suite', () => {
+
+    suite('parseFrontmatter', () => {
+
+        test('should parse valid YAML frontmatter', () => {
+            const content = `---
+status: in-progress
+priority: must
+title: Test Story
+---
+
+# Content here`;
+
+            const result = parseFrontmatter(content);
+
+            assert.ok(result);
+            assert.strictEqual(result.status, 'in-progress');
+            assert.strictEqual(result.priority, 'must');
+            assert.strictEqual(result.title, 'Test Story');
+        });
+
+        test('should return null for content without frontmatter', () => {
+            const content = `# Just a heading
+
+Some content without frontmatter.`;
+
+            const result = parseFrontmatter(content);
+
+            assert.strictEqual(result, null);
+        });
+
+        test('should return null for empty content', () => {
+            assert.strictEqual(parseFrontmatter(''), null);
+        });
+
+        test('should return null for null/undefined input', () => {
+            assert.strictEqual(parseFrontmatter(null as unknown as string), null);
+            assert.strictEqual(parseFrontmatter(undefined as unknown as string), null);
+        });
+
+        test('should return null for invalid YAML', () => {
+            const content = `---
+status: [invalid yaml
+  broken: stuff
+---
+
+# Content`;
+
+            const result = parseFrontmatter(content);
+
+            assert.strictEqual(result, null);
+        });
+
+        test('should handle frontmatter with nested objects', () => {
+            const content = `---
+complexity:
+  avg_complexity: 2
+  avg_uncertainty: 1
+stories:
+  - story-001
+  - story-002
+---
+
+# Content`;
+
+            const result = parseFrontmatter(content);
+
+            assert.ok(result);
+            assert.ok(result.complexity);
+            assert.strictEqual((result.complexity as Record<string, number>).avg_complexity, 2);
+            assert.ok(Array.isArray(result.stories));
+            assert.strictEqual((result.stories as string[]).length, 2);
+        });
+
+        test('should handle frontmatter with only delimiters', () => {
+            const content = `---
+---
+
+# Content`;
+
+            const result = parseFrontmatter(content);
+
+            // Empty YAML returns empty object or null depending on parser
+            assert.ok(result === null || Object.keys(result).length === 0);
+        });
+
+        test('should handle unicode in values', () => {
+            const content = `---
+title: Test with unicode
+description: Contains special chars
+---
+
+# Content`;
+
+            const result = parseFrontmatter(content);
+
+            assert.ok(result);
+            assert.strictEqual(result.title, 'Test with unicode');
+        });
+    });
+
+    suite('normalizeStatus', () => {
+
+        test('should normalize draft variations', () => {
+            assert.strictEqual(normalizeStatus('draft'), ArtifactStatus.Draft);
+            assert.strictEqual(normalizeStatus('pending'), ArtifactStatus.Draft);
+            assert.strictEqual(normalizeStatus('planned'), ArtifactStatus.Draft);
+            assert.strictEqual(normalizeStatus('todo'), ArtifactStatus.Draft);
+            assert.strictEqual(normalizeStatus('new'), ArtifactStatus.Draft);
+        });
+
+        test('should normalize in-progress variations', () => {
+            assert.strictEqual(normalizeStatus('in-progress'), ArtifactStatus.InProgress);
+            assert.strictEqual(normalizeStatus('in_progress'), ArtifactStatus.InProgress);
+            assert.strictEqual(normalizeStatus('inprogress'), ArtifactStatus.InProgress);
+            assert.strictEqual(normalizeStatus('in progress'), ArtifactStatus.InProgress);
+            assert.strictEqual(normalizeStatus('active'), ArtifactStatus.InProgress);
+            assert.strictEqual(normalizeStatus('started'), ArtifactStatus.InProgress);
+            assert.strictEqual(normalizeStatus('wip'), ArtifactStatus.InProgress);
+            assert.strictEqual(normalizeStatus('working'), ArtifactStatus.InProgress);
+        });
+
+        test('should normalize complete variations', () => {
+            assert.strictEqual(normalizeStatus('complete'), ArtifactStatus.Complete);
+            assert.strictEqual(normalizeStatus('completed'), ArtifactStatus.Complete);
+            assert.strictEqual(normalizeStatus('done'), ArtifactStatus.Complete);
+            assert.strictEqual(normalizeStatus('finished'), ArtifactStatus.Complete);
+            assert.strictEqual(normalizeStatus('closed'), ArtifactStatus.Complete);
+            assert.strictEqual(normalizeStatus('resolved'), ArtifactStatus.Complete);
+        });
+
+        test('should handle case insensitivity', () => {
+            assert.strictEqual(normalizeStatus('DRAFT'), ArtifactStatus.Draft);
+            assert.strictEqual(normalizeStatus('In-Progress'), ArtifactStatus.InProgress);
+            assert.strictEqual(normalizeStatus('COMPLETE'), ArtifactStatus.Complete);
+        });
+
+        test('should handle whitespace', () => {
+            assert.strictEqual(normalizeStatus('  draft  '), ArtifactStatus.Draft);
+            assert.strictEqual(normalizeStatus('\tin-progress\n'), ArtifactStatus.InProgress);
+        });
+
+        test('should return Unknown for unrecognized status', () => {
+            assert.strictEqual(normalizeStatus('unknown'), ArtifactStatus.Unknown);
+            assert.strictEqual(normalizeStatus('random'), ArtifactStatus.Unknown);
+            assert.strictEqual(normalizeStatus('invalid'), ArtifactStatus.Unknown);
+        });
+
+        test('should return Unknown for undefined/null', () => {
+            assert.strictEqual(normalizeStatus(undefined), ArtifactStatus.Unknown);
+            assert.strictEqual(normalizeStatus(null as unknown as string), ArtifactStatus.Unknown);
+        });
+
+        test('should return Unknown for empty string', () => {
+            assert.strictEqual(normalizeStatus(''), ArtifactStatus.Unknown);
+            assert.strictEqual(normalizeStatus('   '), ArtifactStatus.Unknown);
+        });
+    });
+
+    suite('extractStatus', () => {
+
+        test('should extract and normalize status from content', () => {
+            const content = `---
+status: in-progress
+---
+
+# Content`;
+
+            assert.strictEqual(extractStatus(content), ArtifactStatus.InProgress);
+        });
+
+        test('should return Unknown for content without frontmatter', () => {
+            const content = '# Just content';
+            assert.strictEqual(extractStatus(content), ArtifactStatus.Unknown);
+        });
+
+        test('should return Unknown for frontmatter without status', () => {
+            const content = `---
+priority: must
+---
+
+# Content`;
+
+            assert.strictEqual(extractStatus(content), ArtifactStatus.Unknown);
+        });
+    });
+});

package/src/iris_bundle/frameworks/iris-core/vs-code-extension/src/test/parser/memoryBankSchema.test.ts

@@ -0,0 +1,185 @@
+import * as assert from 'assert';
+import * as path from 'path';
+import { MemoryBankSchema } from '../../parser/memoryBankSchema';
+
+suite('MemoryBankSchema Test Suite', () => {
+
+    const workspacePath = '/test/workspace';
+    let schema: MemoryBankSchema;
+
+    setup(() => {
+        schema = new MemoryBankSchema(workspacePath);
+    });
+
+    suite('getMemoryBankPath', () => {
+
+        test('should return correct memory-bank path', () => {
+            const result = schema.getMemoryBankPath();
+            assert.strictEqual(result, path.join(workspacePath, 'memory-bank'));
+        });
+    });
+
+    suite('getIntentsPath', () => {
+
+        test('should return correct intents path', () => {
+            const result = schema.getIntentsPath();
+            assert.strictEqual(result, path.join(workspacePath, 'memory-bank', 'intents'));
+        });
+    });
+
+    suite('getBoltsPath', () => {
+
+        test('should return correct bolts path', () => {
+            const result = schema.getBoltsPath();
+            assert.strictEqual(result, path.join(workspacePath, 'memory-bank', 'bolts'));
+        });
+    });
+
+    suite('getStandardsPath', () => {
+
+        test('should return correct standards path', () => {
+            const result = schema.getStandardsPath();
+            assert.strictEqual(result, path.join(workspacePath, 'memory-bank', 'standards'));
+        });
+    });
+
+    suite('getUnitsPath', () => {
+
+        test('should return correct units path for intent', () => {
+            const result = schema.getUnitsPath('001-user-auth');
+            assert.strictEqual(
+                result,
+                path.join(workspacePath, 'memory-bank', 'intents', '001-user-auth', 'units')
+            );
+        });
+    });
+
+    suite('getStoriesPath', () => {
+
+        test('should return correct stories path for unit', () => {
+            const result = schema.getStoriesPath('001-user-auth', 'auth-service');
+            assert.strictEqual(
+                result,
+                path.join(
+                    workspacePath,
+                    'memory-bank',
+                    'intents',
+                    '001-user-auth',
+                    'units',
+                    'auth-service',
+                    'stories'
+                )
+            );
+        });
+    });
+
+    suite('getBoltPath', () => {
+
+        test('should return correct bolt folder path', () => {
+            const result = schema.getBoltPath('bolt-auth-service-1');
+            assert.strictEqual(
+                result,
+                path.join(workspacePath, 'memory-bank', 'bolts', 'bolt-auth-service-1')
+            );
+        });
+    });
+
+    suite('getSpecsmdPath', () => {
+
+        test('should return correct .irismd path', () => {
+            const result = schema.getSpecsmdPath();
+            assert.strictEqual(result, path.join(workspacePath, '.irismd'));
+        });
+    });
+
+    suite('getIntentPath', () => {
+
+        test('should return correct intent folder path', () => {
+            const result = schema.getIntentPath('001-user-auth');
+            assert.strictEqual(
+                result,
+                path.join(workspacePath, 'memory-bank', 'intents', '001-user-auth')
+            );
+        });
+    });
+
+    suite('getUnitPath', () => {
+
+        test('should return correct unit folder path', () => {
+            const result = schema.getUnitPath('001-user-auth', 'auth-service');
+            assert.strictEqual(
+                result,
+                path.join(
+                    workspacePath,
+                    'memory-bank',
+                    'intents',
+                    '001-user-auth',
+                    'units',
+                    'auth-service'
+                )
+            );
+        });
+    });
+
+    suite('getUnitBriefPath', () => {
+
+        test('should return correct unit-brief.md path', () => {
+            const result = schema.getUnitBriefPath('001-user-auth', 'auth-service');
+            assert.strictEqual(
+                result,
+                path.join(
+                    workspacePath,
+                    'memory-bank',
+                    'intents',
+                    '001-user-auth',
+                    'units',
+                    'auth-service',
+                    'unit-brief.md'
+                )
+            );
+        });
+    });
+
+    suite('getRequirementsPath', () => {
+
+        test('should return correct requirements.md path', () => {
+            const result = schema.getRequirementsPath('001-user-auth');
+            assert.strictEqual(
+                result,
+                path.join(
+                    workspacePath,
+                    'memory-bank',
+                    'intents',
+                    '001-user-auth',
+                    'requirements.md'
+                )
+            );
+        });
+    });
+
+    suite('getBoltFilePath', () => {
+
+        test('should return correct bolt.md path', () => {
+            const result = schema.getBoltFilePath('bolt-auth-service-1');
+            assert.strictEqual(
+                result,
+                path.join(
+                    workspacePath,
+                    'memory-bank',
+                    'bolts',
+                    'bolt-auth-service-1',
+                    'bolt.md'
+                )
+            );
+        });
+    });
+
+    suite('cross-platform compatibility', () => {
+
+        test('should use path.join for all paths', () => {
+            // All paths should use the platform's separator
+            const memoryBankPath = schema.getMemoryBankPath();
+            assert.ok(memoryBankPath.includes(path.sep) || memoryBankPath === path.join(workspacePath, 'memory-bank'));
+        });
+    });
+});