x-fidelity 3.5.0 → 3.6.0

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+# [3.6.0](https://github.com/zotoio/x-fidelity/compare/v3.5.0...v3.6.0) (2025-02-27)
+
+
+### Bug Fixes
+
+* add type annotations to fix TypeScript errors in globalFileAnalysis ([588c814](https://github.com/zotoio/x-fidelity/commit/588c8140a348a4959e62c027bdadbd625a11dc51))
+
+
+### Features
+
+* add global file analysis with pattern matching and ratio operators ([ab456df](https://github.com/zotoio/x-fidelity/commit/ab456df857efa82fd4f394f474b0b6f85b1fc91e))
+* add support for new and legacy pattern analysis ([6702ea0](https://github.com/zotoio/x-fidelity/commit/6702ea081cff3fbc2abceed35e4aee073ff02b56))
+* **targeting:** facts and operators to support rules applied to specific codebase matches ([231cb9a](https://github.com/zotoio/x-fidelity/commit/231cb9adedac8dc18666058925af835b68fe60e3))
+
 # [3.5.0](https://github.com/zotoio/x-fidelity/compare/v3.4.0...v3.5.0) (2025-02-27)
 
 

package/dist/demoConfig/node-fullstack.json

@@ -9,7 +9,8 @@
         "openaiAnalysisA11y-global",
         "invalidSystemIdConfigured-iterative",
         "missingRequiredFiles-global",
-        "factDoesNotAddResultToAlmanac-iterative"
+        "factDoesNotAddResultToAlmanac-iterative",
+        "apiUsageConsistency-global"
     ],
     "operators": [
         "fileContains",
@@ -18,14 +19,17 @@
         "openaiAnalysisHighSeverity",
         "invalidRemoteValidation",
         "missingRequiredFiles",
-        "regexMatch"
+        "regexMatch",
+        "globalPatternRatio",
+        "globalPatternCount"
     ],
     "facts": [
         "repoFilesystemFacts",
         "repoDependencyFacts",
         "openaiAnalysisFacts",
         "remoteSubstringValidation",
-        "missingRequiredFiles"
+        "missingRequiredFiles",
+        "globalFileAnalysisFacts"
     ],
     "plugins": [
         "xfiPluginRequiredFiles",

package/dist/demoConfig/rules/apiUsageConsistency-global-rule.json

@@ -0,0 +1,37 @@
+{
+    "name": "apiUsageConsistency-global",
+    "conditions": {
+        "all": [
+            {
+                "fact": "fileData",
+                "path": "$.fileName",
+                "operator": "equal",
+                "value": "REPO_GLOBAL_CHECK"
+            },
+            {
+                "fact": "globalFileAnalysis",
+                "params": {
+                    "newPatterns": [
+                        "logger\\.info\\("
+                    ],
+                    "legacyPatterns": [
+                        "logger\\.debug\\("
+                    ],
+                    "fileFilter": ".*\\.(ts|js)$",
+                    "resultFact": "apiUsageAnalysis"
+                },
+                "operator": "globalPatternRatio",
+                "value": 0.3
+            }
+        ]
+    },
+    "event": {
+        "type": "warning",
+        "params": {
+            "message": "The codebase is not consistently using the new API methods. At least 80% of API calls should use the new methods.",
+            "details": {
+                "fact": "apiUsageAnalysis"
+            }
+        }
+    }
+}

package/dist/facts/globalFileAnalysisFacts.d.ts

@@ -0,0 +1,2 @@
+import { FactDefn } from '../types/typeDefs';
+export declare const globalFileAnalysis: FactDefn;

package/dist/facts/globalFileAnalysisFacts.js

@@ -0,0 +1,108 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.globalFileAnalysis = void 0;
+const logger_1 = require("../utils/logger");
+const maskSensitiveData_1 = require("../utils/maskSensitiveData");
+exports.globalFileAnalysis = {
+    name: 'globalFileAnalysis',
+    fn: (params, almanac) => __awaiter(void 0, void 0, void 0, function* () {
+        const result = { result: [], matchCounts: {}, fileMatches: {} };
+        try {
+            // Get all file data from the almanac
+            const globalFileMetadata = yield almanac.factValue('globalFileMetadata');
+            if (!Array.isArray(globalFileMetadata)) {
+                logger_1.logger.error('Invalid globalFileMetadata');
+                return result;
+            }
+            // Extract parameters
+            const newPatterns = Array.isArray(params.newPatterns) ? params.newPatterns : (params.newPatterns ? [params.newPatterns] : []);
+            const legacyPatterns = Array.isArray(params.legacyPatterns) ? params.legacyPatterns : (params.legacyPatterns ? [params.legacyPatterns] : []);
+            // For backward compatibility
+            const patterns = Array.isArray(params.patterns) ? params.patterns : (params.patterns ? [params.patterns] : []);
+            const fileFilter = params.fileFilter || '.*';
+            const fileFilterRegex = new RegExp(fileFilter);
+            // Combine all patterns for processing
+            const allPatterns = [...newPatterns, ...legacyPatterns, ...patterns];
+            logger_1.logger.info(`Running global file analysis with ${newPatterns.length} new patterns, ${legacyPatterns.length} legacy patterns, and ${patterns.length} regular patterns across ${globalFileMetadata.length} files`);
+            // Filter files based on fileFilter parameter
+            const filteredFiles = globalFileMetadata.filter(file => file.fileName !== 'REPO_GLOBAL_CHECK' && fileFilterRegex.test(file.filePath));
+            logger_1.logger.info(`Analyzing ${filteredFiles.length} files after filtering`);
+            // Initialize match counts for each pattern
+            allPatterns.forEach((pattern) => {
+                result.matchCounts[pattern] = 0;
+                result.fileMatches[pattern] = [];
+            });
+            // Process each file
+            for (const file of filteredFiles) {
+                const fileContent = file.fileContent;
+                if (!fileContent)
+                    continue;
+                const lines = fileContent.split('\n');
+                // Check each pattern against the file
+                for (const pattern of allPatterns) {
+                    const regex = new RegExp(pattern, 'g');
+                    let fileMatches = 0;
+                    const matchDetails = [];
+                    // Check each line for matches
+                    for (let i = 0; i < lines.length; i++) {
+                        const line = lines[i];
+                        let match;
+                        while ((match = regex.exec(line)) !== null) {
+                            fileMatches++;
+                            matchDetails.push({
+                                lineNumber: i + 1,
+                                match: match[0],
+                                context: (0, maskSensitiveData_1.maskSensitiveData)(line.trim())
+                            });
+                        }
+                    }
+                    // Update results if matches found
+                    if (fileMatches > 0) {
+                        result.matchCounts[pattern] += fileMatches;
+                        result.fileMatches[pattern].push({
+                            filePath: file.filePath,
+                            matchCount: fileMatches,
+                            matches: matchDetails
+                        });
+                    }
+                }
+            }
+            // Calculate totals for new and legacy patterns
+            const newPatternsTotal = newPatterns.reduce((sum, pattern) => sum + (result.matchCounts[pattern] || 0), 0);
+            const legacyPatternsTotal = legacyPatterns.reduce((sum, pattern) => sum + (result.matchCounts[pattern] || 0), 0);
+            // Add summary to result
+            result.summary = {
+                totalFiles: filteredFiles.length,
+                totalMatches: Object.values(result.matchCounts).reduce((sum, count) => sum + count, 0),
+                patternCounts: result.matchCounts,
+                newPatternCounts: newPatterns.reduce((counts, pattern) => {
+                    counts[pattern] = result.matchCounts[pattern] || 0;
+                    return counts;
+                }, {}),
+                legacyPatternCounts: legacyPatterns.reduce((counts, pattern) => {
+                    counts[pattern] = result.matchCounts[pattern] || 0;
+                    return counts;
+                }, {}),
+                newPatternsTotal: newPatternsTotal,
+                legacyPatternsTotal: legacyPatternsTotal
+            };
+            // Add the result to the almanac
+            almanac.addRuntimeFact(params.resultFact, result);
+            logger_1.logger.info(`Global file analysis complete: ${JSON.stringify(result.summary)}`);
+            return result;
+        }
+        catch (error) {
+            logger_1.logger.error(`Error in globalFileAnalysis: ${error}`);
+            return result;
+        }
+    })
+};

package/dist/facts/globalFileAnalysisFacts.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/facts/globalFileAnalysisFacts.test.js

@@ -0,0 +1,69 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const globalFileAnalysisFacts_1 = require("./globalFileAnalysisFacts");
+const logger_1 = require("../utils/logger");
+jest.mock('../utils/logger', () => ({
+    logger: {
+        debug: jest.fn(),
+        error: jest.fn(),
+        info: jest.fn(),
+        warn: jest.fn(),
+    },
+}));
+describe('globalFileAnalysis', () => {
+    it('should analyze patterns across multiple files', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mockAlmanac = {
+            factValue: jest.fn().mockResolvedValue([
+                {
+                    fileName: 'file1.ts',
+                    filePath: '/path/to/file1.ts',
+                    fileContent: 'function test() { newApiMethod(); legacyApiMethod(); }'
+                },
+                {
+                    fileName: 'file2.ts',
+                    filePath: '/path/to/file2.ts',
+                    fileContent: 'function test2() { newApiMethod(); newApiMethod(); }'
+                },
+                {
+                    fileName: 'REPO_GLOBAL_CHECK',
+                    filePath: 'REPO_GLOBAL_CHECK',
+                    fileContent: 'REPO_GLOBAL_CHECK'
+                }
+            ]),
+            addRuntimeFact: jest.fn(),
+        };
+        const params = {
+            patterns: ['newApiMethod\\(', 'legacyApiMethod\\('],
+            fileFilter: '\\.ts$',
+            resultFact: 'apiUsageAnalysis'
+        };
+        const result = yield globalFileAnalysisFacts_1.globalFileAnalysis.fn(params, mockAlmanac);
+        expect(result.summary.totalFiles).toBe(2);
+        expect(result.matchCounts['newApiMethod\\(']).toBe(3);
+        expect(result.matchCounts['legacyApiMethod\\(']).toBe(1);
+        expect(mockAlmanac.addRuntimeFact).toHaveBeenCalledWith('apiUsageAnalysis', expect.any(Object));
+    }));
+    it('should handle errors gracefully', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mockAlmanac = {
+            factValue: jest.fn().mockRejectedValue(new Error('Test error')),
+            addRuntimeFact: jest.fn(),
+        };
+        const params = {
+            patterns: ['newApiMethod\\('],
+            fileFilter: '\\.ts$',
+            resultFact: 'apiUsageAnalysis'
+        };
+        const result = yield globalFileAnalysisFacts_1.globalFileAnalysis.fn(params, mockAlmanac);
+        expect(result.result).toEqual([]);
+        expect(logger_1.logger.error).toHaveBeenCalled();
+    }));
+});

package/dist/facts/index.js

@@ -13,6 +13,7 @@ exports.loadFacts = loadFacts;
 const repoFilesystemFacts_1 = require("./repoFilesystemFacts");
 const repoDependencyFacts_1 = require("./repoDependencyFacts");
 const openaiAnalysisFacts_1 = require("./openaiAnalysisFacts");
+const globalFileAnalysisFacts_1 = require("./globalFileAnalysisFacts");
 const pluginRegistry_1 = require("../core/pluginRegistry");
 const openaiUtils_1 = require("../utils/openaiUtils");
 const logger_1 = require("../utils/logger");
@@ -29,6 +30,10 @@ function loadFacts(factNames) {
             }, openaiAnalysisFacts: {
                 name: 'openaiAnalysis',
                 fn: openaiAnalysisFacts_1.openaiAnalysis
+            }, globalFileAnalysisFacts: {
+                name: 'globalFileAnalysis',
+                fn: globalFileAnalysisFacts_1.globalFileAnalysis.fn,
+                priority: 50 // Set priority to run after globalFileMetadata
             } }, Object.fromEntries(pluginRegistry_1.pluginRegistry.getPluginFacts().map(fact => [fact.name, fact])));
         logger_1.logger.info(`Loading facts: ${factNames.join(', ')}`);
         const pluginFacts = pluginRegistry_1.pluginRegistry.getPluginFacts();

package/dist/operators/globalPatternCount.d.ts

@@ -0,0 +1,3 @@
+import { OperatorDefn } from '../types/typeDefs';
+declare const globalPatternCount: OperatorDefn;
+export { globalPatternCount };

package/dist/operators/globalPatternCount.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.globalPatternCount = void 0;
+const logger_1 = require("../utils/logger");
+const globalPatternCount = {
+    'name': 'globalPatternCount',
+    'fn': (analysisResult, threshold) => {
+        try {
+            logger_1.logger.debug(`globalPatternCount: processing ${JSON.stringify(analysisResult)}`);
+            if (!analysisResult || !analysisResult.summary) {
+                logger_1.logger.debug('globalPatternCount: no analysis result available');
+                return false;
+            }
+            // Check if we have new pattern totals
+            if (analysisResult.summary.newPatternsTotal !== undefined) {
+                const newTotal = analysisResult.summary.newPatternsTotal;
+                logger_1.logger.info(`globalPatternCount: new patterns total: ${newTotal}, threshold: ${threshold}`);
+                // Compare count with threshold
+                return newTotal >= threshold;
+            }
+            // Fallback to original behavior for backward compatibility
+            const patterns = Object.keys(analysisResult.matchCounts);
+            if (patterns.length < 1) {
+                logger_1.logger.debug('globalPatternCount: no patterns found in analysis');
+                return false;
+            }
+            // Get count for the first pattern
+            const patternCount = analysisResult.matchCounts[patterns[0]] || 0;
+            logger_1.logger.info(`globalPatternCount: ${patternCount}, threshold: ${threshold}`);
+            // Compare count with threshold
+            return patternCount >= threshold;
+        }
+        catch (e) {
+            logger_1.logger.error(`globalPatternCount error: ${e}`);
+            return false;
+        }
+    }
+};
+exports.globalPatternCount = globalPatternCount;

package/dist/operators/globalPatternCount.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/operators/globalPatternCount.test.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const globalPatternCount_1 = require("./globalPatternCount");
+jest.mock('../utils/logger', () => ({
+    logger: {
+        debug: jest.fn(),
+        error: jest.fn(),
+        info: jest.fn(),
+    },
+}));
+describe('globalPatternCount', () => {
+    it('should return true when count exceeds threshold', () => {
+        const analysisResult = {
+            matchCounts: {
+                'pattern1': 10
+            },
+            summary: {
+                totalFiles: 5,
+                totalMatches: 10
+            }
+        };
+        expect(globalPatternCount_1.globalPatternCount.fn(analysisResult, 5)).toBe(true);
+    });
+    it('should return false when count is below threshold', () => {
+        const analysisResult = {
+            matchCounts: {
+                'pattern1': 3
+            },
+            summary: {
+                totalFiles: 5,
+                totalMatches: 3
+            }
+        };
+        expect(globalPatternCount_1.globalPatternCount.fn(analysisResult, 5)).toBe(false);
+    });
+    it('should handle edge cases', () => {
+        // No patterns
+        expect(globalPatternCount_1.globalPatternCount.fn({ matchCounts: {}, summary: {} }, 1)).toBe(false);
+        // No matches
+        expect(globalPatternCount_1.globalPatternCount.fn({
+            matchCounts: { 'pattern1': 0 },
+            summary: { totalMatches: 0 }
+        }, 1)).toBe(false);
+    });
+});

package/dist/operators/globalPatternRatio.d.ts

@@ -0,0 +1,3 @@
+import { OperatorDefn } from '../types/typeDefs';
+declare const globalPatternRatio: OperatorDefn;
+export { globalPatternRatio };

package/dist/operators/globalPatternRatio.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.globalPatternRatio = void 0;
+const logger_1 = require("../utils/logger");
+const globalPatternRatio = {
+    'name': 'globalPatternRatio',
+    'fn': (analysisResult, threshold) => {
+        try {
+            logger_1.logger.debug(`globalPatternRatio: processing ${JSON.stringify(analysisResult)}`);
+            if (!analysisResult || !analysisResult.summary) {
+                logger_1.logger.debug('globalPatternRatio: no analysis result available');
+                return false;
+            }
+            // Check if we have new and legacy pattern totals
+            if (analysisResult.summary.newPatternsTotal !== undefined &&
+                analysisResult.summary.legacyPatternsTotal !== undefined) {
+                const newTotal = analysisResult.summary.newPatternsTotal;
+                const legacyTotal = analysisResult.summary.legacyPatternsTotal;
+                const total = newTotal + legacyTotal;
+                // Avoid division by zero
+                if (total === 0) {
+                    logger_1.logger.debug('globalPatternRatio: no pattern matches found');
+                    return false;
+                }
+                // Calculate ratio of new patterns to total patterns
+                const ratio = newTotal / total;
+                logger_1.logger.info(`globalPatternRatio: ${newTotal}/(${newTotal}+${legacyTotal}) = ${ratio}, threshold: ${threshold}`);
+                // Compare ratio with threshold
+                return ratio >= threshold;
+            }
+            // Fallback to original behavior for backward compatibility
+            const patterns = Object.keys(analysisResult.matchCounts);
+            if (patterns.length < 2) {
+                logger_1.logger.debug('globalPatternRatio: need at least 2 patterns to calculate ratio');
+                return false;
+            }
+            // Calculate ratio between first two patterns
+            const pattern1Count = analysisResult.matchCounts[patterns[0]] || 0;
+            const pattern2Count = analysisResult.matchCounts[patterns[1]] || 0;
+            // Avoid division by zero
+            if (pattern2Count === 0) {
+                logger_1.logger.debug('globalPatternRatio: denominator pattern has zero matches');
+                return false;
+            }
+            const ratio = pattern1Count / pattern2Count;
+            logger_1.logger.info(`globalPatternRatio: ${pattern1Count}/${pattern2Count} = ${ratio}, threshold: ${threshold}`);
+            // Compare ratio with threshold
+            return ratio >= threshold;
+        }
+        catch (e) {
+            logger_1.logger.error(`globalPatternRatio error: ${e}`);
+            return false;
+        }
+    }
+};
+exports.globalPatternRatio = globalPatternRatio;

package/dist/operators/globalPatternRatio.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/operators/globalPatternRatio.test.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const globalPatternRatio_1 = require("./globalPatternRatio");
+jest.mock('../utils/logger', () => ({
+    logger: {
+        debug: jest.fn(),
+        error: jest.fn(),
+        info: jest.fn(),
+    },
+}));
+describe('globalPatternRatio', () => {
+    it('should return true when ratio exceeds threshold', () => {
+        const analysisResult = {
+            matchCounts: {
+                'newApiMethod\\(': 8,
+                'legacyApiMethod\\(': 2
+            },
+            summary: {
+                totalFiles: 5,
+                totalMatches: 10
+            }
+        };
+        expect(globalPatternRatio_1.globalPatternRatio.fn(analysisResult, 3)).toBe(true);
+    });
+    it('should return false when ratio is below threshold', () => {
+        const analysisResult = {
+            matchCounts: {
+                'newApiMethod\\(': 4,
+                'legacyApiMethod\\(': 6
+            },
+            summary: {
+                totalFiles: 5,
+                totalMatches: 10
+            }
+        };
+        expect(globalPatternRatio_1.globalPatternRatio.fn(analysisResult, 1)).toBe(false);
+    });
+    it('should handle edge cases', () => {
+        // No patterns
+        expect(globalPatternRatio_1.globalPatternRatio.fn({ matchCounts: {}, summary: {} }, 1)).toBe(false);
+        // Only one pattern
+        expect(globalPatternRatio_1.globalPatternRatio.fn({
+            matchCounts: { 'pattern1': 5 },
+            summary: { totalMatches: 5 }
+        }, 1)).toBe(false);
+        // Denominator is zero
+        expect(globalPatternRatio_1.globalPatternRatio.fn({
+            matchCounts: { 'pattern1': 5, 'pattern2': 0 },
+            summary: { totalMatches: 5 }
+        }, 1)).toBe(false);
+    });
+});

package/dist/operators/index.js

@@ -15,6 +15,8 @@ const fileContains_1 = require("./fileContains");
 const nonStandardDirectoryStructure_1 = require("./nonStandardDirectoryStructure");
 const openaiAnalysisHighSeverity_1 = require("./openaiAnalysisHighSeverity");
 const regexMatch_1 = require("./regexMatch");
+const globalPatternRatio_1 = require("./globalPatternRatio");
+const globalPatternCount_1 = require("./globalPatternCount");
 const openaiUtils_1 = require("../utils/openaiUtils");
 const logger_1 = require("../utils/logger");
 const pluginRegistry_1 = require("../core/pluginRegistry");
@@ -25,7 +27,9 @@ function loadOperators(operatorNames) {
             fileContains: fileContains_1.fileContains,
             nonStandardDirectoryStructure: nonStandardDirectoryStructure_1.nonStandardDirectoryStructure,
             openaiAnalysisHighSeverity: openaiAnalysisHighSeverity_1.openaiAnalysisHighSeverity,
-            regexMatch: regexMatch_1.regexMatch }, Object.fromEntries(pluginRegistry_1.pluginRegistry.getPluginOperators().map(op => [op.name, op])));
+            regexMatch: regexMatch_1.regexMatch,
+            globalPatternRatio: globalPatternRatio_1.globalPatternRatio,
+            globalPatternCount: globalPatternCount_1.globalPatternCount }, Object.fromEntries(pluginRegistry_1.pluginRegistry.getPluginOperators().map(op => [op.name, op])));
         const openAIStatus = (0, openaiUtils_1.getOpenAIStatus)();
         logger_1.logger.info(`Loading operators: ${operatorNames.join(', ')}`);
         const loadedOperators = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "x-fidelity",
