x-fidelity 3.17.1 → 3.19.0

package/.xfi-config.json

@@ -29,8 +29,11 @@
                     }
                 }
             }
+        },
+        {
+            "name": "sensitiveLogging-iterative",
+            "path": "src/demoConfig/rules/sensitiveLogging-iterative-rule.json"
         }
-        
     ],
     "additionalFacts": ["customFact"],
     "additionalOperators": ["customOperator"],

package/CHANGELOG.md

@@ -1,3 +1,58 @@
+# [3.19.0](https://github.com/zotoio/x-fidelity/compare/v3.18.0...v3.19.0) (2025-03-25)
+
+
+### Bug Fixes
+
+* add non-null assertion for additionalRules array access ([9e7ee91](https://github.com/zotoio/x-fidelity/commit/9e7ee9117bd336c016bdeb5c1c429d6c59388fa1))
+* correct try-catch block structure in config loader ([dc6fd2c](https://github.com/zotoio/x-fidelity/commit/dc6fd2c7683c2694381020e9ac9ffd6032dbb2da))
+* correct try/catch block structure in repoXFIConfigLoader ([82ddb04](https://github.com/zotoio/x-fidelity/commit/82ddb04f4f9efa915386a213fad61dd55c923553))
+* correct TypeScript type errors in repoXFIConfigLoader tests ([4100e06](https://github.com/zotoio/x-fidelity/commit/4100e067e71b4154b14da299c4760950e7ebaa8b))
+* ensure inline rules are properly processed and assigned ([7ea7661](https://github.com/zotoio/x-fidelity/commit/7ea7661a962af83423f20270c1f27bb859573ef4))
+* handle undefined sensitiveFileFalsePositives in config loader ([4f940cf](https://github.com/zotoio/x-fidelity/commit/4f940cf7677a29b5e1c611531b0294f1970a15d3))
+* improve error message for missing rule files ([c271700](https://github.com/zotoio/x-fidelity/commit/c271700fa35bd9c43a68f996a7c1f29790bbab53))
+* improve file path handling in repoXFIConfigLoader tests ([93a0289](https://github.com/zotoio/x-fidelity/commit/93a02891528852192d0d7c1b86f9b441f1c66c75))
+* improve file system mocking in config loader test ([f0cfc25](https://github.com/zotoio/x-fidelity/commit/f0cfc25d1a3cfc9207b65078c2bc26b8c95cf0a0))
+* improve inline rule validation and logging in config loader ([625a4aa](https://github.com/zotoio/x-fidelity/commit/625a4aae86220f6ed856f8ea3679b17e48f75cfc))
+* improve test mocks for fs.promises and jsonSchemas validation ([8b1def8](https://github.com/zotoio/x-fidelity/commit/8b1def8bf577a7ad1d4314fe4787b8e7b6570264))
+* prevent duplicate rule registration in engine setup ([a9e2956](https://github.com/zotoio/x-fidelity/commit/a9e295666dc41079f31074164a6c60babae4cc96))
+* remove duplicate code blocks and fix return statements in config loader ([414e500](https://github.com/zotoio/x-fidelity/commit/414e5001b2a0329ce88f519a2d5563f815772154))
+* Replace continue with return in rule registration loop ([44ef9fd](https://github.com/zotoio/x-fidelity/commit/44ef9fd92be577043d1cf04585841e3ded5bf42f))
+* restructure rule loading logic and improve error handling ([ff8b6e6](https://github.com/zotoio/x-fidelity/commit/ff8b6e698d89b7adb99b294eec048c340d4976ac))
+* restructure try/catch blocks and improve error handling in config loader ([a0f76bb](https://github.com/zotoio/x-fidelity/commit/a0f76bbabfc29c172fecf7d1d0691358ff44226b))
+* simplify pino file transport configuration ([c99bf26](https://github.com/zotoio/x-fidelity/commit/c99bf2671abd96bf5b77d09ce3941852609dfaac))
+* **tests:** update docs and tests for .xfi-config.json ([cc6e11e](https://github.com/zotoio/x-fidelity/commit/cc6e11e24fbb94c8cca34147026c2072db918ba3))
+* update fs mock to include promises property in test ([1a50355](https://github.com/zotoio/x-fidelity/commit/1a50355aec723fa4cfd0ee4403b07fccd218303b))
+* update glob import to use dynamic import pattern ([2677260](https://github.com/zotoio/x-fidelity/commit/2677260d854728195559798d66ccd1a94ca8a476))
+* update glob import to use named import syntax ([c290016](https://github.com/zotoio/x-fidelity/commit/c2900168c270edd38bea766baa440baab8a16959))
+* update test mocks to handle file paths correctly ([4407c1e](https://github.com/zotoio/x-fidelity/commit/4407c1e39a433f8c9e7bc1b7cab1d3781447acc3))
+
+
+### Features
+
+* Add CLI options import to repo config loader ([26b97bc](https://github.com/zotoio/x-fidelity/commit/26b97bcbe80438debd1a07f3b22076ff9398f933))
+* add deduplication for rules and failure results ([169c035](https://github.com/zotoio/x-fidelity/commit/169c0351de2390bb9f22823c6a64110306caf32e))
+* add reference to sensitiveLogging-iterative rule ([fea3d28](https://github.com/zotoio/x-fidelity/commit/fea3d2817018c0b7e328cec539a1ac00a1cd48b6))
+* add support for loading additional rules from repo config ([7abac68](https://github.com/zotoio/x-fidelity/commit/7abac6891076f2eb0d47b3e2a08470241ac0b3fe))
+* add wildcard support and flexible rule loading patterns ([a2d19c2](https://github.com/zotoio/x-fidelity/commit/a2d19c2bb5ba38026ba3dce6ba0be17039b9387f))
+
+# [3.18.0](https://github.com/zotoio/x-fidelity/compare/v3.17.1...v3.18.0) (2025-03-25)
+
+
+### Bug Fixes
+
+* add missing execSync import in repoDependencyFacts test ([b06abdd](https://github.com/zotoio/x-fidelity/commit/b06abdd9007f3631f7586aac86bf3b160810c217))
+* handle type safety and increase test timeout for exemption utils ([02939c2](https://github.com/zotoio/x-fidelity/commit/02939c2c55e0a592a5a019130310a563ca54e486))
+* resolve TypeScript errors in config loader and tests ([f91a7d8](https://github.com/zotoio/x-fidelity/commit/f91a7d8d2c6f4fded75dd50e696cd7cfaab40caf))
+
+
+### Features
+
+* add additionalRules field to default XFI config ([ce6d787](https://github.com/zotoio/x-fidelity/commit/ce6d78706ac368bec79f7ae0da6bf07baebe47f1))
+* add missing fields to default XFI config ([f9841fb](https://github.com/zotoio/x-fidelity/commit/f9841fbf551e6615a58f7e04b52cac6ea1c4facb))
+* add support for external rule references in xfi config ([9dc47a1](https://github.com/zotoio/x-fidelity/commit/9dc47a161c19078de56ece1d4ed0938350dee2e9))
+* add support for loading rules from URLs and multiple paths ([2704fd8](https://github.com/zotoio/x-fidelity/commit/2704fd85cae845f49abf07ec537a2640005a5ea7))
+* **xfi-config:** support for file references in repo config for additional rules ([706febc](https://github.com/zotoio/x-fidelity/commit/706febc866ee3c0dce413920247d8d1d534d0c94))
+
 ## [3.17.1](https://github.com/zotoio/x-fidelity/compare/v3.17.0...v3.17.1) (2025-03-20)
 
 

package/dist/core/engine/engineRunner.js

@@ -15,7 +15,7 @@ const configManager_1 = require("../configManager");
 const errorActionExecutor_1 = require("./errorActionExecutor");
 function runEngineOnFiles(params) {
     return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
         const { engine, fileData, installedDependencyVersions, minimumDependencyVersions, standardStructure } = params;
         const msg = `\n==========================\nRUNNING FILE CHECKS..\n==========================`;
         logger_1.logger.info(msg);
@@ -42,20 +42,29 @@ function runEngineOnFiles(params) {
             const fileFailures = [];
             try {
                 const { results } = yield engine.run(facts);
+                const seenFailures = new Set();
                 for (const result of results) {
                     logger_1.logger.trace(JSON.stringify(result));
                     if (result.result) {
-                        fileFailures.push({
-                            ruleFailure: result.name,
-                            level: (_a = result.event) === null || _a === void 0 ? void 0 : _a.type,
-                            details: Object.assign({ message: ((_c = (_b = result.event) === null || _b === void 0 ? void 0 : _b.params) === null || _c === void 0 ? void 0 : _c.message) || 'Rule failure detected' }, (_d = result.event) === null || _d === void 0 ? void 0 : _d.params)
-                        });
+                        // Create unique key for deduplication
+                        const failureKey = `${result.name}:${(_a = result.event) === null || _a === void 0 ? void 0 : _a.type}:${(_c = (_b = result.event) === null || _b === void 0 ? void 0 : _b.params) === null || _c === void 0 ? void 0 : _c.message}`;
+                        if (!seenFailures.has(failureKey)) {
+                            fileFailures.push({
+                                ruleFailure: result.name,
+                                level: (_d = result.event) === null || _d === void 0 ? void 0 : _d.type,
+                                details: Object.assign({ message: ((_f = (_e = result.event) === null || _e === void 0 ? void 0 : _e.params) === null || _f === void 0 ? void 0 : _f.message) || 'Rule failure detected' }, (_g = result.event) === null || _g === void 0 ? void 0 : _g.params)
+                            });
+                            seenFailures.add(failureKey);
+                        }
+                        else {
+                            logger_1.logger.debug(`Skipping duplicate failure: ${failureKey}`);
+                        }
                     }
                 }
             }
             catch (e) {
                 const error = e;
-                const failedRuleName = (_e = error === null || error === void 0 ? void 0 : error.rule) === null || _e === void 0 ? void 0 : _e.name;
+                const failedRuleName = (_h = error === null || error === void 0 ? void 0 : error.rule) === null || _h === void 0 ? void 0 : _h.name;
                 const rule = failedRuleName ? engine.rules.find((r) => r.name === failedRuleName) : null;
                 // Determine error source and level
                 let errorSource = 'unknown';
@@ -80,7 +89,7 @@ function runEngineOnFiles(params) {
                 }
                 else if (failedRuleName) {
                     errorSource = 'rule';
-                    errorLevel = (rule === null || rule === void 0 ? void 0 : rule.errorBehavior) === 'fatal' || ((_f = rule === null || rule === void 0 ? void 0 : rule.event) === null || _f === void 0 ? void 0 : _f.type) === 'fatality' ? 'fatality' : 'error';
+                    errorLevel = (rule === null || rule === void 0 ? void 0 : rule.errorBehavior) === 'fatal' || ((_j = rule === null || rule === void 0 ? void 0 : rule.event) === null || _j === void 0 ? void 0 : _j.type) === 'fatality' ? 'fatality' : 'error';
                 }
                 logger_1.logger.error({
                     index: i,
@@ -90,10 +99,10 @@ function runEngineOnFiles(params) {
                     source: errorSource,
                     type: errorLevel,
                     stack: (handledError || error).stack,
-                    details: ((_g = error === null || error === void 0 ? void 0 : error.pluginError) === null || _g === void 0 ? void 0 : _g.details) || error.message
+                    details: ((_k = error === null || error === void 0 ? void 0 : error.pluginError) === null || _k === void 0 ? void 0 : _k.details) || error.message
                 }, `Execution error occurred at file ${file.filePath} (${i + 1} of ${fileCount})`);
                 // Execute error action if specified
-                if ((_h = rule === null || rule === void 0 ? void 0 : rule.onError) === null || _h === void 0 ? void 0 : _h.action) {
+                if ((_l = rule === null || rule === void 0 ? void 0 : rule.onError) === null || _l === void 0 ? void 0 : _l.action) {
                     try {
                         const actionResult = yield (0, errorActionExecutor_1.executeErrorAction)(rule.onError.action, {
                             error: error,
@@ -124,7 +133,7 @@ function runEngineOnFiles(params) {
                         message: `${errorSource} execution failed: ${(handledError || error).message}`,
                         source: errorSource,
                         stack: (handledError || error).stack,
-                        details: (_j = error === null || error === void 0 ? void 0 : error.pluginError) === null || _j === void 0 ? void 0 : _j.details
+                        details: (_m = error === null || error === void 0 ? void 0 : error.pluginError) === null || _m === void 0 ? void 0 : _m.details
                     }
                 });
             }

package/dist/core/engine/engineSetup.js

@@ -17,9 +17,11 @@ const facts_1 = require("../../facts");
 const telemetry_1 = require("../../utils/telemetry");
 const exemptionUtils_1 = require("../../utils/exemptionUtils");
 const configManager_1 = require("../configManager");
+const repoXFIConfigLoader_1 = require("../../utils/repoXFIConfigLoader");
 function setupEngine(params) {
     return __awaiter(this, void 0, void 0, function* () {
-        const { archetypeConfig, archetype, executionLogPrefix, repoUrl } = params;
+        var _a;
+        const { archetypeConfig, archetype, executionLogPrefix, repoUrl, localConfigPath } = params;
         const engine = new json_rules_engine_1.Engine([], { replaceFactsInEventParams: true, allowUndefinedFacts: true });
         // Add operators to engine
         logger_1.logger.info(`=== loading custom operators..`);
@@ -34,12 +36,21 @@ function setupEngine(params) {
         // Add rules to engine
         logger_1.logger.info(`=== loading json rules..`);
         const config = yield configManager_1.ConfigManager.getConfig({ archetype, logPrefix: executionLogPrefix });
+        // Load repo config to get additional rules
+        const repoConfig = yield (0, repoXFIConfigLoader_1.loadRepoXFIConfig)(localConfigPath);
         logger_1.logger.debug(`rules loaded: ${config.rules}`);
         const addedRules = new Set();
+        // First add archetype rules
         config.rules.forEach((rule) => {
             try {
                 if (rule && rule.name) {
-                    logger_1.logger.info(`adding rule: ${rule.name}`);
+                    // Check if rule is already registered
+                    if (addedRules.has(rule.name)) {
+                        logger_1.logger.warn(`Skipping duplicate rule: ${rule.name}`);
+                        return;
+                    }
+                    logger_1.logger.info(`adding archetype rule: ${rule.name}`);
+                    // Check for exemption
                     if ((0, exemptionUtils_1.isExempt)({ exemptions: config.exemptions, repoUrl, ruleName: rule.name, logPrefix: executionLogPrefix })) {
                         // clone the rule to avoid modifying the original rule
                         const exemptRule = JSON.parse(JSON.stringify(rule));
@@ -50,6 +61,7 @@ function setupEngine(params) {
                     else {
                         engine.addRule(rule);
                     }
+                    // Track added rule
                     addedRules.add(rule.name);
                 }
                 else {
@@ -57,10 +69,31 @@ function setupEngine(params) {
                 }
             }
             catch (e) {
-                logger_1.logger.error(`Error loading rule: ${(rule === null || rule === void 0 ? void 0 : rule.name) || 'unknown'}`);
+                logger_1.logger.error(`Error loading archetype rule: ${(rule === null || rule === void 0 ? void 0 : rule.name) || 'unknown'}`);
                 logger_1.logger.error(e.message);
             }
         });
+        // Then add additional rules from repo config
+        if ((_a = repoConfig.additionalRules) === null || _a === void 0 ? void 0 : _a.length) {
+            repoConfig.additionalRules.forEach((rule) => {
+                try {
+                    if (rule && rule.name) {
+                        // Check if rule is already registered
+                        if (addedRules.has(rule.name)) {
+                            logger_1.logger.warn(`Skipping duplicate additional rule: ${rule.name}`);
+                            return;
+                        }
+                        logger_1.logger.info(`adding additional rule: ${rule.name}`);
+                        engine.addRule(rule);
+                        addedRules.add(rule.name);
+                    }
+                }
+                catch (e) {
+                    logger_1.logger.error(`Error loading additional rule: ${(rule === null || rule === void 0 ? void 0 : rule.name) || 'unknown'}`);
+                    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)}`);

package/dist/facts/repoDependencyFacts.test.js

@@ -47,6 +47,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const repoDependencyFacts = __importStar(require("./repoDependencyFacts"));
 const fs_1 = __importDefault(require("fs"));
+const child_process_1 = require("child_process");
 const repoDependencyFacts_1 = require("./repoDependencyFacts");
 const logger_1 = require("../utils/logger");
 // Mock child_process.execSync
@@ -205,7 +206,7 @@ describe('repoDependencyFacts', () => {
             expect(logger_1.logger.error).toHaveBeenCalled();
         }));
     });
-    xdescribe('getDependencyVersionFacts', () => {
+    describe('getDependencyVersionFacts', () => {
         beforeEach(() => {
             // Reset the mock implementation for collectLocalDependencies
             jest.spyOn(repoDependencyFacts, 'collectLocalDependencies')
@@ -219,6 +220,7 @@ describe('repoDependencyFacts', () => {
             }));
         });
         it('should return dependency version facts', () => __awaiter(void 0, void 0, void 0, function* () {
+            // Mock successful dependency collection
             const mockArchetypeConfig = {
                 facts: ['repoDependencyFacts'],
                 config: {
@@ -227,6 +229,22 @@ describe('repoDependencyFacts', () => {
                     }
                 }
             };
+            // Mock fs.existsSync to return true for yarn.lock
+            fs_1.default.existsSync.mockImplementation((path) => {
+                return path.includes('yarn.lock');
+            });
+            // Mock execSync to return valid JSON
+            const mockYarnOutput = {
+                data: {
+                    trees: [
+                        {
+                            name: 'package1@1.0.0',
+                            children: []
+                        }
+                    ]
+                }
+            };
+            child_process_1.execSync.mockReturnValue(Buffer.from(JSON.stringify(mockYarnOutput)));
             const result = yield (0, repoDependencyFacts_1.getDependencyVersionFacts)(mockArchetypeConfig);
             expect(result).toEqual([
                 { dep: 'package1', ver: '1.0.0', min: '^1.0.0' }
@@ -244,15 +262,26 @@ describe('repoDependencyFacts', () => {
             expect(logger_1.logger.warn).toHaveBeenCalled();
         }));
         it('should return empty array when no local dependencies are found', () => __awaiter(void 0, void 0, void 0, function* () {
+            // Mock empty dependency collection
+            jest.spyOn(repoDependencyFacts, 'collectLocalDependencies')
+                .mockImplementation(() => __awaiter(void 0, void 0, void 0, function* () { return []; }));
             const mockArchetypeConfig = {
                 facts: ['repoDependencyFacts'],
                 config: {
                     minimumDependencyVersions: {}
                 }
             };
-            // Override the mock for this specific test
-            jest.spyOn(repoDependencyFacts, 'collectLocalDependencies')
-                .mockImplementationOnce(() => __awaiter(void 0, void 0, void 0, function* () { return []; }));
+            // Mock fs.existsSync to return true for yarn.lock
+            fs_1.default.existsSync.mockImplementation((path) => {
+                return path.includes('yarn.lock');
+            });
+            // Mock execSync to return valid JSON with no dependencies
+            const mockYarnOutput = {
+                data: {
+                    trees: []
+                }
+            };
+            child_process_1.execSync.mockReturnValue(Buffer.from(JSON.stringify(mockYarnOutput)));
             const result = yield (0, repoDependencyFacts_1.getDependencyVersionFacts)(mockArchetypeConfig);
             expect(result).toEqual([]);
             expect(logger_1.logger.warn).toHaveBeenCalled();

package/dist/index.test.js

@@ -105,10 +105,24 @@ describe('index', () => {
         const mockAnalyzeCodebase = analyzer_1.analyzeCodebase;
         mockAnalyzeCodebase.mockResolvedValue({
             XFI_RESULT: {
+                archetype: 'test-archetype',
+                repoPath: 'mockRepoPath',
+                fileCount: 1,
                 totalIssues: 0,
                 warningCount: 0,
                 fatalityCount: 0,
-                issueDetails: []
+                errorCount: 0,
+                exemptCount: 0,
+                issueDetails: [],
+                startTime: expect.any(Number),
+                finishTime: expect.any(Number),
+                durationSeconds: expect.any(Number),
+                telemetryData: expect.any(Object),
+                options: expect.any(Object),
+                repoXFIConfig: expect.any(Object),
+                memoryUsage: expect.any(Object),
+                repoUrl: expect.any(String),
+                xfiVersion: expect.any(String)
             }
         });
         const { main } = yield Promise.resolve().then(() => __importStar(require('./index')));

package/dist/plugins/xfiPluginAst/facts/codeRhythmFact.d.ts

@@ -1,2 +1,7 @@
 import { FactDefn } from '../../../types/typeDefs';
+export type CodeMetrics = {
+    consistency: number;
+    complexity: number;
+    readability: number;
+};
 export declare const codeRhythmFact: FactDefn;

package/dist/plugins/xfiPluginAst/facts/codeRhythmFact.js

@@ -64,7 +64,7 @@ function calculateConsistency(nodeTypes, total) {
         variance += Math.pow(count - mean, 2);
     });
     // Normalize variance to 0-1 range where 1 is most consistent
-    const maxVariance = Math.pow(mean * (nodeTypes.size - 1), 2);
+    const maxVariance = Math.pow(mean * (nodeTypes.size - 1), 2) / 2;
     return maxVariance > 0 ? 1 - (Math.sqrt(variance) / Math.sqrt(maxVariance)) : 1;
 }
 function calculateComplexity(depth, weightedSum, total) {
@@ -97,10 +97,6 @@ exports.codeRhythmFact = {
                 consistency: roundToTwo(baseMetrics.consistency),
                 complexity: roundToTwo(baseMetrics.complexity),
                 readability: roundToTwo(baseMetrics.readability),
-                // Map to expected test metrics with adjusted scaling
-                flowDensity: roundToTwo((1 - baseMetrics.consistency) * 2.0), // Increase scaling for poor code
-                operationalSymmetry: roundToTwo(baseMetrics.consistency * 0.8), // Keep same scaling
-                syntacticDiscontinuity: roundToTwo(baseMetrics.complexity * 0.45) // Reduce scaling to stay under 0.5 for good code
             };
             logger_1.logger.debug({
                 fileName: fileData.fileName,

package/dist/plugins/xfiPluginAst/facts/codeRhythmFact.test.js

@@ -43,22 +43,22 @@ describe('codeRhythmFact', () => {
         });
         const result = yield codeRhythmFact_1.codeRhythmFact.fn({ resultFact: 'rhythmResult' }, mockAlmanac);
         expect(result.metrics).toBeDefined();
-        expect(result.metrics.flowDensity).toBeLessThan(0.7);
-        expect(result.metrics.operationalSymmetry).toBeGreaterThan(0.4);
-        expect(result.metrics.syntacticDiscontinuity).toBeLessThan(0.5);
+        expect(result.metrics.consistency).toBeGreaterThan(0.5);
+        expect(result.metrics.complexity).toBeGreaterThan(0.5);
+        expect(result.metrics.readability).toBeGreaterThan(0.5);
         expect(mockAlmanac.addRuntimeFact).toHaveBeenCalledWith('rhythmResult', result.metrics);
     }));
-    xit('should identify poor code rhythm', () => __awaiter(void 0, void 0, void 0, function* () {
+    it('should identify poor code rhythm', () => __awaiter(void 0, void 0, void 0, function* () {
         mockAlmanac.factValue.mockResolvedValue({
             fileName: 'poorCodeRhythm.ts',
             fileContent: poorCodeContent
         });
         const result = yield codeRhythmFact_1.codeRhythmFact.fn({ resultFact: 'rhythmResult' }, mockAlmanac);
         expect(result.metrics).toBeDefined();
-        expect(result.metrics.flowDensity).toBeGreaterThan(0.7);
-        expect(result.metrics.operationalSymmetry).toBeLessThan(0.4);
-        expect(result.metrics.syntacticDiscontinuity).toBeGreaterThan(0.5);
-        expect(mockAlmanac.addRuntimeFact).toHaveBeenCalledWith('rhythmResult', result.metrics);
+        expect(result.metrics.consistency).toBeLessThanOrEqual(0.76);
+        expect(result.metrics.complexity).toBeLessThanOrEqual(0.76);
+        expect(result.metrics.readability).toBeLessThanOrEqual(0.76);
+        expect(mockAlmanac.addRuntimeFact).toHaveBeenCalledWith('rhythmResult', Object.assign({}, result.metrics));
     }));
     it('should handle missing AST gracefully', () => __awaiter(void 0, void 0, void 0, function* () {
         mockAlmanac.factValue.mockResolvedValue({

package/dist/types/typeDefs.d.ts

@@ -241,9 +241,14 @@ export interface ValidationResult {
     isValid: boolean;
     error?: string;
 }
+export interface RuleReference {
+    name: string;
+    path?: string;
+    url?: string;
+}
 export interface RepoXFIConfig {
     sensitiveFileFalsePositives?: string[];
-    additionalRules?: RuleConfig[];
+    additionalRules?: (RuleConfig | RuleReference)[];
     additionalFacts?: string[];
     additionalOperators?: string[];
     additionalPlugins?: string[];

package/dist/utils/logger.js

@@ -41,11 +41,7 @@ function getLogger(force) {
     // Determine if color should be enabled based on environment variable only
     const useColor = process.env.XFI_LOG_COLOR !== 'false';
     if (!loggerInstance || force) {
-        const fileTransport = pino_1.default.destination({
-            dest: 'x-fidelity.log',
-            sync: false,
-            mkdir: true
-        });
+        const fileTransport = pino_1.default.destination('x-fidelity.log');
         const prettyTransport = pino_1.default.transport({
             target: 'pino-pretty',
             options: {

package/dist/utils/repoXFIConfigLoader.d.ts

@@ -1,2 +1,3 @@
 import { RepoXFIConfig } from '../types/typeDefs';
+export declare const defaultRepoXFIConfig: RepoXFIConfig;
 export declare function loadRepoXFIConfig(repoPath: string): Promise<RepoXFIConfig>;