x-fidelity 3.21.0 → 3.22.0

package/CHANGELOG.md

@@ -1,3 +1,39 @@
+# [3.22.0](https://github.com/zotoio/x-fidelity/compare/v3.21.1...v3.22.0) (2025-04-02)
+
+
+### Bug Fixes
+
+* access operatorThreshold and operatorValue through details property ([e427e94](https://github.com/zotoio/x-fidelity/commit/e427e942aa0072483e02c62fb6e8af967b6a76cc))
+* add missing logger function mocks in test files ([713a1e9](https://github.com/zotoio/x-fidelity/commit/713a1e969142272f4f9e835ede0853c8e92d1620))
+* add ruleName property to BasicTelemetryMetadata interface ([0c66b78](https://github.com/zotoio/x-fidelity/commit/0c66b787986018250f77f727425dfe012400c2e9))
+* add type assertions for conditionType in engineSetup ([734d492](https://github.com/zotoio/x-fidelity/commit/734d492b09e76531c42d712ff0e70a4150761b55))
+* resolve TypeScript type errors and null safety issues ([bfb892d](https://github.com/zotoio/x-fidelity/commit/bfb892d637519f3d4d7b768067e4f478ad74971a))
+
+
+### Features
+
+* add all condition operators to rule failure details ([023f44f](https://github.com/zotoio/x-fidelity/commit/023f44fffdd82011fc00ea9ae2dabd2ba380e5f7))
+* add all operator value objects to rule results ([c8103c5](https://github.com/zotoio/x-fidelity/commit/c8103c55f60f9da2453305980fe305c57341f961))
+* add backward compatibility for pattern and file output grouping ([db22b70](https://github.com/zotoio/x-fidelity/commit/db22b7084532ddf3edac2b16e7fe30761b15d5d4))
+* add condition details to rule failure output ([168aeec](https://github.com/zotoio/x-fidelity/commit/168aeec2741a22e6706d309b93e361946024a14a))
+* add operator threshold details to rule output and telemetry ([c28974a](https://github.com/zotoio/x-fidelity/commit/c28974a0d1259a943b5afda3ec3f83424c196b16))
+* add operator threshold details to rule output reports ([0ce279d](https://github.com/zotoio/x-fidelity/commit/0ce279d4e480645ba2636beedec5d2fd17f8dadc))
+* add operator value information to report sections ([697a1a3](https://github.com/zotoio/x-fidelity/commit/697a1a36dbb0b6de19b1c5b3be7ca308f757cbbe))
+* add operator value to rule failure details ([ae62f56](https://github.com/zotoio/x-fidelity/commit/ae62f561583209bc8496ff0cd07be597b04909d9))
+* add rule name to log prefix for better traceability ([6a4c4b6](https://github.com/zotoio/x-fidelity/commit/6a4c4b6880c9dfa06bad56a024b3065db771dcdd))
+* enhance rule condition details with descriptions and recommendations ([8eef433](https://github.com/zotoio/x-fidelity/commit/8eef43370c800b5dcb3e9150c858ed7e848abc58))
+* enhance rule condition tracking with detailed condition info ([4e48e7c](https://github.com/zotoio/x-fidelity/commit/4e48e7c63843aef98a6ccbf73cc1252c0e48608c))
+* enhance rule failure reporting with detailed condition information ([915ae09](https://github.com/zotoio/x-fidelity/commit/915ae09a0b3f539d7e48effd3abe26e16d28dee5))
+* enhance XFI_RESULT with detailed rule conditions and recommendations ([7243da5](https://github.com/zotoio/x-fidelity/commit/7243da538f1c37abae2806bc405ec6c251184bb5))
+* include all rule conditions and parameters in output ([ae802bb](https://github.com/zotoio/x-fidelity/commit/ae802bbb41a0613835e4d3e6e477c66abcd8e1ac))
+
+## [3.21.1](https://github.com/zotoio/x-fidelity/compare/v3.21.0...v3.21.1) (2025-04-02)
+
+
+### Bug Fixes
+
+* **tests:** logic issue ([1578b81](https://github.com/zotoio/x-fidelity/commit/1578b817ff58912a312e32f5480b2b5f655a1014))
+
 # [3.21.0](https://github.com/zotoio/x-fidelity/compare/v3.20.0...v3.21.0) (2025-04-02)
 
 

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, _k, _l, _m;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
         const { engine, fileData, installedDependencyVersions, minimumDependencyVersions, standardStructure } = params;
         const msg = `\n==========================\nRUNNING FILE CHECKS..\n==========================`;
         logger_1.logger.info(msg);
@@ -41,6 +41,8 @@ function runEngineOnFiles(params) {
             };
             const fileFailures = [];
             try {
+                // Save the original log prefix
+                const originalLogPrefix = (0, logger_1.getLogPrefix)();
                 const { results } = yield engine.run(facts);
                 const seenFailures = new Set();
                 for (const result of results) {
@@ -49,11 +51,66 @@ function runEngineOnFiles(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)) {
+                            // Set the rule name as log prefix for this failure
+                            const ruleName = result.name || 'unknown-rule';
+                            (0, logger_1.setLogPrefix)(`${originalLogPrefix}:${ruleName}`);
+                            // Extract condition details from the rule
+                            let conditionDetails = undefined;
+                            let ruleDescription = null;
+                            let recommendations = null;
+                            let allConditions = [];
+                            let conditionType = 'unknown';
+                            try {
+                                // Find the condition that triggered this rule
+                                const rule = engine.rules.find((r) => r.name === result.name);
+                                if (rule) {
+                                    // Extract rule description if available
+                                    ruleDescription = rule.description || 'No description available';
+                                    // Extract recommendations if available
+                                    if ((_e = (_d = result.event) === null || _d === void 0 ? void 0 : _d.params) === null || _e === void 0 ? void 0 : _e.recommendations) {
+                                        recommendations = result.event.params.recommendations;
+                                    }
+                                    else if (rule.recommendations) {
+                                        recommendations = rule.recommendations;
+                                    }
+                                    // Extract operator value from the condition
+                                    const conditions = rule.conditions.all || rule.conditions.any || [];
+                                    conditionType = rule.conditions.all ? 'all' : 'any';
+                                    // Capture all conditions with their parameters
+                                    allConditions = conditions.map((condition) => ({
+                                        fact: condition.fact,
+                                        operator: condition.operator,
+                                        value: condition.value,
+                                        params: condition.params,
+                                        path: condition.path,
+                                        priority: condition.priority
+                                    }));
+                                    // Find the first condition with operator and value for backward compatibility
+                                    for (const condition of conditions) {
+                                        if (condition.operator && condition.value !== undefined) {
+                                            conditionDetails = {
+                                                fact: condition.fact,
+                                                operator: condition.operator,
+                                                value: condition.value,
+                                                params: condition.params
+                                            };
+                                            break;
+                                        }
+                                    }
+                                }
+                            }
+                            catch (err) {
+                                logger_1.logger.debug(`Error extracting operator value: ${err}`);
+                            }
                             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)
+                                level: (_f = result.event) === null || _f === void 0 ? void 0 : _f.type,
+                                details: Object.assign({ message: ((_h = (_g = result.event) === null || _g === void 0 ? void 0 : _g.params) === null || _h === void 0 ? void 0 : _h.message) || 'Rule failure detected', conditionDetails: conditionDetails, allConditions: allConditions, conditionType: conditionType, ruleDescription: ruleDescription, recommendations: recommendations }, (_j = result.event) === null || _j === void 0 ? void 0 : _j.params)
                             });
+                            // Restore original log prefix
+                            (0, logger_1.setLogPrefix)(originalLogPrefix);
+                            // Restore original log prefix before continuing
+                            (0, logger_1.setLogPrefix)(originalLogPrefix);
                             seenFailures.add(failureKey);
                         }
                         else {
@@ -64,8 +121,11 @@ function runEngineOnFiles(params) {
             }
             catch (e) {
                 const error = e;
-                const failedRuleName = (_h = error === null || error === void 0 ? void 0 : error.rule) === null || _h === void 0 ? void 0 : _h.name;
+                const failedRuleName = (_k = error === null || error === void 0 ? void 0 : error.rule) === null || _k === void 0 ? void 0 : _k.name;
                 const rule = failedRuleName ? engine.rules.find((r) => r.name === failedRuleName) : null;
+                // Set the rule name as log prefix for this error
+                const originalLogPrefix = (0, logger_1.getLogPrefix)();
+                (0, logger_1.setLogPrefix)(`${originalLogPrefix}:${failedRuleName || 'unknown-rule'}`);
                 // Determine error source and level
                 let errorSource = 'unknown';
                 let errorLevel = 'error';
@@ -89,7 +149,7 @@ function runEngineOnFiles(params) {
                 }
                 else if (failedRuleName) {
                     errorSource = 'rule';
-                    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';
+                    errorLevel = (rule === null || rule === void 0 ? void 0 : rule.errorBehavior) === 'fatal' || ((_l = rule === null || rule === void 0 ? void 0 : rule.event) === null || _l === void 0 ? void 0 : _l.type) === 'fatality' ? 'fatality' : 'error';
                 }
                 logger_1.logger.error({
                     index: i,
@@ -99,10 +159,10 @@ function runEngineOnFiles(params) {
                     source: errorSource,
                     type: errorLevel,
                     stack: (handledError || error).stack,
-                    details: ((_k = error === null || error === void 0 ? void 0 : error.pluginError) === null || _k === void 0 ? void 0 : _k.details) || error.message
+                    details: ((_m = error === null || error === void 0 ? void 0 : error.pluginError) === null || _m === void 0 ? void 0 : _m.details) || error.message
                 }, `Execution error occurred at file ${file.filePath} (${i + 1} of ${fileCount})`);
                 // Execute error action if specified
-                if ((_l = rule === null || rule === void 0 ? void 0 : rule.onError) === null || _l === void 0 ? void 0 : _l.action) {
+                if ((_o = rule === null || rule === void 0 ? void 0 : rule.onError) === null || _o === void 0 ? void 0 : _o.action) {
                     try {
                         const actionResult = yield (0, errorActionExecutor_1.executeErrorAction)(rule.onError.action, {
                             error: error,
@@ -133,9 +193,17 @@ function runEngineOnFiles(params) {
                         message: `${errorSource} execution failed: ${(handledError || error).message}`,
                         source: errorSource,
                         stack: (handledError || error).stack,
-                        details: (_m = error === null || error === void 0 ? void 0 : error.pluginError) === null || _m === void 0 ? void 0 : _m.details
+                        details: (_p = error === null || error === void 0 ? void 0 : error.pluginError) === null || _p === void 0 ? void 0 : _p.details,
+                        // Include rule information if available
+                        rule: rule ? {
+                            name: rule.name,
+                            conditions: rule.conditions,
+                            event: rule.event
+                        } : undefined
                     }
                 });
+                // Restore original log prefix before returning
+                (0, logger_1.setLogPrefix)(originalLogPrefix);
             }
             if (fileFailures.length > 0) {
                 failures.push({ filePath: file.filePath, errors: fileFailures });

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

@@ -21,6 +21,8 @@ jest.mock('../../utils/logger', () => ({
         warn: jest.fn(),
         trace: jest.fn()
     },
+    getLogPrefix: jest.fn().mockReturnValue('test-prefix'),
+    setLogPrefix: jest.fn(),
 }));
 describe('runEngineOnFiles', () => {
     let mockEngine;

package/dist/core/engine/engineSetup.js

@@ -94,12 +94,53 @@ function setupEngine(params) {
                 }
             });
         }
-        engine.on('success', (_a) => __awaiter(this, [_a], void 0, function* ({ type, params }) {
+        engine.on('success', (_a) => __awaiter(this, [_a], void 0, function* ({ type, params, name, conditions }) {
+            const originalLogPrefix = (0, logger_1.getLogPrefix)();
+            const ruleName = name || 'unknown-rule';
+            (0, logger_1.setLogPrefix)(`${originalLogPrefix}:${ruleName}`);
+            // Extract condition details from conditions
+            let conditionDetails = undefined;
+            let allConditions = [];
+            let conditionType = 'unknown';
+            try {
+                const rule = engine.rules.find((r) => r.name === name);
+                if (rule) {
+                    const conditions = rule.conditions.all || rule.conditions.any || [];
+                    conditionType = rule.conditions.all ? 'all' : 'any';
+                    // Capture all conditions with their parameters
+                    allConditions = conditions.map((condition) => ({
+                        fact: condition.fact,
+                        operator: condition.operator,
+                        value: condition.value,
+                        params: condition.params,
+                        path: condition.path,
+                        priority: condition.priority
+                    }));
+                    // Find the first condition with operator and value for backward compatibility
+                    for (const condition of conditions) {
+                        if (condition.operator && condition.value !== undefined) {
+                            conditionDetails = {
+                                fact: condition.fact,
+                                operator: condition.operator,
+                                value: condition.value,
+                                params: condition.params
+                            };
+                            break;
+                        }
+                    }
+                }
+            }
+            catch (err) {
+                logger_1.logger.debug(`Error extracting operator threshold: ${err}`);
+            }
             if (type === 'warning') {
                 logger_1.logger.warn(`warning detected: ${JSON.stringify(params)}`);
                 yield (0, telemetry_1.sendTelemetry)({
                     eventType: 'warning',
-                    metadata: Object.assign({ archetype, repoPath: '' }, params),
+                    metadata: Object.assign({ archetype, repoPath: '', ruleName,
+                        conditionDetails,
+                        allConditions,
+                        conditionType }, params),
                     timestamp: new Date().toISOString()
                 }, executionLogPrefix);
             }
@@ -107,7 +148,10 @@ function setupEngine(params) {
                 logger_1.logger.error(`fatality detected: ${JSON.stringify(params)}`);
                 yield (0, telemetry_1.sendTelemetry)({
                     eventType: 'fatality',
-                    metadata: Object.assign({ archetype, repoPath: '' }, params),
+                    metadata: Object.assign({ archetype, repoPath: '', ruleName,
+                        conditionDetails,
+                        allConditions,
+                        conditionType }, params),
                     timestamp: new Date().toISOString()
                 }, executionLogPrefix);
             }
@@ -115,10 +159,17 @@ function setupEngine(params) {
                 logger_1.logger.error(`exemption detected: ${JSON.stringify(params)}`);
                 yield (0, telemetry_1.sendTelemetry)({
                     eventType: 'exempt',
-                    metadata: Object.assign({ archetype, repoPath: '' }, params),
+                    metadata: Object.assign({ archetype, repoPath: '', ruleName,
+                        conditionDetails,
+                        allConditions,
+                        conditionType }, params),
                     timestamp: new Date().toISOString()
                 }, executionLogPrefix);
             }
+            // Restore original log prefix
+            (0, logger_1.setLogPrefix)(originalLogPrefix);
+            // Restore original log prefix
+            (0, logger_1.setLogPrefix)(originalLogPrefix);
         }));
         // Add facts to engine
         logger_1.logger.info(`=== loading facts..`);

package/dist/core/engine/errorActionExecutor.d.ts

@@ -1,4 +1,4 @@
-interface ErrorActionParams {
+export interface ErrorActionParams {
     error: Error;
     rule: string;
     level: string;
@@ -7,4 +7,3 @@ interface ErrorActionParams {
     file: any;
 }
 export declare function executeErrorAction(actionName: string, params: ErrorActionParams): Promise<any>;
-export {};

package/dist/core/engine/errorActionExecutor.js

@@ -15,23 +15,31 @@ const pluginRegistry_1 = require("../pluginRegistry");
 function executeErrorAction(actionName, params) {
     return __awaiter(this, void 0, void 0, function* () {
         var _a;
-        // First check if it's a plugin action
-        if (actionName.includes(':')) {
-            const [pluginName, functionName] = actionName.split(':');
-            const result = pluginRegistry_1.pluginRegistry.executePluginFunction(pluginName, functionName, params);
-            if (!result.success) {
-                throw new Error(`Plugin error action failed: ${(_a = result.error) === null || _a === void 0 ? void 0 : _a.message}`);
+        const originalLogPrefix = (0, logger_1.getLogPrefix)();
+        (0, logger_1.setLogPrefix)(`${originalLogPrefix}:${params.rule || 'unknown-rule'}`);
+        try {
+            // First check if it's a plugin action
+            if (actionName.includes(':')) {
+                const [pluginName, functionName] = actionName.split(':');
+                const result = pluginRegistry_1.pluginRegistry.executePluginFunction(pluginName, functionName, params);
+                if (!result.success) {
+                    throw new Error(`Plugin error action failed: ${(_a = result.error) === null || _a === void 0 ? void 0 : _a.message}`);
+                }
+                return result.data;
+            }
+            // Otherwise check built-in actions
+            switch (actionName) {
+                case 'sendNotification':
+                    return yield sendNotification(params);
+                case 'logToFile':
+                    return yield logToFile(params);
+                default:
+                    throw new Error(`Unknown error action: ${actionName}`);
             }
-            return result.data;
         }
-        // Otherwise check built-in actions
-        switch (actionName) {
-            case 'sendNotification':
-                return yield sendNotification(params);
-            case 'logToFile':
-                return yield logToFile(params);
-            default:
-                throw new Error(`Unknown error action: ${actionName}`);
+        finally {
+            // Always restore the original log prefix
+            (0, logger_1.setLogPrefix)(originalLogPrefix);
         }
     });
 }

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

@@ -16,6 +16,8 @@ jest.mock('../../utils/logger', () => ({
         info: jest.fn(),
         error: jest.fn(),
     },
+    getLogPrefix: jest.fn().mockReturnValue('test-prefix'),
+    setLogPrefix: jest.fn(),
 }));
 describe('executeErrorAction', () => {
     it('should execute sendNotification action', () => __awaiter(void 0, void 0, void 0, function* () {

package/dist/facts/globalFileAnalysisFacts.js

@@ -125,12 +125,10 @@ exports.globalFileAnalysis = {
                 const patternEntry = result.patternData.find((p) => p.pattern === pattern);
                 return sum + ((patternEntry === null || patternEntry === void 0 ? void 0 : patternEntry.count) || 0);
             }, 0);
-            // Create matchCounts and fileMatches for backward compatibility
+            // Create matchCounts for convenience
             result.matchCounts = {};
-            result.fileMatches = {};
             result.patternData.forEach((entry) => {
                 result.matchCounts[entry.pattern] = entry.count;
-                result.fileMatches[entry.pattern] = entry.files;
             });
             // Add summary to result
             result.summary = {

package/dist/index.js

@@ -151,7 +151,28 @@ function main() {
                     // 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(resultString);
+                        // Create a more detailed summary of issues
+                        const issuesSummary = {
+                            totalIssues: resultMetadata.XFI_RESULT.totalIssues,
+                            warningCount: resultMetadata.XFI_RESULT.warningCount,
+                            fatalityCount: resultMetadata.XFI_RESULT.fatalityCount,
+                            errorCount: resultMetadata.XFI_RESULT.errorCount,
+                            exemptCount: resultMetadata.XFI_RESULT.exemptCount,
+                            topIssues: resultMetadata.XFI_RESULT.issueDetails
+                                .slice(0, 5)
+                                .map(detail => ({
+                                filePath: detail.filePath,
+                                errors: detail.errors.map(err => {
+                                    var _a;
+                                    return ({
+                                        rule: err.ruleFailure,
+                                        level: err.level,
+                                        message: (_a = err.details) === null || _a === void 0 ? void 0 : _a.message
+                                    });
+                                })
+                            }))
+                        };
+                        logger_1.logger.warn(JSON.stringify(issuesSummary, null, 2));
                         if (resultMetadata.XFI_RESULT.errorCount > 0) {
                             logger_1.logger.error(outcomeMessage(`THERE WERE ${resultMetadata.XFI_RESULT.errorCount} UNEXPECTED ERRORS!`));
                             logger_1.logger.error(`\n${prettyResult}\n\n`);

package/dist/notifications/reportGenerator.d.ts

@@ -20,6 +20,10 @@ export declare class XFiReportGenerator {
     private generateDependencyIssuesSection;
     private generateSensitiveDataSection;
     private generateGlobalIssuesSection;
+    /**
+     * Helper method to add operator information to report sections
+     */
+    private addOperatorValueToReport;
     generateReport(): string;
     saveReportToFile(outputPath: string): Promise<void>;
 }

package/dist/notifications/reportGenerator.js

@@ -236,6 +236,14 @@ Based on the OpenAI analysis, these are the top 5 critical issues to address:
 **Suggestion**: ${issue.suggestion}
 
 `;
+                    // Add condition details if available
+                    if (openAiAnalysis.details && openAiAnalysis.details.conditionDetails) {
+                        const { fact, operator, value, params } = openAiAnalysis.details.conditionDetails;
+                        aiAnalysis += `**Condition**: Fact \`${fact}\` with operator \`${operator}\`\n`;
+                        if (params) {
+                            aiAnalysis += `**Parameters**: \`${JSON.stringify(params)}\`\n\n`;
+                        }
+                    }
                 });
             }
         }
@@ -250,7 +258,7 @@ Based on the OpenAI analysis, these are the top 5 critical issues to address:
             filePath: detail.filePath,
             fileName: this.getFileName(detail.filePath),
             fileUrl: this.getGithubUrl(detail.filePath),
-            details: error.details
+            details: error.details,
         })));
         if (complexityIssues.length === 0) {
             return '';
@@ -259,7 +267,17 @@ Based on the OpenAI analysis, these are the top 5 critical issues to address:
 
 The analysis identified several functions with high complexity that should be refactored:
 
-| File | Function | Cyclomatic Complexity | Cognitive Complexity | Nesting Depth | Parameter Count | Return Count |
+`;
+        // Add threshold information if available from the first issue
+        if (complexityIssues[0].details && complexityIssues[0].details.operatorThreshold) {
+            const { operator, value } = complexityIssues[0].details.operatorThreshold;
+            section += `**Threshold**: \`${operator}: ${JSON.stringify(value)}\`\n\n`;
+        }
+        // Add operator value information if available
+        if (complexityIssues[0].details && complexityIssues[0].details.operatorValue) {
+            section += `**Required Value**: \`${JSON.stringify(complexityIssues[0].details.operatorValue)}\`\n\n`;
+        }
+        section += `| File | Function | Cyclomatic Complexity | Cognitive Complexity | Nesting Depth | Parameter Count | Return Count |
 |------|----------|------------------------|----------------------|--------------|----------------|--------------|
 `;
         complexityIssues.forEach(issue => {
@@ -287,7 +305,16 @@ The analysis identified several functions with high complexity that should be re
 
 The analysis detected outdated framework dependencies that need updating:
 
-| Dependency | Current Version | Required Version |
+`;
+        // Add condition details if available
+        if (dependencyIssue.details.conditionDetails) {
+            const { fact, operator, params } = dependencyIssue.details.conditionDetails;
+            section += `**Condition**: Fact \`${fact}\` with operator \`${operator}\`\n`;
+            if (params) {
+                section += `**Parameters**: \`${JSON.stringify(params)}\`\n\n`;
+            }
+        }
+        section += `| Dependency | Current Version | Required Version |
 |------------|-----------------|------------------|
 `;
         dependencies.forEach((dep) => {
@@ -341,9 +368,41 @@ Several files contain potentially sensitive data patterns that shouldn't be logg
 `;
         globalIssues.forEach(issue => {
             section += `- **${issue.ruleFailure}** (${issue.level}): ${issue.details && issue.details.message ? issue.details.message : 'No details available'}\n`;
+            // Add condition details if available
+            if (issue.details && issue.details.conditionDetails) {
+                const { fact, operator, params } = issue.details.conditionDetails;
+                section += `  - Condition: Fact \`${fact}\` with operator \`${operator}\`\n`;
+                if (params) {
+                    section += `  - Parameters: \`${JSON.stringify(params)}\`\n`;
+                }
+            }
         });
         return section;
     }
+    /**
+     * Helper method to add operator information to report sections
+     */
+    addOperatorValueToReport(issueDetails, error) {
+        // Add condition details if available
+        if (error.details.conditionDetails) {
+            const { fact, operator, params } = error.details.conditionDetails;
+            issueDetails += `  - Condition: Fact \`${fact}\` with operator \`${operator}\`\n`;
+            if (params) {
+                issueDetails += `  - Parameters: \`${JSON.stringify(params)}\`\n`;
+            }
+        }
+        // Add all condition operators if available
+        if (error.details && error.details.allConditionOperators && error.details.allConditionOperators.length > 0) {
+            issueDetails += `  - All Condition Operators:\n`;
+            error.details.allConditionOperators.forEach((condition, index) => {
+                issueDetails += `    ${index + 1}. Fact: \`${condition.fact}\` Operator: \`${condition.operator}\` Value: \`${JSON.stringify(condition.value)}\`\n`;
+                if (condition.params) {
+                    issueDetails += `       Parameters: \`${JSON.stringify(condition.params)}\`\n`;
+                }
+            });
+        }
+        return issueDetails;
+    }
     generateReport() {
         const executiveSummary = this.generateExecutiveSummary();
         const fileStatusChart = this.generateFileStatusChart();

package/dist/operators/globalPatternCount.js

@@ -13,7 +13,7 @@ const globalPatternCount = {
             }
             // Parse threshold and comparison type
             let thresholdValue;
-            let comparisonType = 'gte'; // Default to greater than or equal
+            let comparisonType = 'lte'; // Default to greater than or equal
             if (typeof threshold === 'object' && threshold !== null) {
                 thresholdValue = threshold.threshold;
                 if (threshold.comparison) {

package/dist/operators/globalPatternCount.test.js

@@ -24,7 +24,7 @@ describe('globalPatternCount', () => {
                 totalMatches: 10
             }
         };
-        expect(globalPatternCount_1.globalPatternCount.fn(analysisResult, 5)).toBe(true);
+        expect(globalPatternCount_1.globalPatternCount.fn(analysisResult, 5)).toBe(false);
     });
     it('should return true when count exceeds threshold with explicit gte comparison', () => {
         const analysisResult = {
@@ -81,7 +81,7 @@ describe('globalPatternCount', () => {
         expect(globalPatternCount_1.globalPatternCount.fn({
             patternData: [{ pattern: 'pattern1', count: 0, files: [] }],
             summary: { totalMatches: 0 }
-        }, 1)).toBe(false);
+        }, 1)).toBe(true);
     });
     it('should handle new pattern totals with lte comparison', () => {
         const analysisResult = {

package/dist/operators/globalPatternRatio.test.js

@@ -81,12 +81,12 @@ describe('globalPatternRatio', () => {
     });
     it('should handle edge cases', () => {
         // No patterns
-        expect(globalPatternRatio_1.globalPatternRatio.fn({ patternData: [], summary: {} }, { value: 1, comparison: 'gte' })).toBe(false);
+        expect(globalPatternRatio_1.globalPatternRatio.fn({ patternData: [], summary: {} }, { threshold: 1, comparison: 'gte' })).toBe(false);
         // Only one pattern
         expect(globalPatternRatio_1.globalPatternRatio.fn({
             patternData: [{ pattern: 'pattern1', count: 5, files: [] }],
             summary: { totalMatches: 5 }
-        }, { value: 1, comparison: 'gte' })).toBe(false);
+        }, { threshold: 1, comparison: 'gte' })).toBe(false);
         // Denominator is zero
         expect(globalPatternRatio_1.globalPatternRatio.fn({
             patternData: [
@@ -94,7 +94,7 @@ describe('globalPatternRatio', () => {
                 { pattern: 'pattern2', count: 0, files: [] }
             ],
             summary: { totalMatches: 5 }
-        }, { value: 1, comparison: 'gte' })).toBe(false);
+        }, { threshold: 1, comparison: 'gte' })).toBe(false);
     });
     it('should handle new pattern totals with lte comparison', () => {
         const analysisResult = {

package/dist/types/typeDefs.d.ts

@@ -21,6 +21,17 @@ export interface RuleFailure {
         source?: 'operator' | 'fact' | 'plugin' | 'rule' | 'unknown';
         originalError?: Error;
         stack?: string;
+        operatorThreshold?: {
+            operator: string;
+            value: any;
+        };
+        operatorValue?: any;
+        conditionDetails?: {
+            fact: string;
+            operator: string;
+            value: any;
+            params?: any;
+        };
         [key: string]: any;
     } | undefined;
 }
@@ -112,6 +123,8 @@ export interface RuleConfig {
         action: string;
         params?: Record<string, any>;
     };
+    description?: string;
+    recommendations?: string[];
 }
 export type RuleConfigSchema = JSONSchemaType<RuleConfig>;
 export interface OpenAIAnalysisParams {
@@ -130,6 +143,22 @@ export interface BasicTelemetryMetadata {
     errorMessage?: string;
     options?: any;
     errorStack?: string;
+    ruleName?: string;
+    conditionDetails?: {
+        fact: string;
+        operator: string;
+        value: any;
+        params?: any;
+    };
+    allConditions?: Array<{
+        fact: string;
+        operator: string;
+        value: any;
+        params?: any;
+        path?: string;
+        priority?: number;
+    }>;
+    conditionType?: 'all' | 'any' | 'unknown';
 }
 export interface ExemptionTelemetryMetadata {
     repoUrl: string;

package/dist/utils/jsonSchemas.js

@@ -187,6 +187,12 @@ const ruleSchema = {
             required: ["action"],
             nullable: true,
         },
+        description: { type: "string", nullable: true },
+        recommendations: {
+            type: "array",
+            items: { type: "string" },
+            nullable: true
+        }
     },
     required: ["name", "conditions", "event"],
 };

package/dist/utils/logger.d.ts

@@ -4,6 +4,8 @@ export declare function generateLogPrefix(): string;
 export declare function resetLogPrefix(): void;
 export declare function setLogPrefix(prefix: string): void;
 export declare function getLogPrefix(): string;
+export declare function appendLogPrefix(suffix: string): void;
+export declare function withLogPrefix<T>(prefix: string, fn: () => T): T;
 export declare const logger: pino.Logger;
 export declare function resetLogger(): void;
 export declare function setLogLevel(level: string): void;