-  "version": "3.5.0",
+  "version": "3.6.0",
   "description": "cli for opinionated framework adherence checks",
   "main": "dist/index",
   "types": "dist/index.d.ts",

package/src/demoConfig/node-fullstack.json

@@ -9,7 +9,8 @@
         "openaiAnalysisA11y-global",
         "invalidSystemIdConfigured-iterative",
         "missingRequiredFiles-global",
-        "factDoesNotAddResultToAlmanac-iterative"
+        "factDoesNotAddResultToAlmanac-iterative",
+        "apiUsageConsistency-global"
     ],
     "operators": [
         "fileContains",
@@ -18,14 +19,17 @@
         "openaiAnalysisHighSeverity",
         "invalidRemoteValidation",
         "missingRequiredFiles",
-        "regexMatch"
+        "regexMatch",
+        "globalPatternRatio",
+        "globalPatternCount"
     ],
     "facts": [
         "repoFilesystemFacts",
         "repoDependencyFacts",
         "openaiAnalysisFacts",
         "remoteSubstringValidation",
-        "missingRequiredFiles"
+        "missingRequiredFiles",
+        "globalFileAnalysisFacts"
     ],
     "plugins": [
         "xfiPluginRequiredFiles",

package/src/demoConfig/rules/apiUsageConsistency-global-rule.json

@@ -0,0 +1,37 @@
+{
+    "name": "apiUsageConsistency-global",
+    "conditions": {
+        "all": [
+            {
+                "fact": "fileData",
+                "path": "$.fileName",
+                "operator": "equal",
+                "value": "REPO_GLOBAL_CHECK"
+            },
+            {
+                "fact": "globalFileAnalysis",
+                "params": {
+                    "newPatterns": [
+                        "logger\\.info\\("
+                    ],
+                    "legacyPatterns": [
+                        "logger\\.debug\\("
+                    ],
+                    "fileFilter": ".*\\.(ts|js)$",
+                    "resultFact": "apiUsageAnalysis"
+                },
+                "operator": "globalPatternRatio",
+                "value": 0.3
+            }
+        ]
+    },
+    "event": {
+        "type": "warning",
+        "params": {
+            "message": "The codebase is not consistently using the new API methods. At least 80% of API calls should use the new methods.",
+            "details": {
+                "fact": "apiUsageAnalysis"
+            }
+        }
+    }
+}

package/src/facts/globalFileAnalysisFacts.test.ts

@@ -0,0 +1,67 @@
+import { globalFileAnalysis } from './globalFileAnalysisFacts';
+import { logger } from '../utils/logger';
+
+jest.mock('../utils/logger', () => ({
+    logger: {
+        debug: jest.fn(),
+        error: jest.fn(),
+        info: jest.fn(),
+        warn: jest.fn(),
+    },
+}));
+
+describe('globalFileAnalysis', () => {
+    it('should analyze patterns across multiple files', async () => {
+        const mockAlmanac = {
+            factValue: jest.fn().mockResolvedValue([
+                {
+                    fileName: 'file1.ts',
+                    filePath: '/path/to/file1.ts',
+                    fileContent: 'function test() { newApiMethod(); legacyApiMethod(); }'
+                },
+                {
+                    fileName: 'file2.ts',
+                    filePath: '/path/to/file2.ts',
+                    fileContent: 'function test2() { newApiMethod(); newApiMethod(); }'
+                },
+                {
+                    fileName: 'REPO_GLOBAL_CHECK',
+                    filePath: 'REPO_GLOBAL_CHECK',
+                    fileContent: 'REPO_GLOBAL_CHECK'
+                }
+            ]),
+            addRuntimeFact: jest.fn(),
+        };
+
+        const params = {
+            patterns: ['newApiMethod\\(', 'legacyApiMethod\\('],
+            fileFilter: '\\.ts$',
+            resultFact: 'apiUsageAnalysis'
+        };
+
+        const result = await globalFileAnalysis.fn(params, mockAlmanac);
+
+        expect(result.summary.totalFiles).toBe(2);
+        expect(result.matchCounts['newApiMethod\\(']).toBe(3);
+        expect(result.matchCounts['legacyApiMethod\\(']).toBe(1);
+        expect(mockAlmanac.addRuntimeFact).toHaveBeenCalledWith('apiUsageAnalysis', expect.any(Object));
+    });
+
+    it('should handle errors gracefully', async () => {
+        const mockAlmanac = {
+            factValue: jest.fn().mockRejectedValue(new Error('Test error')),
+            addRuntimeFact: jest.fn(),
+        };
+
+        const params = {
+            patterns: ['newApiMethod\\('],
+            fileFilter: '\\.ts$',
+            resultFact: 'apiUsageAnalysis'
+        };
+
+        const result = await globalFileAnalysis.fn(params, mockAlmanac);
+
+        expect(result.result).toEqual([]);
+        expect(logger.error).toHaveBeenCalled();
+    });
+});

package/src/facts/globalFileAnalysisFacts.ts

@@ -0,0 +1,116 @@
+import { logger } from '../utils/logger';
+import { FactDefn, FileData } from '../types/typeDefs';
+import { maskSensitiveData } from '../utils/maskSensitiveData';
+
+export const globalFileAnalysis: FactDefn = {
+    name: 'globalFileAnalysis',
+    fn: async (params: any, almanac: any) => {
+        const result: any = { result: [], matchCounts: {}, fileMatches: {} };
+        
+        try {
+            // Get all file data from the almanac
+            const globalFileMetadata: FileData[] = await almanac.factValue('globalFileMetadata');
+            if (!Array.isArray(globalFileMetadata)) {
+                logger.error('Invalid globalFileMetadata');
+                return result;
+            }
+
+            // Extract parameters
+            const newPatterns = Array.isArray(params.newPatterns) ? params.newPatterns : (params.newPatterns ? [params.newPatterns] : []);
+            const legacyPatterns = Array.isArray(params.legacyPatterns) ? params.legacyPatterns : (params.legacyPatterns ? [params.legacyPatterns] : []);
+            // For backward compatibility
+            const patterns = Array.isArray(params.patterns) ? params.patterns : (params.patterns ? [params.patterns] : []);
+            
+            const fileFilter = params.fileFilter || '.*';
+            const fileFilterRegex = new RegExp(fileFilter);
+            
+            // Combine all patterns for processing
+            const allPatterns = [...newPatterns, ...legacyPatterns, ...patterns];
+            
+            logger.info(`Running global file analysis with ${newPatterns.length} new patterns, ${legacyPatterns.length} legacy patterns, and ${patterns.length} regular patterns across ${globalFileMetadata.length} files`);
+            
+            // Filter files based on fileFilter parameter
+            const filteredFiles = globalFileMetadata.filter(file => 
+                file.fileName !== 'REPO_GLOBAL_CHECK' && fileFilterRegex.test(file.filePath)
+            );
+            
+            logger.info(`Analyzing ${filteredFiles.length} files after filtering`);
+            
+            // Initialize match counts for each pattern
+            allPatterns.forEach((pattern: string) => {
+                result.matchCounts[pattern] = 0;
+                result.fileMatches[pattern] = [];
+            });
+            
+            // Process each file
+            for (const file of filteredFiles) {
+                const fileContent = file.fileContent;
+                if (!fileContent) continue;
+                
+                const lines = fileContent.split('\n');
+                
+                // Check each pattern against the file
+                for (const pattern of allPatterns) {
+                    const regex = new RegExp(pattern, 'g');
+                    let fileMatches = 0;
+                    const matchDetails = [];
+                    
+                    // Check each line for matches
+                    for (let i = 0; i < lines.length; i++) {
+                        const line = lines[i];
+                        let match;
+                        while ((match = regex.exec(line)) !== null) {
+                            fileMatches++;
+                            matchDetails.push({
+                                lineNumber: i + 1,
+                                match: match[0],
+                                context: maskSensitiveData(line.trim())
+                            });
+                        }
+                    }
+                    
+                    // Update results if matches found
+                    if (fileMatches > 0) {
+                        result.matchCounts[pattern] += fileMatches;
+                        result.fileMatches[pattern].push({
+                            filePath: file.filePath,
+                            matchCount: fileMatches,
+                            matches: matchDetails
+                        });
+                    }
+                }
+            }
+            
+            // Calculate totals for new and legacy patterns
+            const newPatternsTotal = newPatterns.reduce((sum: number, pattern: string) => sum + (result.matchCounts[pattern] || 0), 0);
+            const legacyPatternsTotal = legacyPatterns.reduce((sum: number, pattern: string) => sum + (result.matchCounts[pattern] || 0), 0);
+            
+            // Add summary to result
+            result.summary = {
+                totalFiles: filteredFiles.length,
+                totalMatches: Object.values(result.matchCounts).reduce((sum: number, count: unknown) => sum + (count as number), 0),
+                patternCounts: result.matchCounts,
+                newPatternCounts: newPatterns.reduce((counts: Record<string, number>, pattern: string) => {
+                    counts[pattern] = result.matchCounts[pattern] || 0;
+                    return counts;
+                }, {}),
+                legacyPatternCounts: legacyPatterns.reduce((counts: Record<string, number>, pattern: string) => {
+                    counts[pattern] = result.matchCounts[pattern] || 0;
+                    return counts;
+                }, {}),
+                newPatternsTotal: newPatternsTotal,
+                legacyPatternsTotal: legacyPatternsTotal
+            };
+            
+            // Add the result to the almanac
+            almanac.addRuntimeFact(params.resultFact, result);
+            
+            logger.info(`Global file analysis complete: ${JSON.stringify(result.summary)}`);
+            
+            return result;
+        } catch (error) {
+            logger.error(`Error in globalFileAnalysis: ${error}`);
+            return result;
+        }
+    }
+};

package/src/facts/index.ts

@@ -1,6 +1,7 @@
 import { collectRepoFileData } from './repoFilesystemFacts';
 import { getDependencyVersionFacts } from './repoDependencyFacts';
 import { openaiAnalysis } from './openaiAnalysisFacts';
+import { globalFileAnalysis } from './globalFileAnalysisFacts';
 import { pluginRegistry } from '../core/pluginRegistry';
 import { isOpenAIEnabled } from '../utils/openaiUtils';
 import { FactDefn } from '../types/typeDefs';
@@ -22,6 +23,11 @@ async function loadFacts(factNames: string[]): Promise<FactDefn[]> {
             name: 'openaiAnalysis', 
             fn: openaiAnalysis 
         },
+        globalFileAnalysisFacts: {
+            name: 'globalFileAnalysis',
+            fn: globalFileAnalysis.fn,
+            priority: 50 // Set priority to run after globalFileMetadata
+        },
         ...Object.fromEntries(
             pluginRegistry.getPluginFacts().map(fact => [fact.name, fact])
         )

package/src/operators/globalPatternCount.test.ts

@@ -0,0 +1,51 @@
+import { globalPatternCount } from './globalPatternCount';
+import { logger } from '../utils/logger';
+
+jest.mock('../utils/logger', () => ({
+    logger: {
+        debug: jest.fn(),
+        error: jest.fn(),
+        info: jest.fn(),
+    },
+}));
+
+describe('globalPatternCount', () => {
+    it('should return true when count exceeds threshold', () => {
+        const analysisResult = {
+            matchCounts: {
+                'pattern1': 10
+            },
+            summary: {
+                totalFiles: 5,
+                totalMatches: 10
+            }
+        };
+        
+        expect(globalPatternCount.fn(analysisResult, 5)).toBe(true);
+    });
+
+    it('should return false when count is below threshold', () => {
+        const analysisResult = {
+            matchCounts: {
+                'pattern1': 3
+            },
+            summary: {
+                totalFiles: 5,
+                totalMatches: 3
+            }
+        };
+        
+        expect(globalPatternCount.fn(analysisResult, 5)).toBe(false);
+    });
+
+    it('should handle edge cases', () => {
+        // No patterns
+        expect(globalPatternCount.fn({ matchCounts: {}, summary: {} }, 1)).toBe(false);
+        
+        // No matches
+        expect(globalPatternCount.fn({ 
+            matchCounts: { 'pattern1': 0 }, 
+            summary: { totalMatches: 0 } 
+        }, 1)).toBe(false);
+    });
+});

package/src/operators/globalPatternCount.ts

@@ -0,0 +1,44 @@
+import { logger } from '../utils/logger';
+import { OperatorDefn } from '../types/typeDefs';
+
+const globalPatternCount: OperatorDefn = {
+    'name': 'globalPatternCount',
+    'fn': (analysisResult: any, threshold: number) => {
+        try {
+            logger.debug(`globalPatternCount: processing ${JSON.stringify(analysisResult)}`);
+            
+            if (!analysisResult || !analysisResult.summary) {
+                logger.debug('globalPatternCount: no analysis result available');
+                return false;
+            }
+            
+            // Check if we have new pattern totals
+            if (analysisResult.summary.newPatternsTotal !== undefined) {
+                const newTotal = analysisResult.summary.newPatternsTotal;
+                logger.info(`globalPatternCount: new patterns total: ${newTotal}, threshold: ${threshold}`);
+                
+                // Compare count with threshold
+                return newTotal >= threshold;
+            }
+            
+            // Fallback to original behavior for backward compatibility
+            const patterns = Object.keys(analysisResult.matchCounts);
+            if (patterns.length < 1) {
+                logger.debug('globalPatternCount: no patterns found in analysis');
+                return false;
+            }
+            
+            // Get count for the first pattern
+            const patternCount = analysisResult.matchCounts[patterns[0]] || 0;
+            logger.info(`globalPatternCount: ${patternCount}, threshold: ${threshold}`);
+            
+            // Compare count with threshold
+            return patternCount >= threshold;
+        } catch (e) {
+            logger.error(`globalPatternCount error: ${e}`);
+            return false;
+        }
+    }
+};
+
+export { globalPatternCount };

package/src/operators/globalPatternRatio.test.ts

@@ -0,0 +1,59 @@
+import { globalPatternRatio } from './globalPatternRatio';
+import { logger } from '../utils/logger';
+
+jest.mock('../utils/logger', () => ({
+    logger: {
+        debug: jest.fn(),
+        error: jest.fn(),
+        info: jest.fn(),
+    },
+}));
+
+describe('globalPatternRatio', () => {
+    it('should return true when ratio exceeds threshold', () => {
+        const analysisResult = {
+            matchCounts: {
+                'newApiMethod\\(': 8,
+                'legacyApiMethod\\(': 2
+            },
+            summary: {
+                totalFiles: 5,
+                totalMatches: 10
+            }
+        };
+        
+        expect(globalPatternRatio.fn(analysisResult, 3)).toBe(true);
+    });
+
+    it('should return false when ratio is below threshold', () => {
+        const analysisResult = {
+            matchCounts: {
+                'newApiMethod\\(': 4,
+                'legacyApiMethod\\(': 6
+            },
+            summary: {
+                totalFiles: 5,
+                totalMatches: 10
+            }
+        };
+        
+        expect(globalPatternRatio.fn(analysisResult, 1)).toBe(false);
+    });
+
+    it('should handle edge cases', () => {
+        // No patterns
+        expect(globalPatternRatio.fn({ matchCounts: {}, summary: {} }, 1)).toBe(false);
+        
+        // Only one pattern
+        expect(globalPatternRatio.fn({ 
+            matchCounts: { 'pattern1': 5 }, 
+            summary: { totalMatches: 5 } 
+        }, 1)).toBe(false);
+        
+        // Denominator is zero
+        expect(globalPatternRatio.fn({ 
+            matchCounts: { 'pattern1': 5, 'pattern2': 0 }, 
+            summary: { totalMatches: 5 } 
+        }, 1)).toBe(false);
+    });
+});

package/src/operators/globalPatternRatio.ts

@@ -0,0 +1,66 @@
+import { logger } from '../utils/logger';
+import { OperatorDefn } from '../types/typeDefs';
+
+const globalPatternRatio: OperatorDefn = {
+    'name': 'globalPatternRatio',
+    'fn': (analysisResult: any, threshold: number) => {
+        try {
+            logger.debug(`globalPatternRatio: processing ${JSON.stringify(analysisResult)}`);
+            
+            if (!analysisResult || !analysisResult.summary) {
+                logger.debug('globalPatternRatio: no analysis result available');
+                return false;
+            }
+            
+            // Check if we have new and legacy pattern totals
+            if (analysisResult.summary.newPatternsTotal !== undefined && 
+                analysisResult.summary.legacyPatternsTotal !== undefined) {
+                
+                const newTotal = analysisResult.summary.newPatternsTotal;
+                const legacyTotal = analysisResult.summary.legacyPatternsTotal;
+                const total = newTotal + legacyTotal;
+                
+                // Avoid division by zero
+                if (total === 0) {
+                    logger.debug('globalPatternRatio: no pattern matches found');
+                    return false;
+                }
+                
+                // Calculate ratio of new patterns to total patterns
+                const ratio = newTotal / total;
+                logger.info(`globalPatternRatio: ${newTotal}/(${newTotal}+${legacyTotal}) = ${ratio}, threshold: ${threshold}`);
+                
+                // Compare ratio with threshold
+                return ratio >= threshold;
+            }
+            
+            // Fallback to original behavior for backward compatibility
+            const patterns = Object.keys(analysisResult.matchCounts);
+            if (patterns.length < 2) {
+                logger.debug('globalPatternRatio: need at least 2 patterns to calculate ratio');
+                return false;
+            }
+            
+            // Calculate ratio between first two patterns
+            const pattern1Count = analysisResult.matchCounts[patterns[0]] || 0;
+            const pattern2Count = analysisResult.matchCounts[patterns[1]] || 0;
+            
+            // Avoid division by zero
+            if (pattern2Count === 0) {
+                logger.debug('globalPatternRatio: denominator pattern has zero matches');
+                return false;
+            }
+            
+            const ratio = pattern1Count / pattern2Count;
+            logger.info(`globalPatternRatio: ${pattern1Count}/${pattern2Count} = ${ratio}, threshold: ${threshold}`);
+            
+            // Compare ratio with threshold
+            return ratio >= threshold;
+        } catch (e) {
+            logger.error(`globalPatternRatio error: ${e}`);
+            return false;
+        }
+    }
+};
+
+export { globalPatternRatio };

package/src/operators/index.ts

@@ -4,6 +4,8 @@ import { fileContains } from './fileContains';
 import { nonStandardDirectoryStructure } from './nonStandardDirectoryStructure';
 import { openaiAnalysisHighSeverity } from './openaiAnalysisHighSeverity';
 import { regexMatch } from './regexMatch';
+import { globalPatternRatio } from './globalPatternRatio';
+import { globalPatternCount } from './globalPatternCount';
 import { getOpenAIStatus } from '../utils/openaiUtils';
 import { logger } from '../utils/logger';
 import { pluginRegistry } from '../core/pluginRegistry';
@@ -16,6 +18,8 @@ async function loadOperators(operatorNames: string[]): Promise<OperatorDefn[]> {
         nonStandardDirectoryStructure,
         openaiAnalysisHighSeverity,
         regexMatch,
+        globalPatternRatio,
+        globalPatternCount,
         ...Object.fromEntries(
             pluginRegistry.getPluginOperators().map(op => [op.name, op])
         )