x-fidelity 3.4.0 → 3.6.0

package/.xfi-config.json

@@ -1,5 +1,5 @@
 {
     "sensitiveFileFalsePositives": [
-        "/README2.md"
+        "/src/facts/repoFilesystemFacts.ts"
     ]
 }

package/CHANGELOG.md

@@ -1,3 +1,29 @@
+# [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)
+
+
+### Bug Fixes
+
+* **regexmatch:** give better examples of iterative and negative matches ([3a4f211](https://github.com/zotoio/x-fidelity/commit/3a4f21157119a0677b29ebc211716526d8a762d0))
+
+
+### Features
+
+* add plugin support to archetype configuration ([9e0a02b](https://github.com/zotoio/x-fidelity/commit/9e0a02be24fb812ca056157a0c3f1c7b8699b7f2))
+
 # [3.4.0](https://github.com/zotoio/x-fidelity/compare/v3.3.1...v3.4.0) (2025-02-26)
 
 

package/README.md

@@ -179,6 +179,7 @@ x-fidelity is designed to be highly extensible, and only has demo rules and arch
 2. **Custom Rules**: Add new JSON rule files in the `rules` subdirectory of your local config or on your config server.
 3. **Custom Operators**: TODO: Implement new operators and add them to your x-fidelity fork or plugin.
 4. **Custom Facts**: TODO: Create new fact providers and add them to your x-fidelity fork or plugin.
+5. **Plugins**: Specify plugins in your archetype configuration or via the CLI to extend functionality.
  
 > At minimum you should configure your archetypes and rules using the provided facts and operators.  Facts and Operators are more complex and are not yet easily added without forking, and those provided are intended to be flexible enough for general codebase analysis.
 
@@ -188,6 +189,7 @@ Archetypes represent a pattern or template of git repo that you expect to be con
 - **rules**: names of rules you have defined to perform either global (repo wide) checks, or checks on each file in a repo.
 - **facts**: data prepared before analysing a repo such as dependency data and file structures.
 - **operators**: these are custom operators, or provided operators that compare facts and return a boolean result.  In x-fi boolean true means a rule failure. 
+- **plugins**: names of plugins to load when using this archetype. These extend the functionality with custom facts and operators.
 - **config**: core configuration related to codebase analysis:
 - minimumDependencyVersions: packages you want to conform to provided semver ranges.
 - standardStructure: expected filesystem directories at high level
@@ -201,6 +203,7 @@ Example of a custom archetype JSON file (`my-custom-archetype.json`):
     "rules": ["myCustomRule-global", "standardRule1-iterative", "standardRule2-iterative"],
     "operators": ["myCustomOperator", "standardOperator1"],
     "facts": ["myCustomFact", "standardFact1"],
+    "plugins": ["xfiPluginRequiredFiles", "myCustomPlugin"],
     "config": {
         "minimumDependencyVersions": {
             "my-framework": ">2.0.0"
@@ -836,7 +839,10 @@ New extensions are available:
 - *Remote String Validation Plugin:* (module: `xfiPluginRemoteStringValidator`) adds remote validation functionality via the `remoteSubstringValidation` fact and the `invalidRemoteValidation` operator.
 - *Sample Custom Plugin:* (module: `xfiPluginSimpleExample`) shows how to add custom facts and operators.
 
-To load these plugins, pass their module names via the `-e` (or `--extensions`) CLI option.
+There are two ways to load plugins:
+
+1. **Via CLI option**: Pass plugin module names via the `-e` (or `--extensions`) CLI option.
+2. **Via archetype configuration**: Specify plugins in the `plugins` array of your archetype JSON file.
 
 x-fidelity supports custom extensions through npm modules. To use extensions:
 
@@ -852,6 +858,17 @@ xfidelity -e xfi-basic-plugin xfi-another-plugin
 
 Multiple extensions can be specified by separating them with spaces.
 
+Alternatively, specify plugins in your archetype configuration:
+```json
+{
+    "name": "my-archetype",
+    "plugins": ["xfi-basic-plugin", "xfi-another-plugin"],
+    // other archetype properties...
+}
+```
+
+Plugins specified in both the CLI and the archetype will be loaded, with CLI-specified plugins loaded first.
+
 ### Creating Extensions
 
 You can create custom extensions by implementing the XFiPlugin interface:

package/dist/core/configManager.js

@@ -139,11 +139,6 @@ class ConfigManager {
             const localConfigPath = cli_1.options.localConfigPath;
             if (logPrefix)
                 (0, logger_1.setLogPrefix)(logPrefix);
-            // Load plugins during initialization
-            yield this.loadPlugins(cli_1.options.extensions).catch(error => {
-                logger_1.logger.error(error, `Error loading plugins`);
-                throw error;
-            });
             logger_1.logger.info(`Initializing config manager for archetype: ${archetype}`);
             logger_1.logger.debug(`Initialize params: ${JSON.stringify(params)}`);
             const config = {
@@ -162,6 +157,19 @@ class ConfigManager {
                 if (!config.archetype || Object.keys(config.archetype).length === 0) {
                     throw new Error(`No valid configuration found for archetype: ${archetype}`);
                 }
+                // Load CLI-specified plugins first
+                yield this.loadPlugins(cli_1.options.extensions).catch(error => {
+                    logger_1.logger.error(error, `Error loading CLI-specified plugins`);
+                    throw error;
+                });
+                // Load archetype-specified plugins
+                if (config.archetype.plugins && config.archetype.plugins.length > 0) {
+                    logger_1.logger.info(`Loading plugins specified by archetype: ${config.archetype.plugins.join(', ')}`);
+                    yield this.loadPlugins(config.archetype.plugins).catch(error => {
+                        logger_1.logger.error(error, `Error loading archetype-specified plugins`);
+                        throw error;
+                    });
+                }
                 // Load all RuleConfig for the archetype
                 config.rules = yield (0, ruleUtils_1.loadRules)({
                     archetype,

package/dist/demoConfig/node-fullstack.json

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

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/demoConfig/rules/factDoesNotAddResultToAlmanac-iterative-rule.json

@@ -0,0 +1,33 @@
+{
+    "name": "factDoesNotAddResultToAlmanac-iterative",
+    "conditions": {
+        "all": [
+            {
+                "fact": "fileData",
+                "path": "$.filePath",
+                "operator": "regexMatch",
+                "value": "^.*\\/facts\\/(?!.*\\.test).*\\.ts$"
+            },
+            {
+                "not": {
+                    "fact": "repoFileAnalysis",
+                    "params": {
+                        "checkPattern": [
+                            "almanac\\.addRuntimeFact\\(params\\.resultFact"
+                        ],
+                        "resultFact": "factAlmanacResults"
+                    },
+                    "operator": "fileContains",
+                    "value": true
+                }
+            }
+        ]
+    },
+    "event": {
+        "type": "warning",
+        "params": {
+            "message": "xfi facts should always add results to the almanac so that details can be reported.",
+            "details": "eg. almanac.addRuntimeFact(params.resultFact, result)"
+        }
+    }
+}

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/facts/repoFilesystemFacts.js

@@ -188,5 +188,6 @@ function repoFileAnalysis(params, almanac) {
         almanac.addRuntimeFact(params.resultFact, result);
         return result;
         // testing match on 'oracle'
+        // testing match on 'declare'
     });
 }

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);
+    });
+});