@bluefly/openstandardagents 0.5.0 → 0.5.1

package/dist/validation/__tests__/error-codes.test.js

@@ -1,252 +0,0 @@
-/**
- * Tests for OSSA Error Codes
- */
-import { OSSAErrorCode, ERROR_CATALOG, getErrorDetails, searchErrorsByTag, searchErrorsBySeverity, getAllErrorCodes, getErrorCountBySeverity, } from '../error-codes';
-describe('Error Codes', () => {
-    describe('OSSAErrorCode enum', () => {
-        it('should have 101 error codes', () => {
-            const codes = Object.values(OSSAErrorCode);
-            expect(codes.length).toBe(101);
-        });
-        it('should have correct format (OSSA-XXX)', () => {
-            const codes = Object.values(OSSAErrorCode);
-            codes.forEach((code) => {
-                expect(code).toMatch(/^OSSA-\d{3}$/);
-            });
-        });
-        it('should have sequential codes', () => {
-            expect(OSSAErrorCode.OSSA_001).toBe('OSSA-001');
-            expect(OSSAErrorCode.OSSA_100).toBe('OSSA-100');
-            expect(OSSAErrorCode.OSSA_200).toBe('OSSA-200');
-            expect(OSSAErrorCode.OSSA_906).toBe('OSSA-906');
-        });
-    });
-    describe('ERROR_CATALOG', () => {
-        it('should have entry for every error code', () => {
-            const codes = Object.values(OSSAErrorCode);
-            codes.forEach((code) => {
-                expect(ERROR_CATALOG[code]).toBeDefined();
-                expect(ERROR_CATALOG[code].code).toBe(code);
-            });
-        });
-        it('should have required fields for all errors', () => {
-            Object.values(ERROR_CATALOG).forEach((error) => {
-                expect(error.code).toBeDefined();
-                expect(error.severity).toMatch(/^(error|warning|info)$/);
-                expect(error.message).toBeDefined();
-                expect(error.remediation).toBeDefined();
-                expect(error.docsUrl).toBeDefined();
-                expect(error.docsUrl).toContain('openstandardagents.org');
-            });
-        });
-        it('should have tags for all errors', () => {
-            Object.values(ERROR_CATALOG).forEach((error) => {
-                expect(error.tags).toBeDefined();
-                expect(Array.isArray(error.tags)).toBe(true);
-                expect(error.tags.length).toBeGreaterThan(0);
-            });
-        });
-    });
-    describe('getErrorDetails', () => {
-        it('should return error details for valid code', () => {
-            const details = getErrorDetails(OSSAErrorCode.OSSA_001);
-            expect(details).toBeDefined();
-            expect(details.code).toBe(OSSAErrorCode.OSSA_001);
-            expect(details.message).toBe('Missing required field');
-            expect(details.severity).toBe('error');
-        });
-        it('should return undefined for invalid code', () => {
-            const details = getErrorDetails('INVALID');
-            expect(details).toBeUndefined();
-        });
-    });
-    describe('searchErrorsByTag', () => {
-        it('should find errors by tag', () => {
-            const didErrors = searchErrorsByTag('did');
-            expect(didErrors.length).toBeGreaterThan(0);
-            didErrors.forEach((error) => {
-                expect(error.tags).toContain('did');
-            });
-        });
-        it('should find schema errors', () => {
-            const schemaErrors = searchErrorsByTag('schema');
-            expect(schemaErrors.length).toBeGreaterThan(0);
-        });
-        it('should find genetics errors', () => {
-            const geneticsErrors = searchErrorsByTag('genetics');
-            expect(geneticsErrors.length).toBeGreaterThan(0);
-        });
-        it('should return empty array for non-existent tag', () => {
-            const errors = searchErrorsByTag('non-existent-tag');
-            expect(errors.length).toBe(0);
-        });
-    });
-    describe('searchErrorsBySeverity', () => {
-        it('should find all errors', () => {
-            const errors = searchErrorsBySeverity('error');
-            expect(errors.length).toBeGreaterThan(0);
-            errors.forEach((error) => {
-                expect(error.severity).toBe('error');
-            });
-        });
-        it('should find all warnings', () => {
-            const warnings = searchErrorsBySeverity('warning');
-            expect(warnings.length).toBeGreaterThan(0);
-            warnings.forEach((warning) => {
-                expect(warning.severity).toBe('warning');
-            });
-        });
-        it('should find all info', () => {
-            const info = searchErrorsBySeverity('info');
-            expect(info.length).toBeGreaterThan(0);
-            info.forEach((infoItem) => {
-                expect(infoItem.severity).toBe('info');
-            });
-        });
-    });
-    describe('getAllErrorCodes', () => {
-        it('should return all error codes', () => {
-            const codes = getAllErrorCodes();
-            expect(codes.length).toBe(101);
-            expect(codes).toContain(OSSAErrorCode.OSSA_001);
-            expect(codes).toContain(OSSAErrorCode.OSSA_906);
-        });
-    });
-    describe('getErrorCountBySeverity', () => {
-        it('should count errors by severity', () => {
-            const counts = getErrorCountBySeverity();
-            expect(counts.error).toBeGreaterThan(0);
-            expect(counts.warning).toBeGreaterThan(0);
-            expect(counts.info).toBeGreaterThan(0);
-            expect(counts.error + counts.warning + counts.info).toBe(101);
-        });
-        it('should have approximately 70% errors', () => {
-            const counts = getErrorCountBySeverity();
-            const errorPercentage = (counts.error / 101) * 100;
-            expect(errorPercentage).toBeGreaterThan(60);
-            expect(errorPercentage).toBeLessThan(80);
-        });
-    });
-    describe('Category Coverage', () => {
-        it('should have schema validation errors (001-099)', () => {
-            const schemaErrors = [
-                OSSAErrorCode.OSSA_001,
-                OSSAErrorCode.OSSA_010,
-                OSSAErrorCode.OSSA_015,
-            ];
-            schemaErrors.forEach((code) => {
-                expect(ERROR_CATALOG[code]).toBeDefined();
-            });
-        });
-        it('should have identity errors (100-199)', () => {
-            const identityErrors = [
-                OSSAErrorCode.OSSA_100,
-                OSSAErrorCode.OSSA_110,
-                OSSAErrorCode.OSSA_112,
-            ];
-            identityErrors.forEach((code) => {
-                expect(ERROR_CATALOG[code]).toBeDefined();
-            });
-        });
-        it('should have genetics errors (200-299)', () => {
-            const geneticsErrors = [
-                OSSAErrorCode.OSSA_200,
-                OSSAErrorCode.OSSA_210,
-                OSSAErrorCode.OSSA_212,
-            ];
-            geneticsErrors.forEach((code) => {
-                expect(ERROR_CATALOG[code]).toBeDefined();
-            });
-        });
-        it('should have lifecycle errors (300-399)', () => {
-            const lifecycleErrors = [
-                OSSAErrorCode.OSSA_300,
-                OSSAErrorCode.OSSA_310,
-                OSSAErrorCode.OSSA_311,
-            ];
-            lifecycleErrors.forEach((code) => {
-                expect(ERROR_CATALOG[code]).toBeDefined();
-            });
-        });
-        it('should have economics errors (400-499)', () => {
-            const economicsErrors = [
-                OSSAErrorCode.OSSA_400,
-                OSSAErrorCode.OSSA_410,
-                OSSAErrorCode.OSSA_411,
-            ];
-            economicsErrors.forEach((code) => {
-                expect(ERROR_CATALOG[code]).toBeDefined();
-            });
-        });
-        it('should have taxonomy errors (500-599)', () => {
-            const taxonomyErrors = [
-                OSSAErrorCode.OSSA_500,
-                OSSAErrorCode.OSSA_505,
-                OSSAErrorCode.OSSA_508,
-            ];
-            taxonomyErrors.forEach((code) => {
-                expect(ERROR_CATALOG[code]).toBeDefined();
-            });
-        });
-        it('should have access control errors (600-699)', () => {
-            const accessErrors = [
-                OSSAErrorCode.OSSA_600,
-                OSSAErrorCode.OSSA_610,
-                OSSAErrorCode.OSSA_614,
-            ];
-            accessErrors.forEach((code) => {
-                expect(ERROR_CATALOG[code]).toBeDefined();
-            });
-        });
-        it('should have revolutionary features errors (700-799)', () => {
-            const revolutionaryErrors = [
-                OSSAErrorCode.OSSA_700,
-                OSSAErrorCode.OSSA_705,
-                OSSAErrorCode.OSSA_706,
-            ];
-            revolutionaryErrors.forEach((code) => {
-                expect(ERROR_CATALOG[code]).toBeDefined();
-            });
-        });
-        it('should have naming errors (800-899)', () => {
-            const namingErrors = [
-                OSSAErrorCode.OSSA_800,
-                OSSAErrorCode.OSSA_805,
-                OSSAErrorCode.OSSA_806,
-            ];
-            namingErrors.forEach((code) => {
-                expect(ERROR_CATALOG[code]).toBeDefined();
-            });
-        });
-        it('should have catalog errors (900-999)', () => {
-            const catalogErrors = [
-                OSSAErrorCode.OSSA_900,
-                OSSAErrorCode.OSSA_905,
-                OSSAErrorCode.OSSA_906,
-            ];
-            catalogErrors.forEach((code) => {
-                expect(ERROR_CATALOG[code]).toBeDefined();
-            });
-        });
-    });
-    describe('Error Examples', () => {
-        it('should have examples for OSSA-001', () => {
-            const details = getErrorDetails(OSSAErrorCode.OSSA_001);
-            expect(details.examples).toBeDefined();
-            expect(details.examples.length).toBeGreaterThan(0);
-            expect(details.examples[0].invalid).toBeDefined();
-            expect(details.examples[0].valid).toBeDefined();
-        });
-        it('should have examples for OSSA-010', () => {
-            const details = getErrorDetails(OSSAErrorCode.OSSA_010);
-            expect(details.examples).toBeDefined();
-            expect(details.examples.length).toBeGreaterThan(0);
-        });
-        it('should have examples for OSSA-100', () => {
-            const details = getErrorDetails(OSSAErrorCode.OSSA_100);
-            expect(details.examples).toBeDefined();
-            expect(details.examples.length).toBeGreaterThan(0);
-        });
-    });
-});
-//# sourceMappingURL=error-codes.test.js.map

