x-fidelity 3.3.1 → 3.4.0

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+# [3.4.0](https://github.com/zotoio/x-fidelity/compare/v3.3.1...v3.4.0) (2025-02-26)
+
+
+### Bug Fixes
+
+* add support for all modern regex flags in pattern matching ([847a320](https://github.com/zotoio/x-fidelity/commit/847a32068b68db66c1a9d84090bae4bc918f36d0))
+* correct regex test case to use case-insensitive flag ([96d906c](https://github.com/zotoio/x-fidelity/commit/96d906c23833f482d649df866ca36f28f609bbd6))
+
+
+### Features
+
+* add regex pattern matching operator with tests ([8ac216f](https://github.com/zotoio/x-fidelity/commit/8ac216f222a28367eba971f0f187fad4173167b3))
+* **operators:** add regexMatch general purpose operator ([8270696](https://github.com/zotoio/x-fidelity/commit/82706966e9a52c089848f785007f415e614b67da))
+
 ## [3.3.1](https://github.com/zotoio/x-fidelity/compare/v3.3.0...v3.3.1) (2025-02-26)
 
 

package/dist/demoConfig/node-fullstack.json

@@ -8,7 +8,8 @@
         "openaiAnalysisTop5-global",
         "openaiAnalysisA11y-global",
         "invalidSystemIdConfigured-iterative",
-        "missingRequiredFiles-global"
+        "missingRequiredFiles-global",
+        "regexMatch-example-iterative"
     ],
     "operators": [
         "fileContains",
@@ -16,7 +17,8 @@
         "nonStandardDirectoryStructure",
         "openaiAnalysisHighSeverity",
         "invalidRemoteValidation",
-        "missingRequiredFiles"
+        "missingRequiredFiles",
+        "regexMatch"
     ],
     "facts": [
         "repoFilesystemFacts",

package/dist/demoConfig/rules/regexMatch-example-iterative-rule.json

@@ -0,0 +1,28 @@
+{
+    "name": "regexMatch-example",
+    "conditions": {
+        "all": [
+            {
+                "fact": "fileData",
+                "path": "$.filePath",
+                "operator": "regexMatch",
+                "value": ".*/facts/.*"
+            },
+            {
+                "fact": "fileData",
+                "path": "$.fileContent",
+                "operator": "regexMatch",
+                "value": "OpenAI"
+            }
+        ]
+    },
+    "event": {
+        "type": "warning",
+        "params": {
+            "message": "I'm seeing a pattern here..",
+            "details": {
+                "suggestion": "wake up and smell the coffee"
+            }
+        }
+    }
+}

package/dist/operators/index.js

@@ -14,6 +14,7 @@ const outdatedFramework_1 = require("./outdatedFramework");
 const fileContains_1 = require("./fileContains");
 const nonStandardDirectoryStructure_1 = require("./nonStandardDirectoryStructure");
 const openaiAnalysisHighSeverity_1 = require("./openaiAnalysisHighSeverity");
+const regexMatch_1 = require("./regexMatch");
 const openaiUtils_1 = require("../utils/openaiUtils");
 const logger_1 = require("../utils/logger");
 const pluginRegistry_1 = require("../core/pluginRegistry");
@@ -23,7 +24,8 @@ function loadOperators(operatorNames) {
         const allAvailableOperators = Object.assign({ outdatedFramework: outdatedFramework_1.outdatedFramework,
             fileContains: fileContains_1.fileContains,
             nonStandardDirectoryStructure: nonStandardDirectoryStructure_1.nonStandardDirectoryStructure,
-            openaiAnalysisHighSeverity: openaiAnalysisHighSeverity_1.openaiAnalysisHighSeverity }, Object.fromEntries(pluginRegistry_1.pluginRegistry.getPluginOperators().map(op => [op.name, op])));
+            openaiAnalysisHighSeverity: openaiAnalysisHighSeverity_1.openaiAnalysisHighSeverity,
+            regexMatch: regexMatch_1.regexMatch }, 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/dist/operators/regexMatch.d.ts

@@ -0,0 +1,10 @@
+import { OperatorDefn } from '../types/typeDefs';
+/**
+ * Operator that tests if a string matches a regular expression pattern
+ *
+ * @param factValue - The string to test against the regex pattern
+ * @param regexPattern - The regex pattern to test against (as a string)
+ * @returns true if the string matches the pattern, false otherwise
+ */
+declare const regexMatch: OperatorDefn;
+export { regexMatch };

package/dist/operators/regexMatch.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.regexMatch = void 0;
+const logger_1 = require("../utils/logger");
+/**
+ * Operator that tests if a string matches a regular expression pattern
+ *
+ * @param factValue - The string to test against the regex pattern
+ * @param regexPattern - The regex pattern to test against (as a string)
+ * @returns true if the string matches the pattern, false otherwise
+ */
+const regexMatch = {
+    'name': 'regexMatch',
+    'fn': (factValue, regexPattern) => {
+        try {
+            logger_1.logger.debug(`regexMatch: testing ${factValue} against pattern ${regexPattern}`);
+            if (factValue === undefined || factValue === null) {
+                logger_1.logger.debug('regexMatch: factValue is undefined or null');
+                return false;
+            }
+            if (typeof regexPattern !== 'string') {
+                logger_1.logger.debug(`regexMatch: regexPattern is not a string: ${typeof regexPattern}`);
+                return false;
+            }
+            // Extract flags if they exist (pattern/flags format)
+            let flags = '';
+            let pattern = regexPattern;
+            // Check if the pattern is in /pattern/flags format
+            const regexFormatMatch = /^\/(.+)\/([gimsuyd]*)$/.exec(regexPattern);
+            if (regexFormatMatch) {
+                pattern = regexFormatMatch[1];
+                flags = regexFormatMatch[2];
+                logger_1.logger.debug(`regexMatch: extracted pattern "${pattern}" with flags "${flags}"`);
+            }
+            const regex = new RegExp(pattern, flags);
+            const result = regex.test(String(factValue));
+            logger_1.logger.debug(`regexMatch: result is ${result}`);
+            return result;
+        }
+        catch (e) {
+            logger_1.logger.error(`regexMatch error: ${e}`);
+            return false;
+        }
+    }
+};
+exports.regexMatch = regexMatch;

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

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

package/dist/operators/regexMatch.test.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const regexMatch_1 = require("./regexMatch");
+const logger_1 = require("../utils/logger");
+jest.mock('../utils/logger', () => ({
+    logger: {
+        debug: jest.fn(),
+        error: jest.fn()
+    },
+}));
+describe('regexMatch', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it('should return true when the string matches the pattern', () => {
+        expect(regexMatch_1.regexMatch.fn('hello world', 'hello')).toBe(true);
+        expect(regexMatch_1.regexMatch.fn('hello world', 'world$')).toBe(true);
+        expect(regexMatch_1.regexMatch.fn('hello world', '^hello')).toBe(true);
+        expect(logger_1.logger.debug).toHaveBeenCalledWith(expect.stringContaining('result is true'));
+    });
+    it('should return false when the string does not match the pattern', () => {
+        expect(regexMatch_1.regexMatch.fn('hello world', 'goodbye')).toBe(false);
+        expect(regexMatch_1.regexMatch.fn('hello world', '^world')).toBe(false);
+        expect(regexMatch_1.regexMatch.fn('hello world', 'hello$')).toBe(false);
+        expect(logger_1.logger.debug).toHaveBeenCalledWith(expect.stringContaining('result is false'));
+    });
+    it('should handle regex flags correctly', () => {
+        expect(regexMatch_1.regexMatch.fn('Hello World', '/hello/i')).toBe(true);
+        expect(regexMatch_1.regexMatch.fn('Hello\nWorld', '/hello.*world/is')).toBe(true);
+        expect(regexMatch_1.regexMatch.fn('Hello World', '/hello world/i')).toBe(true);
+    });
+    it('should handle undefined or null factValue', () => {
+        expect(regexMatch_1.regexMatch.fn(undefined, 'test')).toBe(false);
+        expect(regexMatch_1.regexMatch.fn(null, 'test')).toBe(false);
+        expect(logger_1.logger.debug).toHaveBeenCalledWith('regexMatch: factValue is undefined or null');
+    });
+    it('should handle non-string regexPattern', () => {
+        expect(regexMatch_1.regexMatch.fn('test', null)).toBe(false);
+        expect(regexMatch_1.regexMatch.fn('test', undefined)).toBe(false);
+        expect(regexMatch_1.regexMatch.fn('test', 123)).toBe(false);
+        expect(logger_1.logger.debug).toHaveBeenCalledWith(expect.stringContaining('regexPattern is not a string'));
+    });
+    it('should handle invalid regex patterns gracefully', () => {
+        expect(regexMatch_1.regexMatch.fn('test', '[')).toBe(false);
+        expect(logger_1.logger.error).toHaveBeenCalledWith(expect.stringContaining('regexMatch error'));
+    });
+    it('should handle non-string factValues by converting them to strings', () => {
+        expect(regexMatch_1.regexMatch.fn(123, '123')).toBe(true);
+        expect(regexMatch_1.regexMatch.fn(true, 'true')).toBe(true);
+        expect(regexMatch_1.regexMatch.fn({ toString: () => 'custom' }, 'custom')).toBe(true);
+    });
+});

package/package.json

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

package/src/demoConfig/node-fullstack.json

@@ -8,7 +8,8 @@
         "openaiAnalysisTop5-global",
         "openaiAnalysisA11y-global",
         "invalidSystemIdConfigured-iterative",
-        "missingRequiredFiles-global"
+        "missingRequiredFiles-global",
+        "regexMatch-example-iterative"
     ],
     "operators": [
         "fileContains",
@@ -16,7 +17,8 @@
         "nonStandardDirectoryStructure",
         "openaiAnalysisHighSeverity",
         "invalidRemoteValidation",
-        "missingRequiredFiles"
+        "missingRequiredFiles",
+        "regexMatch"
     ],
     "facts": [
         "repoFilesystemFacts",

package/src/demoConfig/rules/regexMatch-example-iterative-rule.json

@@ -0,0 +1,28 @@
+{
+    "name": "regexMatch-example",
+    "conditions": {
+        "all": [
+            {
+                "fact": "fileData",
+                "path": "$.filePath",
+                "operator": "regexMatch",
+                "value": ".*/facts/.*"
+            },
+            {
+                "fact": "fileData",
+                "path": "$.fileContent",
+                "operator": "regexMatch",
+                "value": "OpenAI"
+            }
+        ]
+    },
+    "event": {
+        "type": "warning",
+        "params": {
+            "message": "I'm seeing a pattern here..",
+            "details": {
+                "suggestion": "wake up and smell the coffee"
+            }
+        }
+    }
+}

package/src/operators/index.ts

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

package/src/operators/regexMatch.test.ts

@@ -0,0 +1,59 @@
+import { regexMatch } from './regexMatch';
+import { logger } from '../utils/logger';
+
+jest.mock('../utils/logger', () => ({
+    logger: {
+        debug: jest.fn(),
+        error: jest.fn()
+    },
+}));
+
+describe('regexMatch', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+
+    it('should return true when the string matches the pattern', () => {
+        expect(regexMatch.fn('hello world', 'hello')).toBe(true);
+        expect(regexMatch.fn('hello world', 'world$')).toBe(true);
+        expect(regexMatch.fn('hello world', '^hello')).toBe(true);
+        expect(logger.debug).toHaveBeenCalledWith(expect.stringContaining('result is true'));
+    });
+
+    it('should return false when the string does not match the pattern', () => {
+        expect(regexMatch.fn('hello world', 'goodbye')).toBe(false);
+        expect(regexMatch.fn('hello world', '^world')).toBe(false);
+        expect(regexMatch.fn('hello world', 'hello$')).toBe(false);
+        expect(logger.debug).toHaveBeenCalledWith(expect.stringContaining('result is false'));
+    });
+
+    it('should handle regex flags correctly', () => {
+        expect(regexMatch.fn('Hello World', '/hello/i')).toBe(true);
+        expect(regexMatch.fn('Hello\nWorld', '/hello.*world/is')).toBe(true);
+        expect(regexMatch.fn('Hello World', '/hello world/i')).toBe(true);
+    });
+
+    it('should handle undefined or null factValue', () => {
+        expect(regexMatch.fn(undefined, 'test')).toBe(false);
+        expect(regexMatch.fn(null, 'test')).toBe(false);
+        expect(logger.debug).toHaveBeenCalledWith('regexMatch: factValue is undefined or null');
+    });
+
+    it('should handle non-string regexPattern', () => {
+        expect(regexMatch.fn('test', null as any)).toBe(false);
+        expect(regexMatch.fn('test', undefined as any)).toBe(false);
+        expect(regexMatch.fn('test', 123 as any)).toBe(false);
+        expect(logger.debug).toHaveBeenCalledWith(expect.stringContaining('regexPattern is not a string'));
+    });
+
+    it('should handle invalid regex patterns gracefully', () => {
+        expect(regexMatch.fn('test', '[')).toBe(false);
+        expect(logger.error).toHaveBeenCalledWith(expect.stringContaining('regexMatch error'));
+    });
+
+    it('should handle non-string factValues by converting them to strings', () => {
+        expect(regexMatch.fn(123, '123')).toBe(true);
+        expect(regexMatch.fn(true, 'true')).toBe(true);
+        expect(regexMatch.fn({ toString: () => 'custom' }, 'custom')).toBe(true);
+    });
+});

package/src/operators/regexMatch.ts

@@ -0,0 +1,51 @@
+import { logger } from '../utils/logger';
+import { OperatorDefn } from '../types/typeDefs';
+
+/**
+ * Operator that tests if a string matches a regular expression pattern
+ * 
+ * @param factValue - The string to test against the regex pattern
+ * @param regexPattern - The regex pattern to test against (as a string)
+ * @returns true if the string matches the pattern, false otherwise
+ */
+const regexMatch: OperatorDefn = {
+    'name': 'regexMatch',
+    'fn': (factValue: any, regexPattern: string) => {
+        try {
+            logger.debug(`regexMatch: testing ${factValue} against pattern ${regexPattern}`);
+            
+            if (factValue === undefined || factValue === null) {
+                logger.debug('regexMatch: factValue is undefined or null');
+                return false;
+            }
+
+            if (typeof regexPattern !== 'string') {
+                logger.debug(`regexMatch: regexPattern is not a string: ${typeof regexPattern}`);
+                return false;
+            }
+
+            // Extract flags if they exist (pattern/flags format)
+            let flags = '';
+            let pattern = regexPattern;
+            
+            // Check if the pattern is in /pattern/flags format
+            const regexFormatMatch = /^\/(.+)\/([gimsuyd]*)$/.exec(regexPattern);
+            if (regexFormatMatch) {
+                pattern = regexFormatMatch[1];
+                flags = regexFormatMatch[2];
+                logger.debug(`regexMatch: extracted pattern "${pattern}" with flags "${flags}"`);
+            }
+
+            const regex = new RegExp(pattern, flags);
+            const result = regex.test(String(factValue));
+            
+            logger.debug(`regexMatch: result is ${result}`);
+            return result;
+        } catch (e) {
+            logger.error(`regexMatch error: ${e}`);
+            return false;
+        }
+    }
+};
+
+export { regexMatch };