x-fidelity 1.17.0 → 2.0.0

package/CHANGELOG.md

@@ -1,3 +1,55 @@
+# [2.0.0](https://github.com/zotoio/x-fidelity/compare/v1.17.0...v2.0.0) (2024-08-17)
+
+
+### Bug Fixes
+
+* Add additional logging to configManager.ts ([bab63c1](https://github.com/zotoio/x-fidelity/commit/bab63c13a714d6d69440380c886a227b388baa41))
+* Add missing properties to ResultMetadata in engineSetup.ts ([1c2d276](https://github.com/zotoio/x-fidelity/commit/1c2d276512a4958b5ae75cec44df00e36551bccc))
+* Add missing properties to ResultMetadata interface ([eb2b71f](https://github.com/zotoio/x-fidelity/commit/eb2b71f375f7d0f8615213f693704e91f8a610f0))
+* Add missing properties to telemetry metadata ([30fefbc](https://github.com/zotoio/x-fidelity/commit/30fefbc3709bb1d13a3624d2e4d66c6b6f78e7a7))
+* Correct the typo in the GPT-4 model name ([438c772](https://github.com/zotoio/x-fidelity/commit/438c77288fe58441adc7956b4ba64db445e7d82f))
+* Fix TypeScript errors in src/index.ts ([30fc784](https://github.com/zotoio/x-fidelity/commit/30fc784580763d956c75003c965821e646bf716d))
+* Fix TypeScript errors in test files ([25af375](https://github.com/zotoio/x-fidelity/commit/25af3759ff321a91d4e0f6a90531a384888c7a39))
+* handle network error in loadRules test ([05a26e6](https://github.com/zotoio/x-fidelity/commit/05a26e634b2a6b43ec860e01ad74caf26dc924db))
+* Import fs module in telemetryCollector.test.ts ([64245d9](https://github.com/zotoio/x-fidelity/commit/64245d90786a3be99a255b5d240afc6dd4737c81))
+* Improve error handling in ConfigManager ([d1bb512](https://github.com/zotoio/x-fidelity/commit/d1bb5127a3e0bac630d613afced3fdf849b8b211))
+* refactor `src/core/engine.test.ts` into separate test files ([4055f8f](https://github.com/zotoio/x-fidelity/commit/4055f8f3179d44862fd779d8bb09022cb4d946b9))
+* Refactor analyzeCodebase function to return ResultMetadata ([81d1936](https://github.com/zotoio/x-fidelity/commit/81d1936618ac2abd0a85718c2f1f0b910fb8b910))
+* Remove expectation of `mockLogPrefix` in `loadRules` calls ([7b8669e](https://github.com/zotoio/x-fidelity/commit/7b8669e864150123e02ba025f73652a82898c723))
+* Remove unused import and update metadata object ([ff4bfc0](https://github.com/zotoio/x-fidelity/commit/ff4bfc0ad0ed13bc3c919722c34de81160e486fa))
+* Update event handling in engineSetup.ts ([73e5358](https://github.com/zotoio/x-fidelity/commit/73e53583b82fab78b72f48c8daa14da41fe244bf))
+* Update import path for ConfigManager ([e87f101](https://github.com/zotoio/x-fidelity/commit/e87f10135d9afddd43ac145c6308ca1fd70d3fd7))
+* Update import path for ConfigManager ([6a6b05a](https://github.com/zotoio/x-fidelity/commit/6a6b05af2dc9e217ae53d5f315116ffd565a2fad))
+* Update ResultMetadata interface ([b95fab7](https://github.com/zotoio/x-fidelity/commit/b95fab7731d8040913b7fbd832b1589a31acef0b))
+* Update telemetryCollector.test.ts to use mocked fs functions ([29d435d](https://github.com/zotoio/x-fidelity/commit/29d435dd24fc4cc01c07d2eecbebb43339474005))
+* Update test case for loadRules function ([5b6278d](https://github.com/zotoio/x-fidelity/commit/5b6278d6323c576ac1b980f41cef78f683b3ae5d))
+* Update test case to expect resolved value instead of rejection ([580108a](https://github.com/zotoio/x-fidelity/commit/580108ae927c00f17673f82125718ca8c4205493))
+* Update test expectation for `analyzeCodebase` results ([bdafd3f](https://github.com/zotoio/x-fidelity/commit/bdafd3f3eaf5a70315e323dd9dfe2af1f82908be))
+* Update test expectations for addOperator and addFact ([c86a33a](https://github.com/zotoio/x-fidelity/commit/c86a33a9042f234c5a934d0ff555af438ebaff1f))
+* Update test expectations to match actual results structure ([3398a84](https://github.com/zotoio/x-fidelity/commit/3398a8433e5a543084c1dcaaf69dd910fae6d297))
+* Update tests to expect new ResultMetadata structure ([fc16223](https://github.com/zotoio/x-fidelity/commit/fc162232c976f6638228a2e450a793ea7d087bb4))
+
+
+### Features
+
+* Add BasicTelemetryMetadata interface ([be87308](https://github.com/zotoio/x-fidelity/commit/be873084164d592822193cad70badeedd2fa17de))
+* Add details on creating custom OpenAI rules ([80abb24](https://github.com/zotoio/x-fidelity/commit/80abb24652565bce89ce61bba16dc4de8c0f5654))
+* add interface for the result of collectTelemetryData ([ea6089a](https://github.com/zotoio/x-fidelity/commit/ea6089a2a35b6445550adde1aa5c63ac1a701dc9))
+* Add new CLI options and examples ([fab7b81](https://github.com/zotoio/x-fidelity/commit/fab7b81db053bcf144fb104b0bba82ff7679ab57))
+* Add ResultMetadata interface ([08c3fe2](https://github.com/zotoio/x-fidelity/commit/08c3fe2f20bfac98ddb173ac482fb8f09a661780))
+* Add telemetry reporting and improve error handling ([ac16e44](https://github.com/zotoio/x-fidelity/commit/ac16e4400197b59fa40384b3802f40dfe9bc5941))
+* Expand OpenAI Integration section in README.md ([c4e34e7](https://github.com/zotoio/x-fidelity/commit/c4e34e7626c264b3972bfc28eaaff172bbba6295))
+* Implement ConfigManager class to manage application configuration ([6836652](https://github.com/zotoio/x-fidelity/commit/6836652ce82791eaa85ddc1eb5a27d63dbaf9b4a))
+* Refactor codebase analysis and reporting ([7f7d30e](https://github.com/zotoio/x-fidelity/commit/7f7d30e607bde3d29a68c4fcf42ecd0779029b24))
+* Refactor ResultMetadata interface ([7d9ddf2](https://github.com/zotoio/x-fidelity/commit/7d9ddf2457b5d3d0981f66dcf07cd4ec03e79554))
+* **system:** fixes, refactor, optimisations ([4da8c9f](https://github.com/zotoio/x-fidelity/commit/4da8c9f0d0dbc8b151ee01b21dfaab150ee02dfe))
+* Update README with callout for OpenAI rule naming convention ([103a470](https://github.com/zotoio/x-fidelity/commit/103a4704213f417f30be0936965ae2d90b29ee75))
+
+
+### BREAKING CHANGES
+
+* **system:** some of the contract for cli has changed, and output interfaces updated
+
 # [1.17.0](https://github.com/zotoio/x-fidelity/compare/v1.16.1...v1.17.0) (2024-08-16)
 
 

package/README.md

@@ -23,13 +23,15 @@ x-fidelity is an advanced CLI tool and paired config server designed to perform
    yarn global add x-fidelity
    export PATH="$PATH:$(yarn global bin)"
    ```
-
-2. Run in your project directory:
+2. Run cli without parameters to view help
    ```
    xfidelity
    ```
-
-3. For more options:
+3. Execute in current project directory with built-in demo rules for node-fullstack:
+   ```
+   xfidelity .
+   ```
+4. For more options:
    ```
    xfidelity --help
    ```
@@ -163,35 +165,62 @@ xfidelity
 Use command-line options for more control:
 
 ```sh
-xfidelity [-d --dir <directory>] [-c --configServer <url>] [-a --archetype <archetype>] [-m --mode <cli|server>] [-p --port <port>] [-o --openaiEnabled <boolean>] [-t --telemetryCollector <url>] [-l --localConfig <path>]
+Usage: x-fidelity [options] [directory]
+
+Arguments:
+  directory                                      code directory to analyze
+
+Options:
+  -d, --dir <directory>                          code directory to analyze. if an arg was passed to command it
+                                                 will be treated as the dir (default: ".")
+  -a, --archetype <archetype>                    The archetype to use for analysis (default: "node-fullstack")
+  -c, --configServer <configServer>              The config server URL for fetching remote archetype
+                                                 configurations and rules
+  -o, --openaiEnabled <boolean>                  Enable OpenAI analysis (default: false)
+  -t, --telemetryCollector <telemetryCollector>  The URL telemetry data will be sent to for usage analysis
+  -m, --mode <mode>                              Run mode: 'client' or 'server' (default: "client")
+  -p, --port <port>                              The port to run the server on (default: "8888")
+  -l, --localConfigPath <path>                   Path to local archetype config and rules
+  -j, --jsonTTL <minutes>                        Set the server json cache TTL in minutes (default: "10")
+  -v, --version                                  Output the version number of xfidelity
+  -h, --help                                     Display help for command
 ```
 
-- `-d --dir <directory>`: Specify the root directory to analyze (default: current directory)
-- `-c --configServer <url>`: URL to fetch the configuration from. eg. https://localhost:8888
-- `-a --archetype <archetype>`: Archetype to use for analysis (default: 'node-fullstack')
-- `-m --mode <mode>`: Run mode: 'client' or 'server' (default: 'client')
-- `-p --port <port>`: Port number for server mode (default: 8888)
-- `-o --openaiEnabled <boolean>`: Enable OpenAI analysis (default: false)
-- `-t --telemetryCollector <url>`: The URL telemetry data will be sent to for usage analysis
-- `-l --localConfigPath <path>`: Path to local archetype config and rules
-- `-j --jsonTTL <minutes>` : The server json cache TTL in minutes (default: 10)
-
 Examples:
 
 ```sh
-# Use remote config server
-xfidelity --configServer https://localhost:8888
+# Run client to analyse current dir using config from remote config server
+xfidelity --configServer http://localhost:8888
 
-# Analyze parent directory with java-microservice archetype and enable OpenAI analysis
-xfidelity -d .. -a java-microservice -c https://localhost:8888 -o true
+# Analyze a specific directory with java-microservice archetype config from remote config server and enable OpenAI analysis
+xfidelity /home/projects/my-codebase -a java-microservice -c https://localhost:8888 -o true
 
-#Run in server mode with custom port and specify telemetry collector
-xfidelity --mode server --port 9999 -t https://telemetry.example.com
+# Run in config server mode with custom port
+xfidelity --mode server --port 9999 
 
 # Use local config and rules
 xfidelity -l /path/to/local/config
 ```
 
+### Environment Variables
+
+x-fidelity supports the following environment variables:
+
+- `OPENAI_API_KEY`: Your OpenAI API key for AI-powered analysis.
+- `OPENAI_MODEL`: The OpenAI model to use (default is 'gpt-4o').
+- `XFI_LISTEN_PORT`: The port for the config server to listen on (default is 8888).
+- `CERT_PATH`: The path to SSL certificates for HTTPS config server.
+- `NODE_TLS_REJECT_UNAUTHORIZED`: Set to '0' to allow self-signed certificates (use with caution).
+
+Example usage:
+
+```sh
+export OPENAI_API_KEY=your_api_key_here
+export OPENAI_MODEL=gpt-4
+export XFI_LISTEN_PORT=9999
+xfidelity -o true
+```
+
 ## Configuration
 
 x-fidelity uses archetypes to define project-specific configurations. Archetypes are now managed as JSON files, which can be stored locally or on a remote server.
@@ -362,11 +391,11 @@ x-fidelity is designed to be highly extensible. You can add custom rules, operat
 3. **Custom Facts**: Create new fact providers and add them to your x-fidelity fork or plugin.
 4. **New Archetypes**: Define new archetypes as JSON files in your local config directory or on your config server.
 
-Example of a custom rule JSON file (`my-custom-rule.json`):
+Example of a custom rule JSON file (`myCustomRule.json`):
 
 ```json
 {
-    "name": "my-custom-rule",
+    "name": "myCustomRule",
     "conditions": {
         "all": [
             {
@@ -378,10 +407,9 @@ Example of a custom rule JSON file (`my-custom-rule.json`):
         ]
     },
     "event": {
-        "type": "violation",
+        "type": "warning",
         "params": {
             "message": "TODO comments should be resolved before committing",
-            "level": "warning",
             "details": {
                 "fact": "fileData",
                 "path": "$.filePath"
@@ -392,7 +420,7 @@ Example of a custom rule JSON file (`my-custom-rule.json`):
 ```
 
 Note on rule event types:
-- Events of type "violation" are treated as warnings and do not cause the tool to return an error code.
+- Events of type "warning" are treated as such and do not cause the tool to return an error code.
 - Events of type "fatality" are strictly enforced and will cause the tool to return an error code 1.
 
 Example of a custom archetype JSON file (`my-custom-archetype.json`):
@@ -421,6 +449,38 @@ Example of a custom archetype JSON file (`my-custom-archetype.json`):
 
 ## OpenAI Integration
 
+x-fidelity offers advanced AI-powered code analysis through integration with OpenAI's language models. This feature provides in-depth insights and suggestions for improving your codebase.
+
+> [!IMPORTANT]
+> Carefully consider the costs and data privacy implications before enabling OpenAI integration, especially for large codebases or sensitive projects.
+
+### How It Works
+
+1. **Data Collection**: x-fidelity gathers relevant information about your codebase, including file contents, structure, and dependencies.
+
+2. **AI Analysis**: This data is sent to OpenAI's API, where it's analyzed by a powerful language model (default is GPT-4o).
+
+3. **Insights Generation**: The AI generates detailed insights, suggestions, and potential issues based on best practices, common pitfalls, and the specific context of your project.
+
+4. **Results Integration**: These insights are integrated into x-fidelity's output, providing you with AI-enhanced analysis alongside the tool's standard checks.
+
+### Key Features
+
+- **Code Quality Assessment**: Identifies potential bugs, anti-patterns, and areas for improvement.
+- **Architecture Suggestions**: Offers insights on overall code structure and architectural decisions.
+- **Performance Optimization**: Highlights areas where performance could be improved.
+- **Security Analysis**: Flags potential security vulnerabilities.
+- **Best Practices**: Suggests adherence to industry-standard best practices.
+
+### Limitations and Considerations
+
+- **Cost**: Using OpenAI's API incurs charges based on the amount of text processed.
+- **Privacy**: Code snippets are sent to OpenAI's servers for analysis. Ensure this complies with your organization's data policies.
+- **Accuracy**: While highly advanced, AI suggestions should be reviewed by human developers for context and applicability.
+- **Rate Limits**: OpenAI's API has rate limits that may affect analysis of very large codebases.
+
+### Setup and Usage
+
 To enable AI-powered code analysis:
 
 1. Sign up for an [OpenAI API key](https://platform.openai.com).
@@ -442,8 +502,61 @@ You can also set the OpenAI model using an environment variable (optional):
 export OPENAI_MODEL=gpt-4  # Optional, default is gpt-4o
 ```
 
+By leveraging OpenAI's advanced language models, x-fidelity provides a unique blend of rule-based checks and AI-powered insights, offering a comprehensive analysis of your codebase that goes beyond traditional static analysis tools.
+
+### Creating Custom OpenAI Rules
+
+You can create custom OpenAI rules to leverage AI-powered analysis for specific aspects of your codebase. Here's how to create a new OpenAI rule:
+
 > [!IMPORTANT]
-> Be aware of potential costs and data privacy concerns when using OpenAI's API.
+> By convention, all OpenAI rules must have a name starting with 'openai'. This naming convention is used to identify and handle OpenAI-specific rules in the system.
+
+1. Create a new JSON file in your rules directory (e.g., `openaiCustomAnalysis-global-rule.json`).
+2. Use the following template structure for your rule:
+
+```json
+{
+    "name": "openai-custom-analysis",
+    "conditions": {
+        "all": [
+            {
+                "fact": "fileData",
+                "path": "$.fileName",
+                "operator": "equal",
+                "value": "REPO_GLOBAL_CHECK"
+            },
+            {
+                "fact": "openaiAnalysis",
+                "params": {
+                    "prompt": "Your custom prompt here",
+                    "resultFact": "openaiCustomAnalysisResult"
+                },
+                "operator": "openaiAnalysisHighSeverity",
+                "value": 8
+            }
+        ]
+    },
+    "event": {
+        "type": "warning",
+        "params": {
+            "message": "Custom message for the warning",
+            "results": {
+                "fact": "openaiCustomAnalysisResult"
+            }
+        }
+    }
+}
+```
+
+3. Customize the rule:
+   - Set a unique `name` for your rule, ensuring it starts with 'openai'.
+   - Modify the `prompt` in the `params` section to specify what you want the AI to analyze.
+   - Adjust the `value` in the `openaiAnalysisHighSeverity` operator to set the severity threshold (1-10).
+   - Customize the `message` in the `event` params to describe the warning.
+
+4. Add your new rule to the appropriate archetype configuration file.
+
+This structure allows you to create custom AI-powered rules that can analyze your codebase for specific patterns, best practices, or potential issues. Remember to follow the naming convention to ensure proper handling of OpenAI rules in the system.
 
 ## Best Practices
 
@@ -460,6 +573,20 @@ export OPENAI_MODEL=gpt-4  # Optional, default is gpt-4o
 
 Contributions to x-fidelity are welcome! Please refer to the `CONTRIBUTING.md` file for guidelines on how to contribute to this project.
 
+## Glossary
+
+- **Archetype**: A predefined configuration template for a specific type of project or technology stack. It defines the rules, operators, facts, and other settings to be applied during analysis.
+
+- **Rule**: A set of conditions and corresponding actions that define a specific check or requirement for the codebase. Rules are used to identify warnings or fatal issues in the codebase.
+
+- **Operator**: A function that performs a specific comparison or check within a rule. Operators are used to evaluate conditions in rules.
+
+- **Fact**: A piece of information about the codebase or its environment that is collected and used during the analysis process. Facts can include file contents, dependency versions, or other relevant data.
+
+- **Config Server**: A server that hosts and distributes archetype configurations and rules, allowing for centralized management of x-fidelity settings.
+
+- **Telemetry**: Data collected about the usage and performance of x-fidelity, which can be used for improving the tool and understanding its impact.
+
 ## License
 
 This project is licensed under the MIT License. See the `LICENSE` file for details.

package/dist/core/cli.js

@@ -7,6 +7,8 @@ exports.options = void 0;
 const logger_1 = require("../utils/logger");
 const commander_1 = require("commander");
 const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const package_json_1 = require("../../package.json");
 // Ensure logger is initialized
 if (!logger_1.logger || typeof logger_1.logger.info !== 'function') {
     console.error('Logger is not properly initialized');
@@ -20,7 +22,7 @@ if (!logger_1.logger || typeof logger_1.logger.info !== 'function') {
     global.logger = fallbackLogger;
 }
 commander_1.program
-    .option("-d, --dir <directory>", "The checkout directory to analyze", ".")
+    .option("-d, --dir <directory>", "code directory to analyze. equivalent of directory argument")
     .option("-a, --archetype <archetype>", "The archetype to use for analysis", "node-fullstack")
     .option("-c, --configServer <configServer>", "The config server URL for fetching remote archetype configurations and rules")
     .option("-o, --openaiEnabled <boolean>", "Enable OpenAI analysis", false)
@@ -28,16 +30,39 @@ commander_1.program
     .option("-m, --mode <mode>", "Run mode: 'client' or 'server'", "client")
     .option("-p, --port <port>", "The port to run the server on", "8888")
     .option("-l, --localConfigPath <path>", "Path to local archetype config and rules")
-    .option("-j, --jsonTTL <minutes>", "Set the server json cache TTL in minutes", "10");
-commander_1.program.parse();
+    .option("-j, --jsonTTL <minutes>", "Set the server json cache TTL in minutes", "10")
+    .version(package_json_1.version, "-v, --version", "Output the version number of xfidelity")
+    .helpOption("-h, --help", "Display help for command")
+    .argument('[directory]', 'code directory to analyze');
 const options = commander_1.program.opts();
 exports.options = options;
+commander_1.program.parse(process.argv);
+// If no options or args are provided, display the help message
+if (process.argv.length === 2 && commander_1.program.args.length === 0) {
+    // dont exit in tests
+    if (process.env.NODE_ENV !== 'test')
+        commander_1.program.help();
+}
 // Resolve paths
-const resolvePath = (inputPath) => path_1.default.resolve(process.cwd(), inputPath);
-options.dir = resolvePath(options.dir);
+if (process.env.NODE_ENV === 'test' || options.mode === 'server')
+    options.dir = '.';
+const resolvePath = (inputPath) => path_1.default === null || path_1.default === void 0 ? void 0 : path_1.default.resolve(process.cwd(), inputPath);
+options.dir = commander_1.program.args.length == 1 ? resolvePath(commander_1.program.args[0]) : resolvePath(options.dir);
 if (options.localConfigPath) {
     options.localConfigPath = resolvePath(options.localConfigPath);
 }
+// if dir does not exist, exit
+if (!options.dir || !fs_1.default.existsSync(options.dir)) {
+    logger_1.logger.error(`target directory ${options.dir} does not exist`);
+    if (process.env.NODE_ENV !== 'test')
+        process.exit(1);
+}
+// if localConfig path does not exist, exit
+if (options.localConfigPath && !fs_1.default.existsSync(options.localConfigPath)) {
+    logger_1.logger.error(`localConfigPath ${options.localConfigPath} does not exist`);
+    if (process.env.NODE_ENV !== 'test')
+        process.exit(1);
+}
 const banner = (`
 =====================================
  __    __          ________  ______ 
@@ -51,6 +76,7 @@ const banner = (`
                                
 -------------------------------------
 ${new Date().toString().slice(0, 24)}
+version: ${package_json_1.version}
 archetype: ${options.archetype}
 directory: ${options.dir}
 configServer: ${options.configServer ? options.configServer : 'none'}
@@ -58,7 +84,7 @@ mode: ${options.mode}
 port: ${options.mode === 'server' ? options.port : 'n/a'}
 localConfigPath: ${options.localConfigPath ? options.localConfigPath : 'none'}
 jsonTTL: ${options.jsonTTL} minutes
-for available options run: xfidelity --help
+for options run: xfidelity --help
 =====================================`);
 logger_1.logger.info(banner);
 // print help if no arguments are passed

package/dist/core/engine/analyzer.js

@@ -11,7 +11,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.analyzeCodebase = analyzeCodebase;
 const logger_1 = require("../../utils/logger");
-const config_1 = require("../../utils/config");
+const configManager_1 = require("../../utils/configManager");
 const openaiUtils_1 = require("../../utils/openaiUtils");
 const telemetry_1 = require("../../utils/telemetry");
 const repoFilesystemFacts_1 = require("../../facts/repoFilesystemFacts");
@@ -20,30 +20,33 @@ const openaiAnalysisFacts_1 = require("../../facts/openaiAnalysisFacts");
 const telemetryCollector_1 = require("./telemetryCollector");
 const engineSetup_1 = require("./engineSetup");
 const engineRunner_1 = require("./engineRunner");
-const utils_1 = require("./utils");
+const utils_1 = require("../../utils/utils");
+const cli_1 = require("../cli");
 function analyzeCodebase(params) {
     return __awaiter(this, void 0, void 0, function* () {
-        const { repoPath, archetype = 'node-fullstack', configServer = '', localConfigPath = '' } = params;
-        const executionLogPrefix = (0, logger_1.generateLogPrefix)();
-        (0, logger_1.setLogPrefix)(executionLogPrefix);
-        logger_1.logger.info(`INITIALISING..`);
+        const { repoPath, archetype = 'node-fullstack', configServer = '', localConfigPath = '', executionLogPrefix = '' } = params;
+        logger_1.logger.info(`STARTING..`);
         const telemetryData = yield (0, telemetryCollector_1.collectTelemetryData)({ repoPath, configServer });
         // Send telemetry for analysis start
         yield (0, telemetry_1.sendTelemetry)({
             eventType: 'analysisStart',
-            metadata: Object.assign({ archetype,
-                repoPath }, telemetryData),
+            metadata: {
+                archetype,
+                repoPath,
+                telemetryData,
+                options: cli_1.options
+            },
             timestamp: new Date().toISOString()
         }, executionLogPrefix);
-        const executionConfig = yield config_1.ConfigManager.getConfig({ archetype, logPrefix: executionLogPrefix });
+        const executionConfig = yield configManager_1.ConfigManager.getConfig({ archetype, logPrefix: executionLogPrefix });
         const archetypeConfig = executionConfig.archetype;
         const installedDependencyVersions = yield (0, repoDependencyFacts_1.getDependencyVersionFacts)(archetypeConfig);
         const fileData = yield (0, repoFilesystemFacts_1.collectRepoFileData)(repoPath, archetypeConfig);
         // add REPO_GLOBAL_CHECK to fileData, which is the trigger for global checks
         fileData.push({
-            fileName: config_1.REPO_GLOBAL_CHECK,
-            filePath: config_1.REPO_GLOBAL_CHECK,
-            fileContent: config_1.REPO_GLOBAL_CHECK
+            fileName: configManager_1.REPO_GLOBAL_CHECK,
+            filePath: configManager_1.REPO_GLOBAL_CHECK,
+            fileContent: configManager_1.REPO_GLOBAL_CHECK
         });
         const { minimumDependencyVersions, standardStructure } = archetypeConfig.config;
         let openaiSystemPrompt;
@@ -53,7 +56,7 @@ function analyzeCodebase(params) {
         const engine = yield (0, engineSetup_1.setupEngine)({
             archetypeConfig,
             archetype,
-            configManager: config_1.ConfigManager,
+            configManager: configManager_1.ConfigManager,
             executionLogPrefix,
             localConfigPath
         });
@@ -73,19 +76,33 @@ function analyzeCodebase(params) {
         });
         const finishMsg = `\n==========================\nCHECKS COMPLETED..\n==========================`;
         logger_1.logger.info(finishMsg);
-        logger_1.logger.info(`${fileData.length} files analyzed. ${failures.length} files with errors.`);
-        const fatalities = (0, utils_1.findKeyValuePair)(failures, 'level', 'fatality');
+        const totalFailureCount = (0, utils_1.countRuleFailures)(failures);
+        logger_1.logger.info(`${fileData.length} files analyzed. ${totalFailureCount} rule failures.`);
+        const fatalityCount = (0, utils_1.countRuleFailures)(failures, 'fatality');
+        const warningCount = (0, utils_1.countRuleFailures)(failures, 'warning');
+        const finishTime = new Date().getTime();
+        const resultMetadata = {
+            XFI_RESULT: {
+                archetype,
+                repoPath,
+                fileCount: fileData.length,
+                totalIssues: totalFailureCount,
+                warningCount: warningCount,
+                fatalityCount: fatalityCount,
+                issueDetails: failures,
+                startTime: telemetryData.startTime,
+                finishTime: finishTime,
+                durationSeconds: (finishTime - telemetryData.startTime) / 1000,
+                telemetryData,
+                options: cli_1.options
+            }
+        };
         // Send telemetry for analysis end
         yield (0, telemetry_1.sendTelemetry)({
-            eventType: 'analysisEnd',
-            metadata: Object.assign(Object.assign({ archetype,
-                repoPath }, telemetryData), { fileCount: fileData.length, failureCount: failures.length, fatalityCount: fatalities.length }),
+            eventType: 'analysisResults',
+            metadata: resultMetadata,
             timestamp: new Date().toISOString()
         }, executionLogPrefix);
-        if (fatalities.length > 0) {
-            throw new Error(JSON.stringify(fatalities));
-        }
-        return failures;
+        return resultMetadata;
     });
 }
-// ... (rest of the helper functions)