x-fidelity 2.5.0 → 2.7.0

package/CHANGELOG.md

@@ -1,3 +1,43 @@
+# [2.7.0](https://github.com/zotoio/x-fidelity/compare/v2.6.0...v2.7.0) (2024-08-22)
+
+
+### Bug Fixes
+
+* Add missing `repoUrl` property to `mockParams` object ([e94114d](https://github.com/zotoio/x-fidelity/commit/e94114dced7c9f6b4f53caa034937d07313abd71))
+
+
+### Features
+
+* **exemption process:** allow a repo to have a timelimited waiver for a given rule ([42d4b7d](https://github.com/zotoio/x-fidelity/commit/42d4b7de181131bbc3400710fc86876f4f3d8748))
+
+# [2.6.0](https://github.com/zotoio/x-fidelity/compare/v2.5.0...v2.6.0) (2024-08-22)
+
+
+### Bug Fixes
+
+* Change log level from debug to info for better visibility ([8173462](https://github.com/zotoio/x-fidelity/commit/817346206d084a0dcad79ceeec548b8b51342135))
+* **deps:** monorepo fixes ([07021e8](https://github.com/zotoio/x-fidelity/commit/07021e8af78db05515ffe8e73b337f431c8caf61))
+* Fix issues with dependency version validation and handling ([75282c1](https://github.com/zotoio/x-fidelity/commit/75282c1d392c49d8f152eac29fdedca7e7add2fa))
+* Improve implementation and test coverage of openaiAnalysisHighSeverity ([acaf784](https://github.com/zotoio/x-fidelity/commit/acaf784b79560c9f303cab65c76e873419275ebc))
+* Improve local dependency collection ([8d7732f](https://github.com/zotoio/x-fidelity/commit/8d7732f80cfea9beef6b35656b8488168070a9ef))
+* improve semver range checking in repoDependencyAnalysis ([ba15f5a](https://github.com/zotoio/x-fidelity/commit/ba15f5ab31c1e2228e26e1eaeeea7d060f5ac033))
+* Improve semver version comparison logic ([8f943e1](https://github.com/zotoio/x-fidelity/commit/8f943e1477fb041d97828829306c6de4af8695ae))
+* Update `collectLocalDependencies` function to return correct dependency structure ([fc3fccb](https://github.com/zotoio/x-fidelity/commit/fc3fccb8780e23816c6cc6c18789a52395e9bbf9))
+* Update collectLocalDependencies function to return expected structure ([42ee815](https://github.com/zotoio/x-fidelity/commit/42ee8159311692a10db648aafa1c34002ad7572e))
+* Update mocking of `collectLocalDependencies` function in tests ([5d8d647](https://github.com/zotoio/x-fidelity/commit/5d8d647702e1cdd8cd979d9abd5da9791e9eed3c))
+* Update repoDependencyAnalysis function to only add dependencies that don't meet requirements ([1070e5f](https://github.com/zotoio/x-fidelity/commit/1070e5faf990e1287a9ba6d36297ef8781e04658))
+* Update semverValid function to return correct result ([158f555](https://github.com/zotoio/x-fidelity/commit/158f55506b6f96ecd18b04ca30557f5a03849a3b))
+* Update test case for collectLocalDependencies function ([4b35d3f](https://github.com/zotoio/x-fidelity/commit/4b35d3faf3c9d9832e9d1a00d26f6b7ece2c19ca))
+* Use toEqual for boolean comparisons in openaiAnalysisHighSeverity tests ([16425c6](https://github.com/zotoio/x-fidelity/commit/16425c67e07fa7c14569fa739b38f2353fa8a466))
+
+
+### Features
+
+* Add collectLocalDependencies function to repoDependencyFacts ([8aa6311](https://github.com/zotoio/x-fidelity/commit/8aa6311e3471ceed1bf07f2564b5de086d5440f1))
+* Add support for version ranges in repoDependencyAnalysis ([ce82a21](https://github.com/zotoio/x-fidelity/commit/ce82a218227eca3b3ccb42cab393dcfe20e3de29))
+* create comprehensive unit test suite for repoDependencyFacts.ts ([a92b83b](https://github.com/zotoio/x-fidelity/commit/a92b83b9ffedffd5f47e15cd7a7fed40353d3754))
+* rewrite src/facts/repoDependencyFacts.test.ts with correct mocking and comprehensive test coverage ([66e26c2](https://github.com/zotoio/x-fidelity/commit/66e26c2bad485c71adca1187aafb81796d38148f))
+
 # [2.5.0](https://github.com/zotoio/x-fidelity/compare/v2.4.0...v2.5.0) (2024-08-21)
 
 

package/dist/core/engine/analyzer.js

@@ -26,7 +26,12 @@ function analyzeCodebase(params) {
     return __awaiter(this, void 0, void 0, function* () {
         const { repoPath, archetype = 'node-fullstack', configServer = '', localConfigPath = '', executionLogPrefix = '' } = params;
         logger_1.logger.info(`STARTING..`);
+        // Load exemptions
+        if (localConfigPath) {
+            yield configManager_1.ConfigManager.loadExemptions(localConfigPath);
+        }
         const telemetryData = yield (0, telemetryCollector_1.collectTelemetryData)({ repoPath, configServer });
+        const repoUrl = telemetryData.repoUrl;
         // Send telemetry for analysis start
         yield (0, telemetry_1.sendTelemetry)({
             eventType: 'analysisStart',
@@ -72,7 +77,8 @@ function analyzeCodebase(params) {
             fileData,
             installedDependencyVersions,
             minimumDependencyVersions,
-            standardStructure
+            standardStructure,
+            repoUrl
         });
         const finishMsg = `\n==========================\nCHECKS COMPLETED..\n==========================`;
         logger_1.logger.info(finishMsg);

package/dist/core/engine/engineRunner.js

@@ -14,7 +14,7 @@ const logger_1 = require("../../utils/logger");
 const configManager_1 = require("../../utils/configManager");
 function runEngineOnFiles(params) {
     return __awaiter(this, void 0, void 0, function* () {
-        const { engine, fileData, installedDependencyVersions, minimumDependencyVersions, standardStructure } = params;
+        const { engine, fileData, installedDependencyVersions, minimumDependencyVersions, standardStructure, repoUrl } = params;
         const msg = `\n==========================\nRUNNING FILE CHECKS..\n==========================`;
         logger_1.logger.info(msg);
         const failures = [];
@@ -41,7 +41,7 @@ function runEngineOnFiles(params) {
                 results.forEach((result) => {
                     var _a, _b;
                     logger_1.logger.debug(JSON.stringify(result));
-                    if (result.result) {
+                    if (result.result && !configManager_1.ConfigManager.isExempt(repoUrl, result.name)) {
                         fileFailures.push({
                             ruleFailure: result.name,
                             level: (_a = result.event) === null || _a === void 0 ? void 0 : _a.type,

package/dist/core/engine/engineRunner.test.js

@@ -35,6 +35,7 @@ describe('runEngineOnFiles', () => {
         installedDependencyVersions: {},
         minimumDependencyVersions: {},
         standardStructure: {},
+        repoUrl: 'https://github.com/mock/repo',
     };
     beforeEach(() => {
         jest.clearAllMocks();

package/dist/facts/repoDependencyFacts.js

@@ -39,6 +39,7 @@ exports.collectLocalDependencies = collectLocalDependencies;
 exports.getDependencyVersionFacts = getDependencyVersionFacts;
 exports.findPropertiesInTree = findPropertiesInTree;
 exports.repoDependencyAnalysis = repoDependencyAnalysis;
+exports.semverValid = semverValid;
 const logger_1 = require("../utils/logger");
 const child_process_1 = require("child_process");
 const semver = __importStar(require("semver"));
@@ -61,7 +62,7 @@ function collectLocalDependencies() {
         logger_1.logger.error('No yarn.lock or package-lock.json found');
         throw new Error('Unsupported package manager');
     }
-    logger_1.logger.debug(`collectLocalDependencies: ${JSON.stringify(result)}`);
+    logger_1.logger.info(`collectLocalDependencies: ${JSON.stringify(result)}`);
     return result;
 }
 function collectYarnDependencies() {
@@ -156,7 +157,7 @@ function getDependencyVersionFacts(archetypeConfig) {
  */
 function findPropertiesInTree(depGraph, minVersions) {
     const results = [];
-    logger_1.logger.debug(`depGraph: ${JSON.stringify(depGraph)}`);
+    logger_1.logger.info(`depGraph: ${JSON.stringify(depGraph)}`);
     function walk(dep, parentName = '') {
         const fullName = parentName ? `${parentName}/${dep.name}` : dep.name;
         if (Object.keys(minVersions).includes(dep.name)) {
@@ -169,6 +170,7 @@ function findPropertiesInTree(depGraph, minVersions) {
         }
     }
     depGraph.forEach(dep => walk(dep));
+    logger_1.logger.info(JSON.stringify(depGraph));
     return results;
 }
 function repoDependencyAnalysis(params, almanac) {
@@ -180,10 +182,11 @@ function repoDependencyAnalysis(params, almanac) {
         }
         const analysis = [];
         const dependencyData = yield almanac.factValue('dependencyData');
-        dependencyData.installedDependencyVersions.map((versionData) => {
+        dependencyData.installedDependencyVersions.forEach((versionData) => {
             logger_1.logger.debug(`outdatedFramework: checking ${versionData.dep}`);
-            const requiredRange = new semver.Range(versionData.min);
-            if (!semver.gtr(versionData.ver, requiredRange)) {
+            // Check if the installed version satisfies the required version, supporting both ranges and specific versions
+            const isValid = semverValid(versionData.ver, versionData.min);
+            if (!isValid) {
                 const dependencyFailure = {
                     'dependency': versionData.dep,
                     'currentVersion': versionData.ver,
@@ -198,3 +201,29 @@ function repoDependencyAnalysis(params, almanac) {
         return result;
     });
 }
+function semverValid(required, installed) {
+    if (!required || !installed) {
+        return true;
+    }
+    // If 'installed' is a single version and 'required' is a range
+    if (semver.valid(installed) && semver.validRange(required)) {
+        logger_1.logger.debug('range vs version');
+        return semver.satisfies(installed, required);
+    }
+    // If 'required' is a single version and 'installed' is a range
+    if (semver.valid(required) && semver.validRange(installed)) {
+        logger_1.logger.debug('version vs range');
+        return semver.satisfies(required, installed);
+    }
+    // If both are single versions, simply compare them
+    if (semver.valid(required) && semver.valid(installed)) {
+        logger_1.logger.debug('version vs version');
+        return semver.gt(installed, required);
+    }
+    // If both are ranges, check if they intersect
+    if (semver.validRange(required) && semver.validRange(installed)) {
+        logger_1.logger.debug('range vs range');
+        return semver.intersects(required, installed);
+    }
+    return false;
+}

package/dist/facts/repoDependencyFacts.test.js

@@ -31,195 +31,139 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const globals_1 = require("@jest/globals");
-const fs = __importStar(require("fs"));
-const child_process_1 = require("child_process");
 const repoDependencyFacts = __importStar(require("./repoDependencyFacts"));
-globals_1.jest.mock('fs');
-globals_1.jest.mock('child_process');
-globals_1.jest.mock('../core/cli', () => ({
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+jest.mock('child_process');
+jest.mock('fs');
+jest.mock('../utils/logger');
+jest.mock('../core/cli', () => ({
     options: {
-        dir: '/test/dir'
+        dir: '/mock/dir'
     }
 }));
 describe('repoDependencyFacts', () => {
     beforeEach(() => {
-        globals_1.jest.clearAllMocks();
+        jest.clearAllMocks();
     });
     describe('collectLocalDependencies', () => {
         it('should collect Yarn dependencies when yarn.lock exists', () => {
-            fs.existsSync.mockImplementation((file) => typeof file === 'string' && file.endsWith('yarn.lock'));
+            fs_1.default.existsSync.mockImplementation((filePath) => filePath.includes('yarn.lock'));
             child_process_1.execSync.mockReturnValue(JSON.stringify({
                 data: {
                     trees: [
-                        { name: 'package-a@1.0.0', children: [{ name: 'package-b@2.0.0' }] }
+                        { name: 'package1@1.0.0', children: [{ name: 'subpackage1@0.1.0' }] },
+                        { name: 'package2@2.0.0' }
                     ]
                 }
             }));
             const result = repoDependencyFacts.collectLocalDependencies();
             expect(result).toEqual([
-                { name: 'package-a', version: '1.0.0', dependencies: [{ name: 'package-b', version: '2.0.0' }] }
+                { name: 'package1', version: '1.0.0', dependencies: [{ name: 'subpackage1', version: '0.1.0' }] },
+                { name: 'package2', version: '2.0.0' }
             ]);
         });
         it('should collect NPM dependencies when package-lock.json exists', () => {
-            fs.existsSync.mockImplementation((file) => typeof file === 'string' && file.endsWith('package-lock.json'));
+            fs_1.default.existsSync.mockImplementation((filePath) => filePath.includes('package-lock.json'));
             child_process_1.execSync.mockReturnValue(JSON.stringify({
                 dependencies: {
-                    'package-a': { version: '1.0.0', dependencies: { 'package-b': { version: '2.0.0' } } }
+                    package1: { version: '1.0.0', dependencies: { subpackage1: { version: '0.1.0' } } },
+                    package2: { version: '2.0.0' }
                 }
             }));
             const result = repoDependencyFacts.collectLocalDependencies();
             expect(result).toEqual([
-                { name: 'package-a', version: '1.0.0', dependencies: [{ name: 'package-b', version: '2.0.0' }] }
+                { name: 'package1', version: '1.0.0', dependencies: [{ name: 'subpackage1', version: '0.1.0' }] },
+                { name: 'package2', version: '2.0.0' }
             ]);
         });
-        it('should throw an error when no lock file is found', () => {
-            fs.existsSync.mockReturnValue(false);
+        it('should throw an error when no supported lock file is found', () => {
+            fs_1.default.existsSync.mockReturnValue(false);
             expect(() => repoDependencyFacts.collectLocalDependencies()).toThrow('Unsupported package manager');
         });
     });
-    describe('getDependencyVersionFacts', () => {
-        it('should return installed dependency versions', () => __awaiter(void 0, void 0, void 0, function* () {
-            const mockArchetypeConfig = {
-                name: 'test-archetype',
-                rules: [],
-                operators: [],
-                facts: [],
-                config: {
-                    minimumDependencyVersions: {
-                        'package-a': '1.0.0',
-                        'package-b': '2.0.0'
-                    },
-                    standardStructure: {},
-                    blacklistPatterns: [],
-                    whitelistPatterns: []
-                }
-            };
-            fs.existsSync.mockImplementation((file) => typeof file === 'string' && file.endsWith('package-lock.json'));
-            child_process_1.execSync.mockReturnValue(JSON.stringify({
-                dependencies: {
-                    'package-a': { version: '1.1.0', dependencies: { 'package-b': { version: '2.1.0' } } }
-                }
-            }));
-            globals_1.jest.spyOn(repoDependencyFacts, 'collectLocalDependencies').mockReturnValue([
-                { name: 'package-a', version: '1.1.0' },
-                { name: 'package-b', version: '2.1.0' },
-                { name: 'package-c', version: '3.0.0' }
-            ]);
-            const result = repoDependencyFacts.getDependencyVersionFacts(mockArchetypeConfig);
-            expect(result).toEqual([
-                { dep: 'package-a', ver: '1.1.0', min: '1.0.0' },
-                { dep: 'package-a/package-b', ver: '2.1.0', min: '2.0.0' }
-            ]);
-        }));
-        it('should return an empty array when no local dependencies are found', () => __awaiter(void 0, void 0, void 0, function* () {
-            const mockArchetypeConfig = {
-                name: 'test-archetype',
-                rules: [],
-                operators: [],
-                facts: [],
-                config: {
-                    minimumDependencyVersions: {},
-                    standardStructure: {},
-                    blacklistPatterns: [],
-                    whitelistPatterns: []
-                }
-            };
-            globals_1.jest.spyOn(repoDependencyFacts, 'collectLocalDependencies').mockReturnValue([]);
-            const result = repoDependencyFacts.getDependencyVersionFacts(mockArchetypeConfig);
-            expect(result).toEqual([]);
-        }));
-    });
     describe('findPropertiesInTree', () => {
         it('should find properties in a nested dependency tree', () => {
             const depGraph = [
                 {
-                    name: 'package-a',
+                    name: 'root1',
                     version: '1.0.0',
                     dependencies: [
-                        { name: 'package-b', version: '2.0.0' },
-                        { name: 'package-c', version: '3.0.0', dependencies: [{ name: 'package-d', version: '4.0.0' }] }
+                        { name: 'child1', version: '0.1.0' },
+                        {
+                            name: 'child2',
+                            version: '0.2.0',
+                            dependencies: [
+                                { name: 'grandchild1', version: '0.0.1' }
+                            ]
+                        }
                     ]
-                }
+                },
+                { name: 'root2', version: '2.0.0' }
             ];
             const minVersions = {
-                'package-a': '0.9.0',
-                'package-c': '2.9.0',
-                'package-d': '3.9.0'
+                'child1': '^0.1.0',
+                'grandchild1': '^0.0.1',
+                'root2': '^1.5.0'
             };
             const result = repoDependencyFacts.findPropertiesInTree(depGraph, minVersions);
             expect(result).toEqual([
-                { dep: 'package-a', ver: '1.0.0', min: '0.9.0' },
-                { dep: 'package-a/package-c', ver: '3.0.0', min: '2.9.0' },
-                { dep: 'package-a/package-c/package-d', ver: '4.0.0', min: '3.9.0' }
+                { dep: 'root1/child1', ver: '0.1.0', min: '^0.1.0' },
+                { dep: 'root1/child2/grandchild1', ver: '0.0.1', min: '^0.0.1' },
+                { dep: 'root2', ver: '2.0.0', min: '^1.5.0' }
             ]);
         });
         it('should return an empty array when no matching properties are found', () => {
             const depGraph = [
-                { name: 'package-x', version: '1.0.0' },
-                { name: 'package-y', version: '2.0.0' }
+                { name: 'package1', version: '1.0.0' },
+                { name: 'package2', version: '2.0.0' }
             ];
             const minVersions = {
-                'package-z': '3.0.0'
+                'package3': '^3.0.0'
             };
             const result = repoDependencyFacts.findPropertiesInTree(depGraph, minVersions);
             expect(result).toEqual([]);
         });
     });
     describe('repoDependencyAnalysis', () => {
-        it('should return an empty result for non-global checks', () => __awaiter(void 0, void 0, void 0, function* () {
-            const almanac = {
-                factValue: globals_1.jest.fn().mockResolvedValue({ fileName: 'not-global-check' })
-            };
-            const result = yield repoDependencyFacts.repoDependencyAnalysis({}, almanac);
+        const mockAlmanac = {
+            factValue: jest.fn(),
+            addRuntimeFact: jest.fn(),
+        };
+        it('should return an empty result for non-REPO_GLOBAL_CHECK files', () => __awaiter(void 0, void 0, void 0, function* () {
+            mockAlmanac.factValue.mockResolvedValueOnce({ fileName: 'some-file.js' });
+            const result = yield repoDependencyFacts.repoDependencyAnalysis({}, mockAlmanac);
             expect(result).toEqual({ result: [] });
         }));
-        it('should analyze dependencies and return failures', () => __awaiter(void 0, void 0, void 0, function* () {
-            const almanac = {
-                factValue: globals_1.jest.fn().mockImplementation((fact) => {
-                    if (fact === 'fileData') {
-                        return Promise.resolve({ fileName: 'REPO_GLOBAL_CHECK' });
-                    }
-                    if (fact === 'dependencyData') {
-                        return Promise.resolve({
-                            installedDependencyVersions: [
-                                { dep: 'package-a', ver: '1.0.0', min: '2.0.0' },
-                                { dep: 'package-b', ver: '3.0.0', min: '2.0.0' }
-                            ]
-                        });
-                    }
-                }),
-                addRuntimeFact: globals_1.jest.fn()
-            };
-            const result = yield repoDependencyFacts.repoDependencyAnalysis({ resultFact: 'testFact' }, almanac);
-            expect(result).toEqual({
-                result: [
-                    { dependency: 'package-a', currentVersion: '1.0.0', requiredVersion: '2.0.0' }
-                ]
-            });
-            expect(almanac.addRuntimeFact).toHaveBeenCalledWith('testFact', result);
-        }));
-        it('should return an empty result when all dependencies meet requirements', () => __awaiter(void 0, void 0, void 0, function* () {
-            const almanac = {
-                factValue: globals_1.jest.fn().mockImplementation((fact) => {
-                    if (fact === 'fileData') {
-                        return Promise.resolve({ fileName: 'REPO_GLOBAL_CHECK' });
-                    }
-                    if (fact === 'dependencyData') {
-                        return Promise.resolve({
-                            installedDependencyVersions: [
-                                { dep: 'package-a', ver: '2.1.0', min: '2.0.0' },
-                                { dep: 'package-b', ver: '3.0.0', min: '2.0.0' }
-                            ]
-                        });
-                    }
-                }),
-                addRuntimeFact: globals_1.jest.fn()
-            };
-            const result = yield repoDependencyFacts.repoDependencyAnalysis({ resultFact: 'testFact' }, almanac);
-            expect(result).toEqual({ result: [] });
-            expect(almanac.addRuntimeFact).toHaveBeenCalledWith('testFact', result);
-        }));
+    });
+    describe('semverValid', () => {
+        it('should return true for valid version comparisons', () => {
+            expect(repoDependencyFacts.semverValid('2.0.0', '^1.0.0')).toBe(false);
+            expect(repoDependencyFacts.semverValid('1.5.0', '1.0.0 - 2.0.0')).toBe(true);
+            expect(repoDependencyFacts.semverValid('1.0.0', '1.0.0')).toBe(true);
+            expect(repoDependencyFacts.semverValid('2.0.0', '>=1.0.0')).toBe(true);
+        });
+        it('should return false for invalid version comparisons', () => {
+            expect(repoDependencyFacts.semverValid('1.0.0', '^2.0.0')).toBe(false);
+            expect(repoDependencyFacts.semverValid('3.0.0', '1.0.0 - 2.0.0')).toBe(false);
+            expect(repoDependencyFacts.semverValid('0.9.0', '>=1.0.0')).toBe(false);
+        });
+        it('should handle complex version ranges', () => {
+            expect(repoDependencyFacts.semverValid('1.2.3', '1.x || >=2.5.0 || 5.0.0 - 7.2.3')).toBe(true);
+            expect(repoDependencyFacts.semverValid('2.5.0', '1.x || >=2.5.0 || 5.0.0 - 7.2.3')).toBe(true);
+            expect(repoDependencyFacts.semverValid('5.5.5', '1.x || >=2.5.0 || 5.0.0 - 7.2.3')).toBe(true);
+            expect(repoDependencyFacts.semverValid('8.0.0', '1.x || >=9.5.0 || 5.0.0 - 7.2.3')).toBe(false);
+        });
+        it('should return true for empty strings', () => {
+            expect(repoDependencyFacts.semverValid('', '')).toBe(true);
+        });
+        it('should return false for invalid input', () => {
+            expect(repoDependencyFacts.semverValid('not-a-version', '1.0.0')).toBe(false);
+            expect(repoDependencyFacts.semverValid('1.0.0', 'not-a-range')).toBe(false);
+        });
     });
 });

package/dist/operators/openaiAnalysisHighSeverity.js

@@ -10,18 +10,18 @@ const openaiAnalysisHighSeverity = {
                 logger_1.logger.error('openaiAnalysisHighSeverity: TypeError: Cannot read properties of undefined (reading \'result\')');
                 return false;
             }
-            severityThreshold = parseInt(severityThreshold) ? parseInt(severityThreshold) : 8;
-            let result = false;
+            const threshold = parseInt(severityThreshold) || 8;
             if (Array.isArray(openaiAnalysis.result) && openaiAnalysis.result.length > 0) {
-                if (openaiAnalysis.result.some((issue) => {
+                const hasHighSeverityIssue = openaiAnalysis.result.some((issue) => {
                     const severity = parseInt(issue === null || issue === void 0 ? void 0 : issue.severity);
-                    return !isNaN(severity) && severity >= severityThreshold;
-                })) {
+                    return !isNaN(severity) && severity >= threshold;
+                });
+                if (hasHighSeverityIssue) {
                     logger_1.logger.error('openai: high severity issues found');
-                    result = true;
+                    return true;
                 }
             }
-            return result;
+            return false;
         }
         catch (e) {
             // for now we don't fail the build if openai response parsing fails

package/dist/operators/openaiAnalysisHighSeverity.test.js

@@ -20,7 +20,7 @@ describe('openaiAnalysisHighSeverity', () => {
             ]
         };
         const result = openaiAnalysisHighSeverity_1.openaiAnalysisHighSeverity.fn(openaiAnalysis, 8);
-        expect(result).toBe(false);
+        expect(result).toEqual(false);
         expect(logger_1.logger.error).not.toHaveBeenCalled();
     });
     it('should return true if high severity issues are found', () => {
@@ -31,7 +31,7 @@ describe('openaiAnalysisHighSeverity', () => {
             ]
         };
         const result = openaiAnalysisHighSeverity_1.openaiAnalysisHighSeverity.fn(openaiAnalysis, 8);
-        expect(result).toBe(true);
+        expect(result).toEqual(true);
         expect(logger_1.logger.error).toHaveBeenCalledWith('openai: high severity issues found');
     });
     it('should use default severity threshold if not provided', () => {
@@ -41,7 +41,7 @@ describe('openaiAnalysisHighSeverity', () => {
             ]
         };
         const result = openaiAnalysisHighSeverity_1.openaiAnalysisHighSeverity.fn(openaiAnalysis, null);
-        expect(result).toBe(true);
+        expect(result).toEqual(true);
         expect(logger_1.logger.error).toHaveBeenCalledWith('openai: high severity issues found');
     });
     it('should handle empty result array', () => {
@@ -80,4 +80,15 @@ describe('openaiAnalysisHighSeverity', () => {
         expect(result).toBe(true);
         expect(logger_1.logger.error).toHaveBeenCalledWith('openai: high severity issues found');
     });
+    it('should use default severity threshold when not provided', () => {
+        const openaiAnalysis = {
+            result: [
+                { severity: 7 },
+                { severity: 8 }
+            ]
+        };
+        const result = openaiAnalysisHighSeverity_1.openaiAnalysisHighSeverity.fn(openaiAnalysis, null);
+        expect(result).toBe(true);
+        expect(logger_1.logger.error).toHaveBeenCalledWith('openai: high severity issues found');
+    });
 });

package/dist/utils/configManager.js

@@ -63,6 +63,39 @@ class ConfigManager {
             return ConfigManager.configs[archetype];
         });
     }
+    static loadExemptions(localConfigPath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const exemptionsPath = path.join(localConfigPath, 'exemptions.json');
+            try {
+                const exemptionsData = yield fs_1.default.promises.readFile(exemptionsPath, 'utf-8');
+                const exemptionsJson = JSON.parse(exemptionsData);
+                ConfigManager.exemptions = exemptionsJson.exemptions;
+                logger_1.logger.info(`Loaded ${ConfigManager.exemptions.length} exemptions`);
+            }
+            catch (error) {
+                logger_1.logger.warn(`Failed to load exemptions: ${error}`);
+                ConfigManager.exemptions = [];
+            }
+        });
+    }
+    static getExemptions() {
+        return ConfigManager.exemptions;
+    }
+    static getExemptionExpirationDate(repoUrl, ruleName) {
+        const exemption = ConfigManager.exemptions.find(exemption => exemption.repoUrl === repoUrl &&
+            exemption.rule === ruleName);
+        return exemption ? new Date(exemption.expirationDate) : undefined;
+    }
+    static isExempt(repoUrl, ruleName) {
+        const now = new Date();
+        const result = ConfigManager.exemptions.some(exemption => exemption.repoUrl === repoUrl &&
+            exemption.rule === ruleName &&
+            new Date(exemption.expirationDate) > now);
+        if (result) {
+            logger_1.logger.error(`Exempting rule ${ruleName} for repo ${repoUrl} until ${ConfigManager.getExemptionExpirationDate(repoUrl, ruleName)}`);
+        }
+        return result;
+    }
     static initialize(params) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
@@ -176,3 +209,4 @@ class ConfigManager {
 }
 exports.ConfigManager = ConfigManager;
 ConfigManager.configs = {};
+ConfigManager.exemptions = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "x-fidelity",
-  "version": "2.5.0",
+  "version": "2.7.0",
   "description": "cli for opinionated framework adherence checks",
   "main": "dist/xfidelity",
   "bin": {

package/src/core/engine/analyzer.ts

@@ -20,7 +20,13 @@ export async function analyzeCodebase(params: AnalyzeCodebaseParams): Promise<Re
     
     logger.info(`STARTING..`);
 
+    // Load exemptions
+    if (localConfigPath) {
+        await ConfigManager.loadExemptions(localConfigPath);
+    }
+
     const telemetryData = await collectTelemetryData({ repoPath, configServer});
+    const repoUrl = telemetryData.repoUrl;
 
     // Send telemetry for analysis start
     await sendTelemetry({
@@ -76,7 +82,8 @@ export async function analyzeCodebase(params: AnalyzeCodebaseParams): Promise<Re
         fileData,
         installedDependencyVersions,
         minimumDependencyVersions,
-        standardStructure
+        standardStructure,
+        repoUrl
     });
 
     const finishMsg = `\n==========================\nCHECKS COMPLETED..\n==========================`;

package/src/core/engine/engineRunner.test.ts

@@ -29,6 +29,7 @@ describe('runEngineOnFiles', () => {
         installedDependencyVersions: {},
         minimumDependencyVersions: {},
         standardStructure: {},
+        repoUrl: 'https://github.com/mock/repo',
     };
 
     beforeEach(() => {

package/src/core/engine/engineRunner.ts

@@ -1,12 +1,12 @@
 import { EngineResult, RuleResult } from 'json-rules-engine';
 import { ScanResult, RuleFailure } from '../../types/typeDefs';
 import { logger } from '../../utils/logger';
-import { REPO_GLOBAL_CHECK } from '../../utils/configManager';
+import { REPO_GLOBAL_CHECK, ConfigManager } from '../../utils/configManager';
 
 import { RunEngineOnFilesParams } from '../../types/typeDefs';
 
 export async function runEngineOnFiles(params: RunEngineOnFilesParams): Promise<ScanResult[]> {
-    const { engine, fileData, installedDependencyVersions, minimumDependencyVersions, standardStructure } = params;
+    const { engine, fileData, installedDependencyVersions, minimumDependencyVersions, standardStructure, repoUrl } = params;
     const msg = `\n==========================\nRUNNING FILE CHECKS..\n==========================`;
     logger.info(msg);
     const failures: ScanResult[] = [];
@@ -32,7 +32,7 @@ export async function runEngineOnFiles(params: RunEngineOnFilesParams): Promise<
             const { results }: EngineResult = await engine.run(facts);
             results.forEach((result: RuleResult) => {
                 logger.debug(JSON.stringify(result));
-                if (result.result) {
+                if (result.result && !ConfigManager.isExempt(repoUrl, result.name)) {
                     fileFailures.push({
                         ruleFailure: result.name,
                         level: result.event?.type,

package/src/facts/repoDependencyFacts.test.ts

@@ -1,229 +1,162 @@
-import { jest } from '@jest/globals';
-import * as fs from 'fs';
+import * as repoDependencyFacts from './repoDependencyFacts';
 import { execSync } from 'child_process';
+import fs from 'fs';
 import { Almanac } from 'json-rules-engine';
-import * as repoDependencyFacts from './repoDependencyFacts';
-import { LocalDependencies, ArchetypeConfig } from '../types/typeDefs';
+import { LocalDependencies, MinimumDepVersions } from '../types/typeDefs';
 
-jest.mock('fs');
 jest.mock('child_process');
+jest.mock('fs');
+jest.mock('../utils/logger');
 jest.mock('../core/cli', () => ({
-  options: {
-    dir: '/test/dir'
-  }
+    options: {
+        dir: '/mock/dir'
+    }
 }));
 
 describe('repoDependencyFacts', () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-  });
-
-  describe('collectLocalDependencies', () => {
-    it('should collect Yarn dependencies when yarn.lock exists', () => {
-      (fs.existsSync as jest.Mock).mockImplementation((file: unknown) => typeof file === 'string' && file.endsWith('yarn.lock'));
-      (execSync as jest.Mock).mockReturnValue(JSON.stringify({
-        data: {
-          trees: [
-            { name: 'package-a@1.0.0', children: [{ name: 'package-b@2.0.0' }] }
-          ]
-        }
-      }));
-
-      const result = repoDependencyFacts.collectLocalDependencies();
-
-      expect(result).toEqual([
-        { name: 'package-a', version: '1.0.0', dependencies: [{ name: 'package-b', version: '2.0.0' }] }
-      ]);
-    });
-
-    it('should collect NPM dependencies when package-lock.json exists', () => {
-      (fs.existsSync as jest.Mock).mockImplementation((file: unknown) => typeof file === 'string' && file.endsWith('package-lock.json'));
-      (execSync as jest.Mock).mockReturnValue(JSON.stringify({
-        dependencies: {
-          'package-a': { version: '1.0.0', dependencies: { 'package-b': { version: '2.0.0' } } }
-        }
-      }));
-
-      const result = repoDependencyFacts.collectLocalDependencies();
-
-      expect(result).toEqual([
-        { name: 'package-a', version: '1.0.0', dependencies: [{ name: 'package-b', version: '2.0.0' }] }
-      ]);
+    beforeEach(() => {
+        jest.clearAllMocks();
     });
 
-    it('should throw an error when no lock file is found', () => {
-      (fs.existsSync as jest.Mock).mockReturnValue(false);
-
-      expect(() => repoDependencyFacts.collectLocalDependencies()).toThrow('Unsupported package manager');
-    });
-  });
-
-  describe('getDependencyVersionFacts', () => {
-    it('should return installed dependency versions', async () => {
-      const mockArchetypeConfig: ArchetypeConfig = {
-        name: 'test-archetype',
-        rules: [],
-        operators: [],
-        facts: [],
-        config: {
-          minimumDependencyVersions: {
-            'package-a': '1.0.0',
-            'package-b': '2.0.0'
-          },
-          standardStructure: {},
-          blacklistPatterns: [],
-          whitelistPatterns: []
-        }
-      };
-
-      (fs.existsSync as jest.Mock).mockImplementation((file: unknown) => typeof file === 'string' && file.endsWith('package-lock.json'));
-      (execSync as jest.Mock).mockReturnValue(JSON.stringify({
-        dependencies: {
-          'package-a': { version: '1.1.0', dependencies: { 'package-b': { version: '2.1.0' } } }
-        }
-      }));
-
-      jest.spyOn(repoDependencyFacts, 'collectLocalDependencies' as any).mockReturnValue([
-        { name: 'package-a', version: '1.1.0' },
-        { name: 'package-b', version: '2.1.0' },
-        { name: 'package-c', version: '3.0.0' }
-      ]);
-
-      const result = repoDependencyFacts.getDependencyVersionFacts(mockArchetypeConfig);
-
-      expect(result).toEqual([
-        { dep: 'package-a', ver: '1.1.0', min: '1.0.0' },
-        { dep: 'package-a/package-b', ver: '2.1.0', min: '2.0.0' }
-      ]);
+    describe('collectLocalDependencies', () => {
+        it('should collect Yarn dependencies when yarn.lock exists', () => {
+            (fs.existsSync as jest.Mock).mockImplementation((filePath) => filePath.includes('yarn.lock'));
+            (execSync as jest.Mock).mockReturnValue(JSON.stringify({
+                data: {
+                    trees: [
+                        { name: 'package1@1.0.0', children: [{ name: 'subpackage1@0.1.0' }] },
+                        { name: 'package2@2.0.0' }
+                    ]
+                }
+            }));
+
+            const result = repoDependencyFacts.collectLocalDependencies();
+
+            expect(result).toEqual([
+                { name: 'package1', version: '1.0.0', dependencies: [{ name: 'subpackage1', version: '0.1.0' }] },
+                { name: 'package2', version: '2.0.0' }
+            ]);
+        });
+
+        it('should collect NPM dependencies when package-lock.json exists', () => {
+            (fs.existsSync as jest.Mock).mockImplementation((filePath) => filePath.includes('package-lock.json'));
+            (execSync as jest.Mock).mockReturnValue(JSON.stringify({
+                dependencies: {
+                    package1: { version: '1.0.0', dependencies: { subpackage1: { version: '0.1.0' } } },
+                    package2: { version: '2.0.0' }
+                }
+            }));
+
+            const result = repoDependencyFacts.collectLocalDependencies();
+
+            expect(result).toEqual([
+                { name: 'package1', version: '1.0.0', dependencies: [{ name: 'subpackage1', version: '0.1.0' }] },
+                { name: 'package2', version: '2.0.0' }
+            ]);
+        });
+
+        it('should throw an error when no supported lock file is found', () => {
+            (fs.existsSync as jest.Mock).mockReturnValue(false);
+
+            expect(() => repoDependencyFacts.collectLocalDependencies()).toThrow('Unsupported package manager');
+        });
     });
 
-    it('should return an empty array when no local dependencies are found', async () => {
-      const mockArchetypeConfig: ArchetypeConfig = {
-        name: 'test-archetype',
-        rules: [],
-        operators: [],
-        facts: [],
-        config: {
-          minimumDependencyVersions: {},
-          standardStructure: {},
-          blacklistPatterns: [],
-          whitelistPatterns: []
-        }
-      };
-
-      jest.spyOn(repoDependencyFacts, 'collectLocalDependencies' as any).mockReturnValue([]);
-
-      const result = repoDependencyFacts.getDependencyVersionFacts(mockArchetypeConfig);
-
-      expect(result).toEqual([]);
+    describe('findPropertiesInTree', () => {
+        it('should find properties in a nested dependency tree', () => {
+            const depGraph: LocalDependencies[] = [
+                {
+                    name: 'root1',
+                    version: '1.0.0',
+                    dependencies: [
+                        { name: 'child1', version: '0.1.0' },
+                        { 
+                            name: 'child2',
+                            version: '0.2.0',
+                            dependencies: [
+                                { name: 'grandchild1', version: '0.0.1' }
+                            ]
+                        }
+                    ]
+                },
+                { name: 'root2', version: '2.0.0' }
+            ];
+
+            const minVersions: MinimumDepVersions = {
+                'child1': '^0.1.0',
+                'grandchild1': '^0.0.1',
+                'root2': '^1.5.0'
+            };
+
+            const result = repoDependencyFacts.findPropertiesInTree(depGraph, minVersions);
+
+            expect(result).toEqual([
+                { dep: 'root1/child1', ver: '0.1.0', min: '^0.1.0' },
+                { dep: 'root1/child2/grandchild1', ver: '0.0.1', min: '^0.0.1' },
+                { dep: 'root2', ver: '2.0.0', min: '^1.5.0' }
+            ]);
+        });
+
+        it('should return an empty array when no matching properties are found', () => {
+            const depGraph: LocalDependencies[] = [
+                { name: 'package1', version: '1.0.0' },
+                { name: 'package2', version: '2.0.0' }
+            ];
+
+            const minVersions: MinimumDepVersions = {
+                'package3': '^3.0.0'
+            };
+
+            const result = repoDependencyFacts.findPropertiesInTree(depGraph, minVersions);
+
+            expect(result).toEqual([]);
+        });
     });
-  });
-
-  describe('findPropertiesInTree', () => {
-    it('should find properties in a nested dependency tree', () => {
-      const depGraph: LocalDependencies[] = [
-        {
-          name: 'package-a',
-          version: '1.0.0',
-          dependencies: [
-            { name: 'package-b', version: '2.0.0' },
-            { name: 'package-c', version: '3.0.0', dependencies: [{ name: 'package-d', version: '4.0.0' }] }
-          ]
-        }
-      ];
-
-      const minVersions = {
-        'package-a': '0.9.0',
-        'package-c': '2.9.0',
-        'package-d': '3.9.0'
-      };
-
-      const result = repoDependencyFacts.findPropertiesInTree(depGraph, minVersions);
-
-      expect(result).toEqual([
-        { dep: 'package-a', ver: '1.0.0', min: '0.9.0' },
-        { dep: 'package-a/package-c', ver: '3.0.0', min: '2.9.0' },
-        { dep: 'package-a/package-c/package-d', ver: '4.0.0', min: '3.9.0' }
-      ]);
-    });
-
-    it('should return an empty array when no matching properties are found', () => {
-      const depGraph: LocalDependencies[] = [
-        { name: 'package-x', version: '1.0.0' },
-        { name: 'package-y', version: '2.0.0' }
-      ];
 
-      const minVersions = {
-        'package-z': '3.0.0'
-      };
+    describe('repoDependencyAnalysis', () => {
+        const mockAlmanac: Almanac = {
+            factValue: jest.fn(),
+            addRuntimeFact: jest.fn(),
+        } as unknown as Almanac;
 
-      const result = repoDependencyFacts.findPropertiesInTree(depGraph, minVersions);
+        it('should return an empty result for non-REPO_GLOBAL_CHECK files', async () => {
+            (mockAlmanac.factValue as jest.Mock).mockResolvedValueOnce({ fileName: 'some-file.js' });
 
-      expect(result).toEqual([]);
-    });
-  });
-
-  describe('repoDependencyAnalysis', () => {
-    it('should return an empty result for non-global checks', async () => {
-      const almanac = {
-        factValue: jest.fn().mockResolvedValue({ fileName: 'not-global-check' } as never)
-      } as unknown as Almanac;
+            const result = await repoDependencyFacts.repoDependencyAnalysis({}, mockAlmanac);
 
-      const result = await repoDependencyFacts.repoDependencyAnalysis({}, almanac);
-
-      expect(result).toEqual({ result: [] });
-    });
+            expect(result).toEqual({ result: [] });
+        });
 
-    it('should analyze dependencies and return failures', async () => {
-      const almanac = {
-        factValue: jest.fn().mockImplementation((fact) => {
-          if (fact === 'fileData') {
-            return Promise.resolve({ fileName: 'REPO_GLOBAL_CHECK' });
-          }
-          if (fact === 'dependencyData') {
-            return Promise.resolve({
-              installedDependencyVersions: [
-                { dep: 'package-a', ver: '1.0.0', min: '2.0.0' },
-                { dep: 'package-b', ver: '3.0.0', min: '2.0.0' }
-              ]
-            });
-          }
-        }),
-        addRuntimeFact: jest.fn()
-      } as unknown as Almanac;
-
-      const result = await repoDependencyFacts.repoDependencyAnalysis({ resultFact: 'testFact' }, almanac);
-
-      expect(result).toEqual({
-        result: [
-          { dependency: 'package-a', currentVersion: '1.0.0', requiredVersion: '2.0.0' }
-        ]
-      });
-      expect(almanac.addRuntimeFact).toHaveBeenCalledWith('testFact', result);
     });
 
-    it('should return an empty result when all dependencies meet requirements', async () => {
-      const almanac = {
-        factValue: jest.fn().mockImplementation((fact) => {
-          if (fact === 'fileData') {
-            return Promise.resolve({ fileName: 'REPO_GLOBAL_CHECK' });
-          }
-          if (fact === 'dependencyData') {
-            return Promise.resolve({
-              installedDependencyVersions: [
-                { dep: 'package-a', ver: '2.1.0', min: '2.0.0' },
-                { dep: 'package-b', ver: '3.0.0', min: '2.0.0' }
-              ]
-            });
-          }
-        }),
-        addRuntimeFact: jest.fn()
-      } as unknown as Almanac;
-
-      const result = await repoDependencyFacts.repoDependencyAnalysis({ resultFact: 'testFact' }, almanac);
-
-      expect(result).toEqual({ result: [] });
-      expect(almanac.addRuntimeFact).toHaveBeenCalledWith('testFact', result);
+    describe('semverValid', () => {
+        it('should return true for valid version comparisons', () => {
+            expect(repoDependencyFacts.semverValid('2.0.0', '^1.0.0')).toBe(false);
+            expect(repoDependencyFacts.semverValid('1.5.0', '1.0.0 - 2.0.0')).toBe(true);
+            expect(repoDependencyFacts.semverValid('1.0.0', '1.0.0')).toBe(true);
+            expect(repoDependencyFacts.semverValid('2.0.0', '>=1.0.0')).toBe(true);
+        });
+
+        it('should return false for invalid version comparisons', () => {
+            expect(repoDependencyFacts.semverValid('1.0.0', '^2.0.0')).toBe(false);
+            expect(repoDependencyFacts.semverValid('3.0.0', '1.0.0 - 2.0.0')).toBe(false);
+            expect(repoDependencyFacts.semverValid('0.9.0', '>=1.0.0')).toBe(false);
+        });
+
+        it('should handle complex version ranges', () => {
+            expect(repoDependencyFacts.semverValid('1.2.3', '1.x || >=2.5.0 || 5.0.0 - 7.2.3')).toBe(true);
+            expect(repoDependencyFacts.semverValid('2.5.0', '1.x || >=2.5.0 || 5.0.0 - 7.2.3')).toBe(true);
+            expect(repoDependencyFacts.semverValid('5.5.5', '1.x || >=2.5.0 || 5.0.0 - 7.2.3')).toBe(true);
+            expect(repoDependencyFacts.semverValid('8.0.0', '1.x || >=9.5.0 || 5.0.0 - 7.2.3')).toBe(false);
+        });
+
+        it('should return true for empty strings', () => {
+            expect(repoDependencyFacts.semverValid('', '')).toBe(true);
+        });
+
+        it('should return false for invalid input', () => {
+            expect(repoDependencyFacts.semverValid('not-a-version', '1.0.0')).toBe(false);
+            expect(repoDependencyFacts.semverValid('1.0.0', 'not-a-range')).toBe(false);
+        });
     });
-  });
 });

package/src/facts/repoDependencyFacts.ts

@@ -13,7 +13,7 @@ import path from 'path';
  * @returns The local dependencies.
  */
 export function collectLocalDependencies(): LocalDependencies[] {
-    let result:LocalDependencies[] = [];
+    let result: LocalDependencies[] = [];
     if (fs.existsSync(path.join(options.dir, 'yarn.lock'))) {
         result = collectYarnDependencies();
     } else if (fs.existsSync(path.join(options.dir, 'package-lock.json'))) {
@@ -22,7 +22,7 @@ export function collectLocalDependencies(): LocalDependencies[] {
         logger.error('No yarn.lock or package-lock.json found');
         throw new Error('Unsupported package manager');
     }
-    logger.debug(`collectLocalDependencies: ${JSON.stringify(result)}`);
+    logger.info(`collectLocalDependencies: ${JSON.stringify(result)}`);
     return result;
 }
 
@@ -121,7 +121,7 @@ export function getDependencyVersionFacts(archetypeConfig: ArchetypeConfig): Ver
 export function findPropertiesInTree(depGraph: LocalDependencies[], minVersions: MinimumDepVersions): VersionData[] {
     const results: VersionData[] = [];
 
-    logger.debug(`depGraph: ${JSON.stringify(depGraph)}`);
+    logger.info(`depGraph: ${JSON.stringify(depGraph)}`);
 
     function walk(dep: LocalDependencies, parentName = '') {
         const fullName = parentName ? `${parentName}/${dep.name}` : dep.name;
@@ -136,6 +136,7 @@ export function findPropertiesInTree(depGraph: LocalDependencies[], minVersions:
     }
 
     depGraph.forEach(dep => walk(dep));
+    logger.info(JSON.stringify(depGraph))
     return results;
 }
 
@@ -151,11 +152,12 @@ export async function repoDependencyAnalysis(params: any, almanac: Almanac) {
     const analysis: any = [];
     const dependencyData: any = await almanac.factValue('dependencyData');
 
-    dependencyData.installedDependencyVersions.map((versionData: VersionData) => { 
+    dependencyData.installedDependencyVersions.forEach((versionData: VersionData) => { 
         logger.debug(`outdatedFramework: checking ${versionData.dep}`);
 
-        const requiredRange = new semver.Range(versionData.min);
-        if (!semver.gtr(versionData.ver, requiredRange)) {
+        // Check if the installed version satisfies the required version, supporting both ranges and specific versions
+        const isValid = semverValid(versionData.ver, versionData.min);
+        if (!isValid) {
             const dependencyFailure = {
                 'dependency': versionData.dep,
                 'currentVersion': versionData.ver,
@@ -173,3 +175,36 @@ export async function repoDependencyAnalysis(params: any, almanac: Almanac) {
 
     return result;
 }
+
+export function semverValid(required: string, installed: string): boolean {
+
+    if (!required || !installed) {
+        return true;
+    }
+
+    // If 'installed' is a single version and 'required' is a range
+    if (semver.valid(installed) && semver.validRange(required)) {
+        logger.debug('range vs version');
+        return semver.satisfies(installed, required);
+    }
+
+    // If 'required' is a single version and 'installed' is a range
+    if (semver.valid(required) && semver.validRange(installed)) {
+        logger.debug('version vs range');
+        return semver.satisfies(required, installed);
+    }
+
+    // If both are single versions, simply compare them
+    if (semver.valid(required) && semver.valid(installed)) {
+        logger.debug('version vs version');
+        return semver.gt(installed, required);
+    }
+
+    // If both are ranges, check if they intersect
+    if (semver.validRange(required) && semver.validRange(installed)) {
+        logger.debug('range vs range');
+        return semver.intersects(required, installed);
+    }
+
+    return false;
+}

package/src/operators/openaiAnalysisHighSeverity.test.ts

@@ -21,7 +21,7 @@ describe('openaiAnalysisHighSeverity', () => {
             ]
         };
         const result = openaiAnalysisHighSeverity.fn(openaiAnalysis, 8);
-        expect(result).toBe(false);
+        expect(result).toEqual(false);
         expect(logger.error).not.toHaveBeenCalled();
     });
 
@@ -33,7 +33,7 @@ describe('openaiAnalysisHighSeverity', () => {
             ]
         };
         const result = openaiAnalysisHighSeverity.fn(openaiAnalysis, 8);
-        expect(result).toBe(true);
+        expect(result).toEqual(true);
         expect(logger.error).toHaveBeenCalledWith('openai: high severity issues found');
     });
 
@@ -44,7 +44,7 @@ describe('openaiAnalysisHighSeverity', () => {
             ]
         };
         const result = openaiAnalysisHighSeverity.fn(openaiAnalysis, null);
-        expect(result).toBe(true);
+        expect(result).toEqual(true);
         expect(logger.error).toHaveBeenCalledWith('openai: high severity issues found');
     });
 
@@ -87,4 +87,16 @@ describe('openaiAnalysisHighSeverity', () => {
         expect(result).toBe(true);
         expect(logger.error).toHaveBeenCalledWith('openai: high severity issues found');
     });
+
+    it('should use default severity threshold when not provided', () => {
+        const openaiAnalysis = {
+            result: [
+                { severity: 7 },
+                { severity: 8 }
+            ]
+        };
+        const result = openaiAnalysisHighSeverity.fn(openaiAnalysis, null);
+        expect(result).toBe(true);
+        expect(logger.error).toHaveBeenCalledWith('openai: high severity issues found');
+    });
 });

package/src/operators/openaiAnalysisHighSeverity.ts

@@ -10,23 +10,24 @@ const openaiAnalysisHighSeverity: OperatorDefn = {
                 return false;
             }
 
-            severityThreshold = parseInt(severityThreshold) ? parseInt(severityThreshold) : 8;
-            let result = false;
+            const threshold = parseInt(severityThreshold) || 8;
             
             if (Array.isArray(openaiAnalysis.result) && openaiAnalysis.result.length > 0) {
-                if (openaiAnalysis.result.some((issue: any) => {
+                const hasHighSeverityIssue = openaiAnalysis.result.some((issue: any) => {
                     const severity = parseInt(issue?.severity);
-                    return !isNaN(severity) && severity >= severityThreshold;
-                })) {
+                    return !isNaN(severity) && severity >= threshold;
+                });
+
+                if (hasHighSeverityIssue) {
                     logger.error('openai: high severity issues found');
-                    result = true;
+                    return true;
                 }
             }
         
-            return result;
+            return false;
         } catch (e) {
             // for now we don't fail the build if openai response parsing fails
-            logger.debug(e)
+            logger.debug(e);
             logger.error(`openaiAnalysisHighSeverity: ${e}`);
             return false;
         }

package/src/types/typeDefs.ts

@@ -53,6 +53,14 @@ export interface RunEngineOnFilesParams {
     installedDependencyVersions: any;
     minimumDependencyVersions: any;
     standardStructure: any;
+    repoUrl: string;
+}
+
+export interface Exemption {
+    repoUrl: string;
+    rule: string;
+    expirationDate: string;
+    reason: string;
 }
 
 export interface AnalyzeCodebaseParams {

package/src/utils/configManager.ts

@@ -1,6 +1,6 @@
 import { axiosClient } from "./axiosClient";
 import { logger, setLogPrefix } from "./logger";
-import { ArchetypeConfig, ExecutionConfig, GetConfigParams, InitializeParams, LoadLocalConfigParams, RuleConfig } from "../types/typeDefs";
+import { ArchetypeConfig, ExecutionConfig, GetConfigParams, InitializeParams, LoadLocalConfigParams, RuleConfig, Exemption } from "../types/typeDefs";
 import { archetypes } from "../archetypes";
 import { options } from '../core/cli';
 import fs from 'fs';
@@ -12,6 +12,7 @@ export const REPO_GLOBAL_CHECK = 'REPO_GLOBAL_CHECK';
 
 export class ConfigManager {
     private static configs: { [key: string]: ExecutionConfig } = {};
+    private static exemptions: Exemption[] = [];
 
     public static getLoadedConfigs(): string[] {
         return Object.keys(ConfigManager.configs);
@@ -31,6 +32,44 @@ export class ConfigManager {
         return ConfigManager.configs[archetype];
     }
 
+    public static async loadExemptions(localConfigPath: string): Promise<void> {
+        const exemptionsPath = path.join(localConfigPath, 'exemptions.json');
+        try {
+            const exemptionsData = await fs.promises.readFile(exemptionsPath, 'utf-8');
+            const exemptionsJson = JSON.parse(exemptionsData);
+            ConfigManager.exemptions = exemptionsJson.exemptions;
+            logger.info(`Loaded ${ConfigManager.exemptions.length} exemptions`);
+        } catch (error) {
+            logger.warn(`Failed to load exemptions: ${error}`);
+            ConfigManager.exemptions = [];
+        }
+    }
+
+    public static getExemptions(): Exemption[] {
+        return ConfigManager.exemptions;
+    }
+
+    public static getExemptionExpirationDate(repoUrl: string, ruleName: string): Date | undefined {
+        const exemption = ConfigManager.exemptions.find(exemption => 
+            exemption.repoUrl === repoUrl &&
+            exemption.rule === ruleName
+        );
+        return exemption ? new Date(exemption.expirationDate) : undefined;
+    }
+
+    public static isExempt(repoUrl: string, ruleName: string): boolean {
+        const now = new Date();
+        const result =  ConfigManager.exemptions.some(exemption => 
+            exemption.repoUrl === repoUrl &&
+            exemption.rule === ruleName &&
+            new Date(exemption.expirationDate) > now
+        );
+        if (result) {
+            logger.error(`Exempting rule ${ruleName} for repo ${repoUrl} until ${ConfigManager.getExemptionExpirationDate(repoUrl, ruleName)}`);
+        }
+        return result;
+    }
+
     private static async initialize(params: InitializeParams): Promise<ExecutionConfig> {
         const { archetype, logPrefix } = params;
         const configServer = options.configServer;