x-fidelity 3.12.0 → 3.13.0

package/CHANGELOG.md

@@ -1,3 +1,36 @@
+# [3.13.0](https://github.com/zotoio/x-fidelity/compare/v3.12.1...v3.13.0) (2025-03-10)
+
+
+### Bug Fixes
+
+* add proper TypeScript types for tree-sitter nodes and imports ([9f9d23f](https://github.com/zotoio/x-fidelity/commit/9f9d23ff8b7a08fae53e3d7512c368d187a71976))
+* correct JavaScript parser language initialization ([9ea4ba0](https://github.com/zotoio/x-fidelity/commit/9ea4ba0077cf69f4fa04f3fa0bff65b6b67974a0))
+* correct TypeScript import declaration for tree-sitter-typescript ([a0c3355](https://github.com/zotoio/x-fidelity/commit/a0c3355bd6774d579ac14c5bf944c89e7a1151db))
+* handle empty array case for maxComplexity calculation ([301e5c3](https://github.com/zotoio/x-fidelity/commit/301e5c3e53e37e0976b81a0f6f1c0c1748c3666c))
+* replace cursor traversal with recursive AST traversal for complexity analysis ([4d54473](https://github.com/zotoio/x-fidelity/commit/4d5447324be6d36cd25b9b752e647ec971ffaf95))
+* resolve maxComplexity variable redeclaration in functionComplexityFact ([0d35ea8](https://github.com/zotoio/x-fidelity/commit/0d35ea82a88bca3b6b5c9d9b8a6456e1ee083af4))
+* Update fact value key from 'ast' to 'astResult' ([e930b53](https://github.com/zotoio/x-fidelity/commit/e930b53d7bbc9414d66906903c0b01a1f2058405))
+* update tree-sitter TypeScript import path and usage ([8bf7ce6](https://github.com/zotoio/x-fidelity/commit/8bf7ce6b34be567216dc331f99b87be67fd5d8f3))
+* update tree-sitter walk API usage to use cursor-based traversal ([f92f2c0](https://github.com/zotoio/x-fidelity/commit/f92f2c0abd14d233d43ec377c4f783bbbae35da5))
+
+
+### Features
+
+* add AST analysis capabilities with function complexity detection ([9d01df0](https://github.com/zotoio/x-fidelity/commit/9d01df0bc3c49e92b6b870c87313a0936704b7b2))
+* add debug logging to AST plugin operations ([cd7ea16](https://github.com/zotoio/x-fidelity/commit/cd7ea16680d4c8d24fea1d14442ed8c3448b159b))
+* add function count rule with AST analysis ([3311d85](https://github.com/zotoio/x-fidelity/commit/3311d8528ff369cac21bee346dce7c2c109208fe))
+* add minimum complexity threshold filter for function analysis ([a67279c](https://github.com/zotoio/x-fidelity/commit/a67279c134d9dbdd711d9782389d6ee8629d929f))
+* add type declarations for tree-sitter-typescript module ([afd1553](https://github.com/zotoio/x-fidelity/commit/afd1553895f33eca6a016e194d70f504d3fb0e03))
+* create AST plugin with facts and operators ([0be5fa5](https://github.com/zotoio/x-fidelity/commit/0be5fa59d76ad2b5fa261545b0c1254ae1441c6c))
+* **plugin:** ast based facts and rule examples ([b734111](https://github.com/zotoio/x-fidelity/commit/b7341118645627967f0adfbe89664c4ffc5752a2))
+
+## [3.12.1](https://github.com/zotoio/x-fidelity/compare/v3.12.0...v3.12.1) (2025-03-10)
+
+
+### Bug Fixes
+
+* **examples:** simple rules to check code evolution ([46547a6](https://github.com/zotoio/x-fidelity/commit/46547a6d5127976178b57010dbc33ad16d0cbdbc))
+
 # [3.12.0](https://github.com/zotoio/x-fidelity/compare/v3.11.0...v3.12.0) (2025-03-10)
 
 

package/dist/demoConfig/node-fullstack.json

@@ -3,37 +3,47 @@
     "rules": [
         "sensitiveLogging-iterative",
         "outdatedFramework-global",
-        "noDatabases-iterative",
+        "noDatabases-iterative", 
         "nonStandardDirectoryStructure-global",
         "openaiAnalysisTop5-global",
         "openaiAnalysisA11y-global",
+        "openaiAnalysisTestCriticality-global",
         "invalidSystemIdConfigured-iterative",
         "missingRequiredFiles-global",
         "factDoesNotAddResultToAlmanac-iterative",
-        "newSdkFeatureNotAdoped-global"
+        "newSdkFeatureNotAdoped-global",
+        "mutuallyExclusivePackages-global",
+        "functionComplexity-iterative",
+        "functionCount-iterative"
     ],
     "operators": [
         "fileContains",
-        "outdatedFramework",
+        "outdatedFramework", 
         "nonStandardDirectoryStructure",
         "openaiAnalysisHighSeverity",
         "invalidRemoteValidation",
         "missingRequiredFiles",
         "regexMatch",
         "globalPatternRatio",
-        "globalPatternCount"
+        "globalPatternCount",
+        "astComplexity",
+        "functionCount"
     ],
     "facts": [
         "repoFilesystemFacts",
         "repoDependencyFacts",
         "openaiAnalysisFacts",
-        "remoteSubstringValidation",
+        "remoteSubstringValidation", 
         "missingRequiredFiles",
-        "globalFileAnalysisFacts"
+        "globalFileAnalysisFacts",
+        "ast",
+        "functionComplexity",
+        "functionCount"
     ],
     "plugins": [
         "xfiPluginRequiredFiles",
-        "xfiPluginRemoteStringValidator"
+        "xfiPluginRemoteStringValidator",
+        "xfiPluginAst"
     ],
     "config": {
         "minimumDependencyVersions": {

package/dist/demoConfig/rules/functionComplexity-iterative-rule.json

@@ -0,0 +1,31 @@
+{
+    "name": "functionComplexity-iterative",
+    "conditions": {
+        "all": [
+            {
+                "fact": "fileData",
+                "path": "$.fileName",
+                "operator": "notEqual",
+                "value": "REPO_GLOBAL_CHECK"
+            },
+            {
+                "fact": "functionComplexity",
+                "params": {
+                    "resultFact": "complexityResult",
+                    "minimumComplexityLogged": 8
+                },
+                "operator": "astComplexity",
+                "value": 10
+            }
+        ]
+    },
+    "event": {
+        "type": "warning",
+        "params": {
+            "message": "Functions detected with high cyclomatic complexity (10+). Consider refactoring.",
+            "details": {
+                "fact": "complexityResult"
+            }
+        }
+    }
+}

package/dist/demoConfig/rules/functionCount-iterative-rule.json

@@ -0,0 +1,30 @@
+{
+    "name": "functionCount-iterative",
+    "conditions": {
+        "all": [
+            {
+                "fact": "fileData",
+                "path": "$.filePath",
+                "operator": "regexMatch",
+                "value": "^.*\\/facts\\/(?!.*\\.test).*\\.ts$"
+            },
+            {
+                "fact": "functionCount",
+                "params": {
+                    "resultFact": "functionCountResult"
+                },
+                "operator": "functionCount",
+                "value": 20
+            }
+        ]
+    },
+    "event": {
+        "type": "warning",
+        "params": {
+            "message": "File contains too many functions (>20). Consider splitting into multiple files.",
+            "details": {
+                "fact": "functionCountResult"
+            }
+        }
+    }
+}

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

@@ -0,0 +1,38 @@
+{                                                                                                                      
+     "name": "mutuallyExclusivePackages-global",                                                                        
+     "conditions": {                                                                                                    
+         "all": [                                                                                                       
+             {                                                                                                          
+                 "fact": "fileData",                                                                                    
+                 "path": "$.fileName",                                                                                  
+                 "operator": "equal",                                                                                   
+                 "value": "REPO_GLOBAL_CHECK"                                                                           
+             },                                                                                                         
+             {                                                                                                          
+                 "fact": "globalFileAnalysis",                                                                          
+                 "params": {                                                                                            
+                     "patterns": [                                                                                      
+                         "import.*from\\s+['\"](@mui/material.*)['\"]",                                              
+                         "import.*from\\s+['\"](antd)['\"]",                                              
+                         "require\\(['\"](@mui/material.*)['\"]\\)",                                                 
+                         "require\\(['\"](antd)['\"]\\)"                                                  
+                     ],                                                                                                 
+                     "fileFilter": "\\.(js|jsx|ts|tsx)$",                                                               
+                     "resultFact": "packageUsageAnalysis"                                                               
+                 },                                                                                                     
+                 "operator": "globalPatternCount",                                                                      
+                 "value": 0                                                                                             
+             }                                                                                                          
+         ]                                                                                                              
+     },                                                                                                                 
+     "event": {                                                                                                         
+         "type": "fatality",                                                                                            
+         "params": {                                                                                                    
+             "message": "Mutually exclusive packages detected. MUI and AntDesign should not be used together.",                                                                                                       
+             "details": {                                                                                               
+                 "fact": "packageUsageAnalysis",                                                                        
+                 "recommendation": "Choose migrate to MUI."                                                                          
+             }                                                                                                          
+         }                                                                                                              
+     }                                                                                                                  
+ }    

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

@@ -12,7 +12,7 @@
                 "fact": "globalFileAnalysis",
                 "params": {
                     "newPatterns": [
-                        "const plugin: XFiPlugin = {"
+                        "const plugin: XFiPlugin.="
                     ],
                     "legacyPatterns": [
                         "import {.*FactDefn.*} from '\\.\\./types/typeDefs';"

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

@@ -0,0 +1,31 @@
+{
+    "name": "openaiAnalysisTestCriticality-global",
+    "conditions": {
+        "all": [
+            {
+                "fact": "fileData",
+                "path": "$.fileName",
+                "operator": "equal",
+                "value": "REPO_GLOBAL_CHECK"
+            },
+            {
+                "fact": "openaiAnalysis",
+                "params": {
+                    "prompt": "what are the files and features in the codebase that are most likely to require unit test uplift in order to be able to trust pull-request checks?",
+                    "resultFact": "openaiAnalysisTestCriticality"
+                },
+                "operator": "openaiAnalysisHighSeverity",
+                "value": 8
+            }
+        ]
+    },
+    "event": {
+        "type": "warning",
+        "params": {
+            "message": "OpenAI suggestions for the supplied prompt.",
+            "details": {
+                "fact": "openaiAnalysisTestCriticality"
+            }
+        }
+    }
+}

package/dist/facts/globalFileAnalysisFacts.js

@@ -60,7 +60,7 @@ exports.globalFileAnalysis = {
                             fileMatches++;
                             matchDetails.push({
                                 lineNumber: i + 1,
-                                match: match[0],
+                                match: pattern,
                                 context: (0, maskSensitiveData_1.maskSensitiveData)(line.trim())
                             });
                         }

package/dist/facts/openaiAnalysisFacts.js

@@ -24,7 +24,7 @@ if ((0, openaiUtils_1.isOpenAIEnabled)()) {
 const openaiAnalysis = function (params, almanac) {
     return __awaiter(this, void 0, void 0, function* () {
         let result = { 'result': [] };
-        const model = process.env.OPENAI_MODEL || 'o3-mini';
+        const model = process.env.OPENAI_MODEL || 'gpt-4o';
         try {
             if (!openai) {
                 throw new Error('OpenAI client is not initialized');
@@ -40,7 +40,7 @@ const openaiAnalysis = function (params, almanac) {
             };
             const payload = {
                 model,
-                reasoning_effort: 'high',
+                //reasoning_effort: 'high',
                 messages: [
                     { role: 'system', content: openaiSystemPrompt },
                     { role: 'user', content: `${params.prompt} 

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

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

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

@@ -0,0 +1,33 @@
+"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.astFact = void 0;
+const logger_1 = require("../../../utils/logger");
+const astUtils_1 = require("../../../utils/astUtils");
+exports.astFact = {
+    name: 'ast',
+    fn: (params, almanac) => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            const fileData = yield almanac.factValue('fileData');
+            const result = (0, astUtils_1.generateAst)(fileData);
+            // Add the AST to the almanac for other facts/operators to use
+            if (params === null || params === void 0 ? void 0 : params.resultFact) {
+                logger_1.logger.trace({ resultFact: params.resultFact }, 'Adding AST to almanac');
+                almanac.addRuntimeFact(params.resultFact, result);
+            }
+            return result;
+        }
+        catch (error) {
+            logger_1.logger.error(`Error in AST fact: ${error}`);
+            return { tree: null };
+        }
+    })
+};

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

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

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

@@ -0,0 +1,136 @@
+"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.functionComplexityFact = void 0;
+const logger_1 = require("../../../utils/logger");
+const astUtils_1 = require("../../../utils/astUtils");
+exports.functionComplexityFact = {
+    name: 'functionComplexity',
+    fn: (params, almanac) => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            const fileData = yield almanac.factValue('fileData');
+            const { tree } = (0, astUtils_1.generateAst)(fileData);
+            if (!tree) {
+                logger_1.logger.debug('No AST available for complexity analysis');
+                return { complexity: 0 };
+            }
+            const complexities = [];
+            logger_1.logger.debug('Starting function complexity analysis');
+            // Visit each function declaration/expression
+            // Traverse the AST to find all function nodes
+            const functionNodes = [];
+            function visit(node) {
+                if (node.type === 'function_declaration' ||
+                    node.type === 'function_expression' ||
+                    node.type === 'arrow_function') {
+                    functionNodes.push(node);
+                }
+                for (let child of node.children || []) {
+                    visit(child);
+                }
+            }
+            visit(tree.rootNode);
+            // Get minimum complexity threshold from params
+            const minimumComplexityLogged = (params === null || params === void 0 ? void 0 : params.minimumComplexityLogged) || 0;
+            // Analyze each function node
+            for (const node of functionNodes) {
+                const name = getFunctionName(node);
+                const complexity = analyzeFunctionComplexity(node);
+                // Only include functions that exceed the minimum complexity threshold
+                if (complexity >= minimumComplexityLogged) {
+                    logger_1.logger.debug({
+                        functionName: name,
+                        nodeType: node.type,
+                        complexity,
+                        startLine: node.startPosition.row + 1,
+                        endLine: node.endPosition.row + 1,
+                        threshold: minimumComplexityLogged
+                    }, 'Function exceeds complexity threshold');
+                    complexities.push({
+                        name,
+                        complexity,
+                        location: {
+                            start: node.startPosition,
+                            end: node.endPosition
+                        }
+                    });
+                }
+                else {
+                    logger_1.logger.debug({
+                        functionName: name,
+                        complexity,
+                        threshold: minimumComplexityLogged
+                    }, 'Function below complexity threshold - skipping');
+                }
+            }
+            // Calculate max complexity from values
+            const complexityValues = complexities.map(c => c.complexity);
+            const maxComplexity = complexityValues.length > 0 ? Math.max(...complexityValues) : 0;
+            logger_1.logger.debug({
+                functionCount: complexities.length,
+                maxComplexity,
+                complexityBreakdown: complexities.map(c => ({
+                    name: c.name,
+                    complexity: c.complexity
+                }))
+            }, 'Completed complexity analysis');
+            const result = {
+                complexities,
+                maxComplexity
+            };
+            if (params === null || params === void 0 ? void 0 : params.resultFact) {
+                logger_1.logger.debug({ resultFact: params.resultFact }, 'Adding complexity results to almanac');
+                almanac.addRuntimeFact(params.resultFact, result);
+            }
+            return result;
+        }
+        catch (error) {
+            logger_1.logger.error(`Error analyzing function complexity: ${error}`);
+            return { complexities: [], maxComplexity: 0 };
+        }
+    })
+};
+function analyzeFunctionComplexity(node) {
+    let complexity = 1; // Base complexity
+    // Walk the AST and count:
+    // - Conditional statements (if, else, switch cases)
+    // - Loops (for, while, do-while)
+    // - Logical operators (&&, ||)
+    // - Try/catch blocks
+    function visit(node) {
+        switch (node.type) {
+            case 'if_statement':
+            case 'switch_case':
+            case 'for_statement':
+            case 'while_statement':
+            case 'do_statement':
+            case 'try_statement':
+                complexity++;
+                break;
+            case '&&':
+            case '||':
+                complexity += 0.5;
+                break;
+        }
+        for (let child of node.children || []) {
+            visit(child);
+        }
+    }
+    visit(node);
+    return complexity;
+}
+function getFunctionName(node) {
+    if (node.type === 'function_declaration') {
+        const nameNode = node.descendantsOfType('identifier')[0];
+        return nameNode ? nameNode.text : 'anonymous';
+    }
+    return 'anonymous';
+}

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

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

package/dist/plugins/xfiPluginAst/facts/functionCountFact.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 });
+exports.functionCountFact = void 0;
+const logger_1 = require("../../../utils/logger");
+const astUtils_1 = require("../../../utils/astUtils");
+exports.functionCountFact = {
+    name: 'functionCount',
+    fn: (params, almanac) => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            const fileData = yield almanac.factValue('fileData');
+            const { tree } = (0, astUtils_1.generateAst)(fileData);
+            if (!tree) {
+                logger_1.logger.debug('No AST available for function count analysis');
+                return { count: 0 };
+            }
+            // Find all function nodes
+            const functionNodes = [];
+            function visit(node) {
+                if (node.type === 'function_declaration' ||
+                    node.type === 'function_expression' ||
+                    node.type === 'arrow_function') {
+                    functionNodes.push(node);
+                }
+                for (let child of node.children || []) {
+                    visit(child);
+                }
+            }
+            visit(tree.rootNode);
+            const result = {
+                count: functionNodes.length,
+                functions: functionNodes.map(node => {
+                    var _a;
+                    return ({
+                        name: node.type === 'function_declaration' ?
+                            (((_a = node.descendantsOfType('identifier')[0]) === null || _a === void 0 ? void 0 : _a.text) || 'anonymous') :
+                            'anonymous',
+                        location: {
+                            start: node.startPosition,
+                            end: node.endPosition
+                        }
+                    });
+                })
+            };
+            logger_1.logger.debug({
+                filePath: fileData.filePath,
+                functionCount: result.count,
+                functions: result.functions
+            }, 'Completed function count analysis');
+            // Add result to almanac if resultFact param provided
+            if (params === null || params === void 0 ? void 0 : params.resultFact) {
+                almanac.addRuntimeFact(params.resultFact, result);
+            }
+            return result;
+        }
+        catch (error) {
+            logger_1.logger.error(`Error in function count analysis: ${error}`);
+            return { count: 0, functions: [] };
+        }
+    })
+};

package/dist/plugins/xfiPluginAst/index.d.ts

@@ -0,0 +1 @@
+export { plugin } from './xfiPluginAst';

package/dist/plugins/xfiPluginAst/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.plugin = void 0;
+var xfiPluginAst_1 = require("./xfiPluginAst");
+Object.defineProperty(exports, "plugin", { enumerable: true, get: function () { return xfiPluginAst_1.plugin; } });

package/dist/plugins/xfiPluginAst/operators/astComplexity.d.ts

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

package/dist/plugins/xfiPluginAst/operators/astComplexity.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.astComplexity = void 0;
+const logger_1 = require("../../../utils/logger");
+exports.astComplexity = {
+    name: 'astComplexity',
+    fn: (factValue, threshold) => {
+        var _a;
+        try {
+            logger_1.logger.debug({ threshold }, 'Checking AST complexity against threshold');
+            if (!factValue || !factValue.maxComplexity) {
+                logger_1.logger.debug('No complexity data available');
+                return false;
+            }
+            const result = factValue.maxComplexity >= threshold;
+            logger_1.logger.trace({
+                maxComplexity: factValue.maxComplexity,
+                threshold,
+                exceedsThreshold: result,
+                complexityDetails: (_a = factValue.complexities) === null || _a === void 0 ? void 0 : _a.map((c) => ({
+                    name: c.name,
+                    complexity: c.complexity,
+                    exceedsThreshold: c.complexity >= threshold
+                }))
+            }, 'Completed complexity threshold check');
+            return result;
+        }
+        catch (error) {
+            logger_1.logger.error(`Error in astComplexity operator: ${error}`);
+            return false;
+        }
+    }
+};

package/dist/plugins/xfiPluginAst/operators/functionCount.d.ts

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

package/dist/plugins/xfiPluginAst/operators/functionCount.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.functionCount = void 0;
+const logger_1 = require("../../../utils/logger");
+exports.functionCount = {
+    name: 'functionCount',
+    fn: (factValue, threshold) => {
+        try {
+            logger_1.logger.debug({ threshold }, 'Checking function count against threshold');
+            if (!factValue || typeof factValue.count !== 'number') {
+                logger_1.logger.debug('No valid function count data available');
+                return false;
+            }
+            const result = factValue.count > threshold;
+            logger_1.logger.debug({
+                count: factValue.count,
+                threshold,
+                exceedsThreshold: result,
+                functions: factValue.functions
+            }, 'Completed function count threshold check');
+            return result;
+        }
+        catch (error) {
+            logger_1.logger.error(`Error in functionCount operator: ${error}`);
+            return false;
+        }
+    }
+};

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

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

package/dist/plugins/xfiPluginAst/xfiPluginAst.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.plugin = void 0;
+const astFact_1 = require("./facts/astFact");
+const functionComplexityFact_1 = require("./facts/functionComplexityFact");
+const functionCountFact_1 = require("./facts/functionCountFact");
+const astComplexity_1 = require("./operators/astComplexity");
+const functionCount_1 = require("./operators/functionCount");
+const plugin = {
+    name: 'xfiPluginAst',
+    version: '1.0.0',
+    facts: [astFact_1.astFact, functionComplexityFact_1.functionComplexityFact, functionCountFact_1.functionCountFact],
+    operators: [astComplexity_1.astComplexity, functionCount_1.functionCount],
+    onError: (error) => ({
+        message: `AST analysis error: ${error.message}`,
+        level: 'warning',
+        details: error.stack
+    })
+};
+exports.plugin = plugin;

package/dist/utils/astUtils.d.ts

@@ -0,0 +1,7 @@
+import Parser from 'tree-sitter';
+import { FileData } from '../types/typeDefs';
+export declare function generateAst(fileData: FileData): {
+    tree: null;
+} | {
+    tree: Parser.Tree;
+};