x-fidelity 2.2.0 → 2.4.0

package/CHANGELOG.md

@@ -1,3 +1,79 @@
+# [2.4.0](https://github.com/zotoio/x-fidelity/compare/v2.3.0...v2.4.0) (2024-08-21)
+
+
+### Bug Fixes
+
+* add unit tests for all files except typeDefs ([b1d1fd9](https://github.com/zotoio/x-fidelity/commit/b1d1fd9d069d2bd54712ae0cf96a9e48ebec903e))
+* **deps:** make artillery a peer dependency ([d89361f](https://github.com/zotoio/x-fidelity/commit/d89361fcc24744cfa52df6cbe52b6117b92e46d8))
+* Handle errors during execution ([48a9488](https://github.com/zotoio/x-fidelity/commit/48a94882eff7db64e0f996a6b55d3dde9eca080b))
+* Improve error handling and execution flow in index.ts ([0b8ca73](https://github.com/zotoio/x-fidelity/commit/0b8ca73d3cc4b0b498ab9a8cf93d9d67965243af))
+* Increase timeout for test case to prevent "force exited" issue ([ab3d0b3](https://github.com/zotoio/x-fidelity/commit/ab3d0b30696f6056df8a386b5eb366f4c545dbfa))
+* **logging:** silence in logs and increase unit test coverage ([5017a12](https://github.com/zotoio/x-fidelity/commit/5017a1216c5dedc443d40787aa70ea40814de49c))
+* Mock axiosClient instead of axios in rules/index.test.ts ([40e7410](https://github.com/zotoio/x-fidelity/commit/40e74108b45813244fa3810649d1b681a1e85af5))
+* Pass executionLogPrefix to startServer and analyzeCodebase ([99a6692](https://github.com/zotoio/x-fidelity/commit/99a669232d77a8bfaeca22590efcdc9fd9ecb80a))
+* Prevent unnecessary process exit in test environment ([aab777f](https://github.com/zotoio/x-fidelity/commit/aab777f76f4ab3c98322c93250bbfa5d35f2812a))
+* Remove setTimeout and directly call process.exit(1) in error handling function ([8a7587e](https://github.com/zotoio/x-fidelity/commit/8a7587ea169ff8313d187f4ea71487eb8273623f))
+* resolve TypeScript errors in telemetry utility ([3c68aa1](https://github.com/zotoio/x-fidelity/commit/3c68aa1d4d3b2594dd05fa120233a56ff06d5206))
+* Update import and call of main function in index.test.ts ([70e11b1](https://github.com/zotoio/x-fidelity/commit/70e11b18dfbf272035e96a004b6f7b889644c229))
+* Update import and export in index.test.ts and index.ts ([b15203d](https://github.com/zotoio/x-fidelity/commit/b15203d8aa3b37b211c5a57edd8dd0ea58c9d93f))
+* Update index.test.ts ([b3d1799](https://github.com/zotoio/x-fidelity/commit/b3d1799153de1f502f5b897d268c30999189f1ca))
+* Update process.exit usage in src/index.ts ([ac398c3](https://github.com/zotoio/x-fidelity/commit/ac398c31cd944e2c062db5d7b57254f026a89f8c))
+* Update startServer function call and process exit handling ([7be6c28](https://github.com/zotoio/x-fidelity/commit/7be6c280dda46f49a8c1c45149b93fcadd261ccb))
+* update test expectations ([d24279e](https://github.com/zotoio/x-fidelity/commit/d24279e8520f882260299190b9562831b7c79528))
+* Update test expectations to match actual error messages ([454aea6](https://github.com/zotoio/x-fidelity/commit/454aea6a8cf38cfdd1b9ed31288c119f7f37dbbf))
+* update type of `code` parameter in `mockImplementation` function ([f7aab15](https://github.com/zotoio/x-fidelity/commit/f7aab15c67e155da2fedb29a704633629561964a))
+
+
+### Features
+
+* centralise the axios client usage in one file and implement exponential backoff ([9a6d000](https://github.com/zotoio/x-fidelity/commit/9a6d00051c92cbe498c429503356f445d64d1685))
+
+# [2.3.0](https://github.com/zotoio/x-fidelity/compare/v2.2.0...v2.3.0) (2024-08-20)
+
+
+### Bug Fixes
+
+* Add clearCache import and ConfigManager import to configServer.ts ([4212096](https://github.com/zotoio/x-fidelity/commit/4212096ea2459e4c55a7c6b396755d72f440ecb6))
+* address SSRF risks in `githubWebhookRoute` ([9b6d64a](https://github.com/zotoio/x-fidelity/commit/9b6d64acf7e49604815b606292890a4b50a11ab8))
+* Clear rule list cache correctly ([3cb17c7](https://github.com/zotoio/x-fidelity/commit/3cb17c7e54e9c8be19b03405a3b13eeaf21bf16c))
+* import missing middleware functions ([fd00a4f](https://github.com/zotoio/x-fidelity/commit/fd00a4f9b4b2dac3ef41782f517186a07ce1c53c))
+* Improve security and mitigate potential SSRF risks in configManager and configServer ([f87ccab](https://github.com/zotoio/x-fidelity/commit/f87ccab24c465d374ef191973d4f3f500ebcca00))
+* move the github webhook route and related update code to separate route file ([4deb57e](https://github.com/zotoio/x-fidelity/commit/4deb57e57f4b95cda757aaa84e8c3f89485e24cd))
+* Properly handle asynchronous operations in configServer.test.ts ([2de6174](https://github.com/zotoio/x-fidelity/commit/2de6174330e518a49c0530455f9bfd4118f648d2))
+* Refactor ConfigManager class ([7f1c2fe](https://github.com/zotoio/x-fidelity/commit/7f1c2fe2e895684145c843615876e3118be095a9))
+* Update configServer to use RuleConfig from ConfigManager ([100c0b3](https://github.com/zotoio/x-fidelity/commit/100c0b301423ca111aa8e452073d3c190a317fbc))
+* Update engineSetup.test.ts to use ConfigManager and setLogPrefix ([c36c64d](https://github.com/zotoio/x-fidelity/commit/c36c64de689a952a500a360dffe8e57605d2dbac))
+* Update error message and fix warning detection test ([9f37bf5](https://github.com/zotoio/x-fidelity/commit/9f37bf502407404ddad355a5ac7d4d8710153b80))
+* Update mock configuration in engineSetup.test.ts ([fd3d7db](https://github.com/zotoio/x-fidelity/commit/fd3d7dbaab3ae51b5c6cbc6d0970f3bf2b2db32c))
+* Update mockParams object to include archetypeConfig property ([b0c9628](https://github.com/zotoio/x-fidelity/commit/b0c9628050643fbc508a087f2387144961a74264))
+* Update rule schema definition ([ed5d87a](https://github.com/zotoio/x-fidelity/commit/ed5d87a3579cd2f6d7eb414207a3cfb9bd571d70))
+* Update ruleSchema to match RuleProperties type ([0f09992](https://github.com/zotoio/x-fidelity/commit/0f099925b14d32d044e5c8fb3583cfec4bb39ae7))
+* Update test configuration for analyzer ([f0b139d](https://github.com/zotoio/x-fidelity/commit/f0b139d7b208553d131d682e19a7b0ccebd5febf))
+* Update test expectation for loadFacts ([ee04ee0](https://github.com/zotoio/x-fidelity/commit/ee04ee0c38883e5c073e6360fe6febed45e42cc6))
+* Update test expectations for loadFacts ([4c57421](https://github.com/zotoio/x-fidelity/commit/4c57421de624622404e6232f450057f200781a2b))
+* Validate and sanitize archetype input in configManager ([3a92119](https://github.com/zotoio/x-fidelity/commit/3a921195beb1ac0da0421aafb443adbf77d83eb2))
+
+
+### Features
+
+* add clearcache route ([89e9633](https://github.com/zotoio/x-fidelity/commit/89e96333ae1bb36b4673c09ddc8b69f6b1ed9740))
+* Add file watcher for local config path ([43da2f3](https://github.com/zotoio/x-fidelity/commit/43da2f3b84f2c852426813068487702c4745d549))
+* Add GitHub webhook route ([cab04ae](https://github.com/zotoio/x-fidelity/commit/cab04ae5c7fbba954e9b85c8182ec3595215a8f9))
+* Add GitHub webhook route to handle archetype or rule config updates ([5af3d63](https://github.com/zotoio/x-fidelity/commit/5af3d63d4d9ef6f3f48a5be4001d3f28f1522d6c))
+* Add high-value unit tests for utility functions ([f90d5e2](https://github.com/zotoio/x-fidelity/commit/f90d5e218cc8c5743515744fc9584801c3003398))
+* Add input validation for URL parameters and telemetry data ([77bdfaa](https://github.com/zotoio/x-fidelity/commit/77bdfaa4e35c34e62c341fca6f87db46726db993))
+* Add support for additional properties in rule schema ([98826e5](https://github.com/zotoio/x-fidelity/commit/98826e5edad1a443d6299a1ad3b970517c384783))
+* add viewcache route ([1fa105c](https://github.com/zotoio/x-fidelity/commit/1fa105c6c29ef05b8eb5312c638785dd5d56af07))
+* Create comprehensive unit test file for engineSetup.ts ([50556ce](https://github.com/zotoio/x-fidelity/commit/50556ce257cb579ef856b74a012b986b81490f2b))
+* Implement GitHub webhook to update local config ([351fbf0](https://github.com/zotoio/x-fidelity/commit/351fbf022100f8e9acc3734b291afdac9057e386))
+* Implement server routes and middleware ([3de18a6](https://github.com/zotoio/x-fidelity/commit/3de18a6cab08a26ecd51f7dc9148da5fee93aeba))
+* load all RuleConfig for a given archetype into the ExecutionConfig ([a122c52](https://github.com/zotoio/x-fidelity/commit/a122c52986adeadeec9085b5c94bfd5e142e80d8))
+* move the configServer features related to caching into a new file ([95a9908](https://github.com/zotoio/x-fidelity/commit/95a9908c97878b062337e100b37ae1d4919b53e5))
+* **rules:** github hook to refresh config ([2485fbe](https://github.com/zotoio/x-fidelity/commit/2485fbe36a9f5102fe815209e0961f604b0e6f30))
+* **rules:** optimise loading of rules, and filesystem watcher for server ([6e6c5ac](https://github.com/zotoio/x-fidelity/commit/6e6c5ac0a784ab76b9d3ec476de580225932b443))
+* update configserver to use new route files ([eda8240](https://github.com/zotoio/x-fidelity/commit/eda8240a09073612f060d65494d4973b1b170c94))
+* Update rule schema to improve flexibility and compatibility ([989bdf6](https://github.com/zotoio/x-fidelity/commit/989bdf64ead3148a366c046f6c0e883d6b1b1109))
+
 # [2.2.0](https://github.com/zotoio/x-fidelity/compare/v2.1.0...v2.2.0) (2024-08-20)
 
 

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

@@ -17,7 +17,6 @@ const openaiAnalysisFacts_1 = require("../../facts/openaiAnalysisFacts");
 const rules_1 = require("../../rules");
 const operators_1 = require("../../operators");
 const facts_1 = require("../../facts");
-const archetypes_1 = require("../../archetypes");
 const configManager_1 = require("../../utils/configManager");
 const telemetry_1 = require("../../utils/telemetry");
 const openaiUtils_1 = require("../../utils/openaiUtils");
@@ -64,8 +63,19 @@ describe('analyzeCodebase', () => {
     beforeEach(() => {
         jest.clearAllMocks();
         configManager_1.ConfigManager.getConfig.mockResolvedValue({
-            archetype: archetypes_1.archetypes['node-fullstack'],
-            rules: [],
+            archetype: {
+                name: 'test-archetype',
+                rules: ['rule1'],
+                operators: ['operator1'],
+                facts: ['fact1'],
+                config: {
+                    minimumDependencyVersions: {},
+                    standardStructure: {},
+                    blacklistPatterns: [],
+                    whitelistPatterns: []
+                }
+            },
+            rules: [{ name: 'rule1', conditions: { all: [] }, event: { type: 'test', params: {} } }],
             cliOptions: {}
         });
         // eslint-disable-next-line @typescript-eslint/no-empty-function
@@ -104,9 +114,8 @@ describe('analyzeCodebase', () => {
         });
         expect(repoFilesystemFacts_1.collectRepoFileData).toHaveBeenCalledWith('mockRepoPath', expect.any(Object));
         expect(repoDependencyFacts_1.getDependencyVersionFacts).toHaveBeenCalledWith(expect.any(Object));
-        expect(rules_1.loadRules).toHaveBeenCalledWith({ archetype: 'node-fullstack', ruleNames: ['mockRule'], configServer: '', logPrefix: '', localConfigPath: '' });
-        expect(operators_1.loadOperators).toHaveBeenCalledWith(['mockOperator']);
-        expect(facts_1.loadFacts).toHaveBeenCalledWith(['mockFact']);
+        expect(operators_1.loadOperators).toHaveBeenCalledWith(['operator1']);
+        expect(facts_1.loadFacts).toHaveBeenCalledWith(['fact1']);
         expect(engineRunMock).toHaveBeenCalledTimes(mockFileData.length);
         expect(results).toEqual({
             XFI_RESULT: expect.objectContaining({
@@ -157,9 +166,8 @@ describe('analyzeCodebase', () => {
         });
         expect(repoFilesystemFacts_1.collectRepoFileData).toHaveBeenCalledWith('mockRepoPath', expect.any(Object));
         expect(repoDependencyFacts_1.getDependencyVersionFacts).toHaveBeenCalled();
-        expect(rules_1.loadRules).toHaveBeenCalledWith({ archetype: 'node-fullstack', ruleNames: ['mockRule'], configServer: '', logPrefix: '', localConfigPath: '' });
-        expect(operators_1.loadOperators).toHaveBeenCalledWith(['mockOperator']);
-        expect(facts_1.loadFacts).toHaveBeenCalledWith(['mockFact']);
+        expect(operators_1.loadOperators).toHaveBeenCalledWith(['operator1']);
+        expect(facts_1.loadFacts).toHaveBeenCalledWith(['fact1']);
         expect(engineRunMock).toHaveBeenCalledTimes(mockFileData.length);
         expect(results).toEqual({
             XFI_RESULT: expect.objectContaining({

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

@@ -18,6 +18,7 @@ jest.mock('../../utils/logger', () => ({
         info: jest.fn(),
         debug: jest.fn(),
         error: jest.fn(),
+        warn: jest.fn(),
     },
 }));
 describe('runEngineOnFiles', () => {

package/dist/core/engine/engineSetup.js

@@ -14,12 +14,11 @@ const json_rules_engine_1 = require("json-rules-engine");
 const logger_1 = require("../../utils/logger");
 const operators_1 = require("../../operators");
 const facts_1 = require("../../facts");
-const rules_1 = require("../../rules");
-const cli_1 = require("../../core/cli");
 const telemetry_1 = require("../../utils/telemetry");
+const configManager_1 = require("../../utils/configManager");
 function setupEngine(params) {
     return __awaiter(this, void 0, void 0, function* () {
-        const { archetypeConfig, archetype, executionLogPrefix, localConfigPath } = params;
+        const { archetypeConfig, archetype, executionLogPrefix } = params;
         const engine = new json_rules_engine_1.Engine([], { replaceFactsInEventParams: true, allowUndefinedFacts: true });
         // Add operators to engine
         logger_1.logger.info(`=== loading custom operators..`);
@@ -33,21 +32,21 @@ function setupEngine(params) {
         });
         // Add rules to engine
         logger_1.logger.info(`=== loading json rules..`);
-        const rules = yield (0, rules_1.loadRules)({ archetype, ruleNames: archetypeConfig.rules, configServer: cli_1.options.configServer, logPrefix: executionLogPrefix, localConfigPath });
-        logger_1.logger.debug(rules);
-        rules.forEach((rule) => {
+        const config = yield configManager_1.ConfigManager.getConfig({ archetype, logPrefix: executionLogPrefix });
+        logger_1.logger.debug(config.rules);
+        config.rules.forEach((rule) => {
             try {
                 logger_1.logger.info(`adding rule: ${rule === null || rule === void 0 ? void 0 : rule.name}`);
                 engine.addRule(rule);
             }
             catch (e) {
-                console.error(`Error loading rule: ${rule === null || rule === void 0 ? void 0 : rule.name}`);
+                logger_1.logger.error(`Error loading rule: ${rule === null || rule === void 0 ? void 0 : rule.name}`);
                 logger_1.logger.error(e.message);
             }
         });
         engine.on('success', (_a) => __awaiter(this, [_a], void 0, function* ({ type, params }) {
             if (type === 'warning') {
-                logger_1.logger.warn(`warning detected: ${JSON.stringify(params)}}`);
+                logger_1.logger.warn(`warning detected: ${JSON.stringify(params)}`);
                 yield (0, telemetry_1.sendTelemetry)({
                     eventType: 'warning',
                     metadata: Object.assign({ archetype, repoPath: '' }, params),
@@ -55,7 +54,7 @@ function setupEngine(params) {
                 }, executionLogPrefix);
             }
             if (type === 'fatality') {
-                logger_1.logger.error(`fatality detected: ${JSON.stringify(params)}}`);
+                logger_1.logger.error(`fatality detected: ${JSON.stringify(params)}`);
                 yield (0, telemetry_1.sendTelemetry)({
                     eventType: 'fatality',
                     metadata: Object.assign({ archetype, repoPath: '' }, params),

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

@@ -13,127 +13,156 @@ const engineSetup_1 = require("./engineSetup");
 const json_rules_engine_1 = require("json-rules-engine");
 const operators_1 = require("../../operators");
 const facts_1 = require("../../facts");
-const rules_1 = require("../../rules");
 const telemetry_1 = require("../../utils/telemetry");
-const openaiUtils_1 = require("../../utils/openaiUtils");
-const cli_1 = require("../cli");
+const configManager_1 = require("../../utils/configManager");
+const logger_1 = require("../../utils/logger");
 jest.mock('json-rules-engine');
 jest.mock('../../operators');
 jest.mock('../../facts');
-jest.mock('../../rules');
 jest.mock('../../utils/telemetry');
-jest.mock('../../utils/openaiUtils');
-jest.mock('../../utils/logger', () => ({
-    logger: {
-        info: jest.fn(),
-        debug: jest.fn(),
-        error: jest.fn(),
-        warn: jest.fn(),
-    },
-}));
+jest.mock('../../utils/configManager');
+jest.mock('../../utils/logger');
 describe('setupEngine', () => {
     const mockArchetypeConfig = {
         name: 'test-archetype',
-        rules: ['rule1'],
-        operators: ['operator1'],
-        facts: ['fact1'],
+        rules: ['rule1', 'rule2'],
+        operators: ['operator1', 'operator2'],
+        facts: ['fact1', 'fact2'],
         config: {
             minimumDependencyVersions: {},
             standardStructure: {},
             blacklistPatterns: [],
             whitelistPatterns: []
-        },
+        }
     };
     const mockParams = {
         archetypeConfig: mockArchetypeConfig,
         archetype: 'test-archetype',
-        configManager: {},
+        configManager: configManager_1.ConfigManager,
         executionLogPrefix: 'test-prefix',
-        localConfigPath: '/test/path',
+        localConfigPath: '/test/path'
     };
     beforeEach(() => {
         jest.clearAllMocks();
-        process.env.OPENAI_API_KEY = 'test-key';
-    });
-    it('should set up engine with correct configurations', () => __awaiter(void 0, void 0, void 0, function* () {
-        const mockEngine = {
-            addOperator: jest.fn(),
-            addRule: jest.fn(),
-            addFact: jest.fn(),
-            on: jest.fn(),
-        };
-        json_rules_engine_1.Engine.mockImplementation(() => mockEngine);
-        operators_1.loadOperators.mockResolvedValue([{ name: 'operator1', fn: jest.fn() }]);
-        facts_1.loadFacts.mockResolvedValue([{ name: 'fact1', fn: jest.fn() }]);
-        rules_1.loadRules.mockResolvedValue([{ name: 'rule1' }]);
-        openaiUtils_1.isOpenAIEnabled.mockReturnValue(true);
-        yield (0, engineSetup_1.setupEngine)(mockParams);
-        expect(json_rules_engine_1.Engine).toHaveBeenCalled();
-        expect(operators_1.loadOperators).toHaveBeenCalledWith(['operator1']);
-        expect(facts_1.loadFacts).toHaveBeenCalledWith(['fact1']);
-        expect(rules_1.loadRules).toHaveBeenCalledWith(expect.objectContaining({
-            archetype: 'test-archetype',
-            ruleNames: ['rule1'],
-        }));
-        expect(mockEngine.addOperator).toHaveBeenCalled();
-        expect(mockEngine.addRule).toHaveBeenCalled();
-        expect(mockEngine.addFact).toHaveBeenCalled();
-        expect(mockEngine.on).toHaveBeenCalledWith('success', expect.any(Function));
-    }));
-    it('should not add OpenAI-related operators and facts when OpenAI is disabled', () => __awaiter(void 0, void 0, void 0, function* () {
-        cli_1.options.openai = false;
-        process.env.OPENAI_API_KEY = '';
-        const mockEngine = {
-            addOperator: jest.fn(),
-            addRule: jest.fn(),
-            addFact: jest.fn(),
-            on: jest.fn(),
-        };
-        json_rules_engine_1.Engine.mockImplementation(() => mockEngine);
+        configManager_1.ConfigManager.getConfig.mockResolvedValue({
+            archetype: mockArchetypeConfig,
+            rules: [
+                { name: 'rule1', conditions: { all: [] }, event: { type: 'test', params: {} } },
+                { name: 'rule2', conditions: { all: [] }, event: { type: 'test', params: {} } }
+            ],
+            cliOptions: {}
+        });
         operators_1.loadOperators.mockResolvedValue([
             { name: 'operator1', fn: jest.fn() },
-            { name: 'openaiOperator', fn: jest.fn() },
+            { name: 'operator2', fn: jest.fn() }
         ]);
         facts_1.loadFacts.mockResolvedValue([
             { name: 'fact1', fn: jest.fn() },
-            { name: 'openaiAnalysis', fn: jest.fn() },
+            { name: 'fact2', fn: jest.fn() }
         ]);
-        rules_1.loadRules.mockResolvedValue([{ name: 'rule1' }]);
-        openaiUtils_1.isOpenAIEnabled.mockReturnValue(false);
+    });
+    it('should create and configure an engine instance', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mockAddOperator = jest.fn();
+        const mockAddRule = jest.fn();
+        const mockAddFact = jest.fn();
+        const mockOn = jest.fn();
+        json_rules_engine_1.Engine.mockImplementation(() => ({
+            addOperator: mockAddOperator,
+            addRule: mockAddRule,
+            addFact: mockAddFact,
+            on: mockOn
+        }));
+        const engine = yield (0, engineSetup_1.setupEngine)(mockParams);
+        expect(json_rules_engine_1.Engine).toHaveBeenCalledWith([], { replaceFactsInEventParams: true, allowUndefinedFacts: true });
+        expect(operators_1.loadOperators).toHaveBeenCalledWith(['operator1', 'operator2']);
+        expect(facts_1.loadFacts).toHaveBeenCalledWith(['fact1', 'fact2']);
+        expect(configManager_1.ConfigManager.getConfig).toHaveBeenCalledWith({ archetype: 'test-archetype', logPrefix: 'test-prefix' });
+        expect(mockAddOperator).toHaveBeenCalledTimes(2);
+        expect(mockAddRule).toHaveBeenCalledTimes(2);
+        expect(mockAddFact).toHaveBeenCalledTimes(2);
+        expect(mockOn).toHaveBeenCalledTimes(1);
+        expect(engine).toBeDefined();
+    }));
+    it('should handle errors when loading rules', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mockAddRule = jest.fn().mockImplementationOnce(() => {
+            throw new Error('Rule loading error');
+        });
+        json_rules_engine_1.Engine.mockImplementation(() => ({
+            addOperator: jest.fn(),
+            addRule: mockAddRule,
+            addFact: jest.fn(),
+            on: jest.fn()
+        }));
         yield (0, engineSetup_1.setupEngine)(mockParams);
-        expect(mockEngine.addOperator).toHaveBeenCalledTimes(1);
-        expect(mockEngine.addFact).toHaveBeenCalledTimes(1);
-        expect(mockEngine.addOperator).not.toHaveBeenCalledWith('openaiOperator', expect.any(Function));
-        expect(mockEngine.addFact).not.toHaveBeenCalledWith('openaiAnalysis', expect.any(Function));
+        expect(mockAddRule).toHaveBeenCalledTimes(2);
+        expect(logger_1.logger.error).toHaveBeenCalledWith('Rule loading error');
     }));
-    it('should send telemetry on warning and fatality events', () => __awaiter(void 0, void 0, void 0, function* () {
-        const mockEngine = {
+    it('should set up event listeners for success events', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mockOn = jest.fn();
+        json_rules_engine_1.Engine.mockImplementation(() => ({
             addOperator: jest.fn(),
             addRule: jest.fn(),
             addFact: jest.fn(),
-            on: jest.fn(),
-        };
-        json_rules_engine_1.Engine.mockImplementation(() => mockEngine);
-        operators_1.loadOperators.mockResolvedValue([{ name: 'operator1', fn: jest.fn() }]);
-        facts_1.loadFacts.mockResolvedValue([{ name: 'fact1', fn: jest.fn() }]);
-        rules_1.loadRules.mockResolvedValue([{ name: 'rule1' }]);
+            on: mockOn
+        }));
         yield (0, engineSetup_1.setupEngine)(mockParams);
-        const successCallback = mockEngine.on.mock.calls[0][1];
+        expect(mockOn).toHaveBeenCalledWith('success', expect.any(Function));
         // Test warning event
-        yield successCallback({ type: 'warning', params: { message: 'Test warning' } });
+        const warningCallback = mockOn.mock.calls[0][1];
+        yield warningCallback({ type: 'warning', params: { message: 'Test warning' } });
+        expect(logger_1.logger.warn).toHaveBeenCalledWith('warning detected: {"message":"Test warning"}');
         expect(telemetry_1.sendTelemetry).toHaveBeenCalledWith(expect.objectContaining({
             eventType: 'warning',
             metadata: expect.objectContaining({
                 archetype: 'test-archetype',
-            }),
+                message: 'Test warning'
+            })
         }), 'test-prefix');
         // Test fatality event
-        yield successCallback({ type: 'fatality', params: { message: 'Test fatality' } });
+        yield warningCallback({ type: 'fatality', params: { message: 'Test fatality' } });
+        expect(logger_1.logger.error).toHaveBeenCalledWith('fatality detected: {"message":"Test fatality"}');
         expect(telemetry_1.sendTelemetry).toHaveBeenCalledWith(expect.objectContaining({
             eventType: 'fatality',
             metadata: expect.objectContaining({
                 archetype: 'test-archetype',
-            }),
+                message: 'Test fatality'
+            })
         }), 'test-prefix');
     }));
+    it('should not add OpenAI-related facts when OpenAI is not enabled', () => __awaiter(void 0, void 0, void 0, function* () {
+        process.env.OPENAI_API_KEY = '';
+        const mockAddFact = jest.fn();
+        json_rules_engine_1.Engine.mockImplementation(() => ({
+            addOperator: jest.fn(),
+            addRule: jest.fn(),
+            addFact: mockAddFact,
+            on: jest.fn()
+        }));
+        facts_1.loadFacts.mockResolvedValue([
+            { name: 'fact1', fn: jest.fn() },
+            { name: 'openaiAnalysis', fn: jest.fn() }
+        ]);
+        yield (0, engineSetup_1.setupEngine)(mockParams);
+        expect(mockAddFact).toHaveBeenCalledTimes(1);
+        expect(mockAddFact).toHaveBeenCalledWith('fact1', expect.any(Function));
+        expect(mockAddFact).not.toHaveBeenCalledWith('openaiAnalysis', expect.any(Function));
+    }));
+    it('should add OpenAI-related facts when OpenAI is enabled', () => __awaiter(void 0, void 0, void 0, function* () {
+        process.env.OPENAI_API_KEY = 'test-key';
+        const mockAddFact = jest.fn();
+        json_rules_engine_1.Engine.mockImplementation(() => ({
+            addOperator: jest.fn(),
+            addRule: jest.fn(),
+            addFact: mockAddFact,
+            on: jest.fn()
+        }));
+        facts_1.loadFacts.mockResolvedValue([
+            { name: 'fact1', fn: jest.fn() },
+            { name: 'openaiAnalysis', fn: jest.fn() }
+        ]);
+        yield (0, engineSetup_1.setupEngine)(mockParams);
+        expect(mockAddFact).toHaveBeenCalledTimes(2);
+        expect(mockAddFact).toHaveBeenCalledWith('fact1', expect.any(Function));
+        expect(mockAddFact).toHaveBeenCalledWith('openaiAnalysis', expect.any(Function));
+    }));
 });

package/dist/facts/openaiAnalysisFacts.test.js

@@ -21,6 +21,7 @@ jest.mock('../utils/logger', () => ({
         debug: jest.fn(),
         error: jest.fn(),
         info: jest.fn(),
+        warn: jest.fn(),
     },
 }));
 jest.mock('openai', () => {

package/dist/index.js

@@ -13,6 +13,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.main = main;
 const logger_1 = require("./utils/logger");
 const prettyjson_1 = __importDefault(require("prettyjson"));
 const cli_1 = require("./core/cli");
@@ -21,18 +22,32 @@ const configServer_1 = require("./server/configServer");
 const telemetry_1 = require("./utils/telemetry");
 const executionLogPrefix = (0, logger_1.generateLogPrefix)();
 (0, logger_1.setLogPrefix)(executionLogPrefix);
+// Function to handle errors and send telemetry
+const handleError = (error) => __awaiter(void 0, void 0, void 0, function* () {
+    yield (0, telemetry_1.sendTelemetry)({
+        eventType: 'execution failure',
+        metadata: {
+            archetype: cli_1.options.archetype,
+            repoPath: cli_1.options.dir,
+            options: cli_1.options,
+            errorMessage: error.message
+        },
+        timestamp: new Date().toISOString()
+    }, executionLogPrefix);
+    logger_1.logger.error(JSON.stringify(error));
+});
 const outcomeMessage = (message) => `\n
 ==========================================================================
 ${message}
 ==========================================================================`;
-logger_1.logger.debug(`startup options: ${cli_1.options}`);
-(() => __awaiter(void 0, void 0, void 0, function* () {
-    try {
-        if (cli_1.options.mode === 'server') {
-            (0, configServer_1.startServer)({ customPort: cli_1.options.port, executionLogPrefix });
-        }
-        else {
-            (() => __awaiter(void 0, void 0, void 0, function* () {
+logger_1.logger.debug(`startup options: ${JSON.stringify(cli_1.options)}`);
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            if (cli_1.options.mode === 'server') {
+                yield (0, configServer_1.startServer)({ customPort: cli_1.options.port, executionLogPrefix });
+            }
+            else {
                 const resultMetadata = yield (0, analyzer_1.analyzeCodebase)({
                     repoPath: cli_1.options.dir,
                     archetype: cli_1.options.archetype,
@@ -43,40 +58,36 @@ logger_1.logger.debug(`startup options: ${cli_1.options}`);
                 // if results are found, there were issues found in the codebase
                 if (resultMetadata.XFI_RESULT.totalIssues > 0) {
                     logger_1.logger.warn(`WARNING: lo-fi attributes detected in codebase. ${resultMetadata.XFI_RESULT.warningCount} are warnings, ${resultMetadata.XFI_RESULT.fatalityCount} are fatal.`);
-                    logger_1.logger.warn(JSON.stringify({ XFI_RESULT: resultMetadata }));
+                    logger_1.logger.warn(JSON.stringify(resultMetadata));
+                    logger_1.logger.warn(`\n${prettyjson_1.default.render(resultMetadata)}\n\n`);
                     if (resultMetadata.XFI_RESULT.fatalityCount > 0) {
                         logger_1.logger.error(outcomeMessage(`THERE WERE ${resultMetadata.XFI_RESULT.fatalityCount} FATAL ERRORS DETECTED TO BE IMMEDIATELY ADDRESSED!`));
-                        setTimeout(() => process.exit(1), 1000);
+                        logger_1.logger.on('finish', function () {
+                            process.exit(1);
+                        });
+                        logger_1.logger.error(`\n${prettyjson_1.default.render(resultMetadata.XFI_RESULT.issueDetails)}\n\n`);
+                        logger_1.logger.error(outcomeMessage(`THERE WERE ${resultMetadata.XFI_RESULT.fatalityCount} FATAL ERRORS DETECTED TO BE IMMEDIATELY ADDRESSED!`));
+                        logger_1.logger.end();
                     }
                     else {
                         logger_1.logger.warn(outcomeMessage('No fatal errors were found, however please review the following warnings.'));
+                        logger_1.logger.warn(`\n${prettyjson_1.default.render(resultMetadata.XFI_RESULT.issueDetails)}\n\n`);
+                        logger_1.logger.warn(outcomeMessage('No fatal errors were found, however please review the above warnings.'));
                     }
-                    console.log(`\n${prettyjson_1.default.render(resultMetadata.XFI_RESULT.issueDetails)}\n\n`);
                 }
                 else {
                     logger_1.logger.info(outcomeMessage('SUCCESS! hi-fi codebase detected.'));
+                    logger_1.logger.info(JSON.stringify(resultMetadata));
+                    logger_1.logger.info(`\n${prettyjson_1.default.render(resultMetadata)}\n\n`);
+                    logger_1.logger.info(outcomeMessage('SUCCESS! hi-fi codebase detected.'));
                 }
-            }))().catch((e) => {
-                // analyzeCodebase failed 
-                logger_1.logger.error(outcomeMessage('FATAL: execution failed!'));
-                logger_1.logger.error(e.message);
-                logger_1.logger.error(`\n${prettyjson_1.default.render(JSON.parse(e.message))}`);
-                setTimeout(() => process.exit(1), 1000);
-            });
+            }
         }
-    }
-    catch (e) {
-        yield (0, telemetry_1.sendTelemetry)({
-            eventType: 'execution failure',
-            metadata: {
-                archetype: cli_1.options.archetype,
-                repoPath: cli_1.options.dir,
-                options: cli_1.options,
-                errorMessage: e.message
-            },
-            timestamp: new Date().toISOString()
-        }, executionLogPrefix);
-        logger_1.logger.error(JSON.stringify(e));
-        setTimeout(() => process.exit(1), 1000);
-    }
-}))();
+        catch (e) {
+            yield handleError(e);
+        }
+    });
+}
+if (require.main === module) {
+    main();
+}