x-fidelity 2.2.0 → 2.3.0

package/CHANGELOG.md

@@ -1,3 +1,49 @@
+# [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,9 +32,9 @@ 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);
@@ -47,7 +46,7 @@ function setupEngine(params) {
         });
         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/server/cacheManager.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCachedData = getCachedData;
+exports.setCachedData = setCachedData;
+exports.clearCache = clearCache;
+exports.getCacheContent = getCacheContent;
+exports.setRuleListCache = setRuleListCache;
+exports.getRuleListCache = getRuleListCache;
+exports.handleConfigChange = handleConfigChange;
+const configManager_1 = require("../utils/configManager");
+const logger_1 = require("../utils/logger");
+// Simple in-memory cache
+const cache = {};
+const DEFAULT_TTL = 10 * 60 * 1000; // 10 minutes in milliseconds
+// Cache for archetype lists and rule lists
+const ruleListCache = {};
+function getCachedData(key) {
+    logger_1.logger.debug(`checking cache for key: ${key}`);
+    const item = cache[key];
+    if (item && item.expiry > Date.now()) {
+        return item.data;
+    }
+    return null;
+}
+function setCachedData(key, data, ttl = DEFAULT_TTL) {
+    logger_1.logger.debug(`setting cache for key: ${key}`);
+    cache[key] = {
+        data,
+        expiry: Date.now() + ttl
+    };
+    logger_1.logger.debug(JSON.stringify(cache));
+}
+function clearCache() {
+    logger_1.logger.debug('Clearing cache');
+    Object.keys(cache).forEach((key) => {
+        delete cache[key];
+    });
+    Object.keys(ruleListCache).forEach((key) => {
+        delete ruleListCache[key];
+    });
+}
+function getCacheContent() {
+    return {
+        cache: cache,
+        ruleListCache: ruleListCache
+    };
+}
+function setRuleListCache(archetype, data, ttl = DEFAULT_TTL) {
+    ruleListCache[archetype] = {
+        data: data,
+        expiry: Date.now() + ttl
+    };
+}
+function getRuleListCache(archetype) {
+    const item = ruleListCache[archetype];
+    if (item && item.expiry > Date.now()) {
+        return item.data;
+    }
+    return null;
+}
+function handleConfigChange(path, fileType, changeType) {
+    logger_1.logger.info(`${fileType} ${path} has been ${changeType}`);
+    clearCache();
+    configManager_1.ConfigManager.clearLoadedConfigs();
+    logger_1.logger.debug('Cache and loaded configs cleared due to local config change');
+}