package/dist/version-management/core/version-manager.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=version-manager.test.d.ts.map

package/dist/version-management/core/version-manager.test.js

@@ -1,210 +0,0 @@
-import { VersionManager } from './version-manager';
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import * as os from 'os';
-describe('VersionManager', () => {
-    let versionManager;
-    let tempDir;
-    beforeEach(async () => {
-        versionManager = new VersionManager();
-        tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'ossa-version-test-'));
-    });
-    afterEach(async () => {
-        await fs.rm(tempDir, { recursive: true, force: true });
-    });
-    describe('validate', () => {
-        it('should validate correct semantic versions', () => {
-            const testCases = [
-                '0.4.2',
-                'v0.4.2',
-                '1.2.3',
-                '1.2.3-alpha.1',
-                '2.0.0-rc.1+build.123',
-            ];
-            testCases.forEach((version) => {
-                const result = versionManager.validate(version);
-                expect(result.valid).toBe(true);
-                expect(result.success).toBe(true);
-                expect(result.parsed).toBeDefined();
-            });
-        });
-        it('should reject invalid semantic versions', () => {
-            const testCases = ['0.4', '1.2.3.4', 'latest', 'v1', 'invalid'];
-            testCases.forEach((version) => {
-                const result = versionManager.validate(version);
-                expect(result.valid).toBe(false);
-                expect(result.errors).toBeDefined();
-            });
-        });
-        it('should parse version components correctly', () => {
-            const result = versionManager.validate('1.2.3-alpha.1');
-            expect(result.valid).toBe(true);
-            expect(result.parsed).toEqual({
-                major: 1,
-                minor: 2,
-                patch: 3,
-                prerelease: 'alpha.1',
-                build: undefined,
-            });
-        });
-    });
-    describe('bump', () => {
-        it('should bump major version', () => {
-            const result = versionManager.bump('0.4.2', 'major');
-            expect(result.success).toBe(true);
-            expect(result.oldVersion).toBe('0.4.2');
-            expect(result.newVersion).toBe('1.0.0');
-            expect(result.bumpType).toBe('major');
-        });
-        it('should bump minor version', () => {
-            const result = versionManager.bump('0.4.2', 'minor');
-            expect(result.success).toBe(true);
-            expect(result.newVersion).toBe('0.5.0');
-        });
-        it('should bump patch version', () => {
-            const result = versionManager.bump('0.4.2', 'patch');
-            expect(result.success).toBe(true);
-            expect(result.newVersion).toBe('0.4.3');
-        });
-        it('should bump to prerelease', () => {
-            const result = versionManager.bump('0.4.2', 'prerelease', 'alpha');
-            expect(result.success).toBe(true);
-            expect(result.newVersion).toBe('0.4.3-alpha.0');
-        });
-        it('should handle versions with v prefix', () => {
-            const result = versionManager.bump('v0.4.2', 'patch');
-            expect(result.success).toBe(true);
-            expect(result.oldVersion).toBe('0.4.2');
-            expect(result.newVersion).toBe('0.4.3');
-        });
-    });
-    describe('substitute', () => {
-        it('should replace placeholders in files', async () => {
-            // Create test files
-            const testFile1 = path.join(tempDir, 'test1.md');
-            const testFile2 = path.join(tempDir, 'test2.json');
-            await fs.writeFile(testFile1, '# Version {{VERSION}}\n\nThis is version {{VERSION}} of the project.');
-            await fs.writeFile(testFile2, JSON.stringify({
-                apiVersion: 'ossa/v{{VERSION}}',
-                version: '{{VERSION}}',
-            }));
-            const result = await versionManager.substitute({
-                version: '0.4.2',
-                paths: ['**/*.md', '**/*.json'],
-                cwd: tempDir,
-            });
-            expect(result.success).toBe(true);
-            expect(result.versionUsed).toBe('v0.4.2');
-            expect(result.filesProcessed).toBe(2);
-            expect(result.replacementsMade).toBe(4);
-            // Verify file contents
-            const content1 = await fs.readFile(testFile1, 'utf-8');
-            expect(content1).toContain('# Version v0.4.2');
-            expect(content1).toContain('This is version v0.4.2 of the project.');
-            const content2 = await fs.readFile(testFile2, 'utf-8');
-            const json = JSON.parse(content2);
-            expect(json.apiVersion).toBe('ossa/vv0.4.2');
-            expect(json.version).toBe('v0.4.2');
-        });
-        it('should support dry run mode', async () => {
-            const testFile = path.join(tempDir, 'test.md');
-            await fs.writeFile(testFile, '# Version {{VERSION}}');
-            const result = await versionManager.substitute({
-                version: '0.4.2',
-                paths: ['**/*.md'],
-                cwd: tempDir,
-                dryRun: true,
-            });
-            expect(result.success).toBe(true);
-            expect(result.dryRun).toBe(true);
-            expect(result.replacementsMade).toBe(1);
-            // Verify file was NOT modified
-            const content = await fs.readFile(testFile, 'utf-8');
-            expect(content).toBe('# Version {{VERSION}}');
-        });
-        it('should handle custom placeholders', async () => {
-            const testFile = path.join(tempDir, 'test.md');
-            await fs.writeFile(testFile, '# Version $VERSION');
-            const result = await versionManager.substitute({
-                version: '0.4.2',
-                paths: ['**/*.md'],
-                cwd: tempDir,
-                placeholder: '$VERSION',
-            });
-            expect(result.success).toBe(true);
-            expect(result.replacementsMade).toBe(1);
-            const content = await fs.readFile(testFile, 'utf-8');
-            expect(content).toBe('# Version v0.4.2');
-        });
-        it('should respect exclude patterns', async () => {
-            // Create files
-            const includedFile = path.join(tempDir, 'included.md');
-            const excludedDir = path.join(tempDir, 'node_modules');
-            await fs.mkdir(excludedDir);
-            const excludedFile = path.join(excludedDir, 'excluded.md');
-            await fs.writeFile(includedFile, '{{VERSION}}');
-            await fs.writeFile(excludedFile, '{{VERSION}}');
-            const result = await versionManager.substitute({
-                version: '0.4.2',
-                paths: ['**/*.md'],
-                exclude: ['node_modules/**'],
-                cwd: tempDir,
-            });
-            expect(result.filesProcessed).toBe(1);
-            expect(result.replacementsMade).toBe(1);
-            // Verify excluded file was NOT modified
-            const excludedContent = await fs.readFile(excludedFile, 'utf-8');
-            expect(excludedContent).toBe('{{VERSION}}');
-        });
-    });
-    describe('restore', () => {
-        it('should restore specific version to placeholder', async () => {
-            const testFile = path.join(tempDir, 'test.md');
-            await fs.writeFile(testFile, '# Version v0.4.2\n\nThis is v0.4.2.');
-            const result = await versionManager.restore({
-                version: '0.4.2',
-                paths: ['**/*.md'],
-                cwd: tempDir,
-            });
-            expect(result.success).toBe(true);
-            expect(result.replacementsMade).toBe(2);
-            const content = await fs.readFile(testFile, 'utf-8');
-            expect(content).toBe('# Version {{VERSION}}\n\nThis is {{VERSION}}.');
-        });
-        it('should restore all versions to placeholder', async () => {
-            const testFile = path.join(tempDir, 'test.md');
-            await fs.writeFile(testFile, 'v0.4.2, v0.4.1, v1.0.0, and even 2.3.4');
-            const result = await versionManager.restore({
-                restoreAll: true,
-                paths: ['**/*.md'],
-                cwd: tempDir,
-            });
-            expect(result.success).toBe(true);
-            expect(result.replacementsMade).toBe(4);
-            const content = await fs.readFile(testFile, 'utf-8');
-            expect(content).toBe('{{VERSION}}, {{VERSION}}, {{VERSION}}, and even {{VERSION}}');
-        });
-    });
-    describe('detect', () => {
-        it('should detect version from package.json', async () => {
-            const packageJson = path.join(tempDir, 'package.json');
-            await fs.writeFile(packageJson, JSON.stringify({ name: 'test', version: '0.4.2' }));
-            const result = await versionManager.detect({ directory: tempDir });
-            expect(result.success).toBe(true);
-            expect(result.version).toBe('0.4.2');
-            expect(result.source).toBe('package_json');
-        });
-        it('should detect version from VERSION file', async () => {
-            const versionFile = path.join(tempDir, 'VERSION');
-            await fs.writeFile(versionFile, 'v0.4.2\n');
-            const result = await versionManager.detect({ directory: tempDir });
-            expect(result.success).toBe(true);
-            expect(result.version).toBe('v0.4.2');
-            expect(result.source).toBe('VERSION_file');
-        });
-        it('should throw error when no version found', async () => {
-            await expect(versionManager.detect({ directory: tempDir })).rejects.toThrow('Could not detect version from any source');
-        });
-    });
-});
-//# sourceMappingURL=version-manager.test.js.map