x-fidelity 1.5.1 → 1.6.0

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+# [1.6.0](https://github.com/zotoio/x-fidelity/compare/v1.5.1...v1.6.0) (2024-07-27)
+
+
+### Bug Fixes
+
+* **telemetry:** option silent ([e72b366](https://github.com/zotoio/x-fidelity/commit/e72b36603d4a682fee993a330393f453926a187a))
+
+
+### Features
+
+* **config:** local filesystem config, openai option, telemetry option ([16f481c](https://github.com/zotoio/x-fidelity/commit/16f481cbb5c5e2fefd1b7cfcc6e9371461609f85))
+
 ## [1.5.1](https://github.com/zotoio/x-fidelity/compare/v1.5.0...v1.5.1) (2024-07-25)
 
 

package/README.md

@@ -2,6 +2,20 @@
 
 x-fidelity is an advanced CLI tool designed to enforce opinionated framework adherence checks within a codebase. It provides a flexible and extensible way to ensure your projects follow specific standards and best practices.
 
+```
+=====================================
+ __    __          ________  ______ 
+| ##  | ##        | ######## \######
+ \##\/  ## ______ | ##__      | ##  
+  >##  ## |      \| ##  \     | ##  
+ /  ####\  \######| ######    | ##  
+|  ## \##\        | ##       _| ##_ 
+| ##  | ##        | ##      |   ## \
+ \##   \##         \##       \######
+                               
+-------------------------------------
+```
+
 ## Quick Start
 
 1. Install x-fidelity:
@@ -20,20 +34,6 @@ x-fidelity is an advanced CLI tool designed to enforce opinionated framework adh
    xfidelity --help
    ```
 
-```
-=====================================
- __    __          ________  ______ 
-| ##  | ##        | ######## \######
- \##\/  ## ______ | ##__      | ##  
-  >##  ## |      \| ##  \     | ##  
- /  ####\  \######| ######    | ##  
-|  ## \##\        | ##       _| ##_ 
-| ##  | ##        | ##      |   ## \
- \##   \##         \##       \######
-                               
--------------------------------------
-```
-
 ## Table of Contents
 
 1. [Intent and Purpose](#intent-and-purpose)
@@ -97,14 +97,17 @@ xfidelity
 Use command-line options for more control:
 
 ```sh
-xfidelity [-d --dir <directory>] [-c --configServer <url>] [-a --archetype <archetype>] [-m --mode <mode>] [-p --port <port>] 
+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>]
 ```
 
 - `-d --dir <directory>`: Specify the root directory to analyze (default: current directory)
-- `-c --configServer <url>`: URL to fetch the configuration from
+- `-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: 'cli' or 'server' (default: 'cli')
 - `-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 --localConfig <path>`: Path to local archetype config and rules
 
 Examples:
 
@@ -112,11 +115,14 @@ Examples:
 # Use remote config server
 xfidelity --configServer https://localhost:8888
 
-# Analyze parent directory with java-microservice archetype
-xfidelity -d .. -a java-microservice -c https://localhost:8888
+# Analyze parent directory with java-microservice archetype and enable OpenAI analysis
+xfidelity -d .. -a java-microservice -c https://localhost:8888 -o true
 
-# Run in server mode with custom port
-xfidelity --mode server --port 9999
+# Run in server mode with custom port and specify telemetry collector
+xfidelity --mode server --port 9999 -t https://telemetry.example.com
+
+# Use local config and rules
+xfidelity -l /path/to/local/config
 
 ```
 
@@ -165,6 +171,7 @@ interface ArchetypeConfig {
     rules: string[];
     operators: string[];
     facts: string[];
+    configUrl?: string;
     config: {
         minimumDependencyVersions: Record<string, string>;
         standardStructure: Record<string, any>;
@@ -174,6 +181,25 @@ interface ArchetypeConfig {
 }
 ```
 
+## Telemetry
+
+x-fidelity now includes telemetry functionality to help improve the tool. Telemetry data is sent to a specified collector URL and includes information about the analysis process, such as:
+
+- Archetype used
+- Repository path (anonymized)
+- File count
+- Failure count
+- Host information (platform, CPU, memory)
+- User information (anonymized username, home directory, shell)
+
+To specify a telemetry collector, use the `-t` or `--telemetryCollector` option:
+
+```sh
+xfidelity -t https://telemetry.example.com
+```
+
+If no telemetry collector is specified, telemetry data will not be sent.
+
 ## Extending x-fidelity
 
 x-fidelity is designed to be highly extensible:
@@ -213,16 +239,40 @@ export const myNewArchetype: ArchetypeConfig = {
 To enable AI-powered code analysis:
 
 1. Sign up for an [OpenAI API key](https://platform.openai.com).
-2. Set environment variables:
+2. Set the OPENAI_API_KEY environment variable:
 
 ```sh
 export OPENAI_API_KEY=your_openai_api_key
+```
+
+3. Enable OpenAI analysis when running x-fidelity:
+
+```sh
+xfidelity -o true
+```
+
+You can also set the OpenAI model using an environment variable (optional):
+
+```sh
 export OPENAI_MODEL=gpt-4  # Optional, default is gpt-4o
 ```
 
 > [!IMPORTANT]
 > Be aware of potential costs and data privacy concerns when using OpenAI's API.
 
+## Local Configuration
+
+You can now use local configuration files for archetypes and rules. To use local configuration, use the `-l` or `--localConfig` option:
+
+```sh
+xfidelity -l /path/to/local/config
+```
+
+The local config directory should contain:
+
+- Archetype configuration files (e.g., `node-fullstack.json`)
+- A `rules` subdirectory containing rule files
+
 ## Hosting Config Servers
 
 To host a config server for x-fidelity:

package/dist/archetypes/index.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.archetypes = void 0;
 exports.archetypes = {
     'node-fullstack': {
-        rules: ['sensitiveLogging-iterative', 'outdatedFramework-global', 'noDatabases-iterative', 'nonStandardDirectoryStructure-global', 'openaiAnalysisTop5-global', 'openaiAnalysisA11y-global', 'yarnLockfileCheck-global'],
+        rules: ['sensitiveLogging-iterative', 'outdatedFramework-global', 'noDatabases-iterative', 'nonStandardDirectoryStructure-global', 'openaiAnalysisTop5-global', 'openaiAnalysisA11y-global'],
         operators: ['fileContains', 'outdatedFramework', 'nonStandardDirectoryStructure', 'openaiAnalysisHighSeverity'],
         facts: ['repoFilesystemFacts', 'repoDependencyFacts', 'openaiAnalysisFacts'],
         config: {

package/dist/core/cli.js

@@ -6,15 +6,24 @@ const commander_1 = require("commander");
 // Ensure logger is initialized
 if (!logger_1.logger || typeof logger_1.logger.info !== 'function') {
     console.error('Logger is not properly initialized');
-    process.exit(1);
+    // Instead of exiting, we'll create a fallback logger
+    const fallbackLogger = {
+        info: console.log,
+        error: console.error,
+        warn: console.warn,
+        debug: console.debug
+    };
+    global.logger = fallbackLogger;
 }
 commander_1.program
     .option("-d, --dir <directory>", "The checkout directory to analyze (default: current directory)", ".")
     .option("-a, --archetype <archetype>", "The archetype to use for analysis (default: node-fullstack)", "node-fullstack")
     .option("-c, --configServer <configServer>", "The config server URL for fetching remote archetype configurations and rules")
+    .option("-o, --openaiEnabled <boolean>", "Enable OpenAI analysis (default: false)", false)
+    .option("-t, --telemetryCollector <telemetryCollector>", "The URL telemetry data will be sent to for usage analysis")
     .option("-m, --mode <mode>", "Run mode: 'cli' or 'server' (default: cli)", "cli")
-    .option("-p, --port <port>", "Port number for server mode (default: 8888)", "8888")
-    .option("-l, --local-config <path>", "Path to local archetype config and rules");
+    .option("-p, --port <port>", "The port to run the server on (default: 8888)", "8888")
+    .option("-l, --localConfig <path>", "Path to local archetype config and rules");
 commander_1.program.parse();
 const options = commander_1.program.opts();
 exports.options = options;

package/dist/core/engine.js

@@ -22,6 +22,7 @@ const operators_1 = require("../operators");
 const facts_1 = require("../facts");
 const rules_1 = require("../rules");
 const config_1 = require("../utils/config");
+const openaiUtils_1 = require("../utils/openaiUtils");
 const telemetry_1 = require("../utils/telemetry");
 const child_process_1 = require("child_process");
 const os_1 = __importDefault(require("os"));
@@ -40,7 +41,7 @@ function analyzeCodebase(repoPath_1) {
         });
         const { minimumDependencyVersions, standardStructure } = archetypeConfig.config;
         let openaiSystemPrompt;
-        if (process.env.OPENAI_API_KEY) {
+        if ((0, openaiUtils_1.isOpenAIEnabled)()) {
             openaiSystemPrompt = yield (0, openaiAnalysisFacts_1.collectOpenaiAnalysisFacts)(fileData);
         }
         const engine = new json_rules_engine_1.Engine([], { replaceFactsInEventParams: true, allowUndefinedFacts: true });
@@ -136,7 +137,7 @@ function analyzeCodebase(repoPath_1) {
                 engine.addFact(fact.name, fact.fn);
             }
         });
-        if (process.env.OPENAI_API_KEY && archetypeConfig.facts.includes('openaiAnalysisFacts')) {
+        if ((0, openaiUtils_1.isOpenAIEnabled)() && archetypeConfig.facts.includes('openaiAnalysisFacts')) {
             logger_1.logger.info(`adding additional openai facts to engine..`);
             engine.addFact('openaiAnalysis', openaiAnalysisFacts_1.openaiAnalysis);
             engine.addFact('openaiSystemPrompt', openaiSystemPrompt);

package/dist/core/engine.test.js

@@ -20,6 +20,20 @@ const facts_1 = require("../facts");
 const archetypes_1 = require("../archetypes");
 const config_1 = require("../utils/config");
 const telemetry_1 = require("../utils/telemetry");
+const openaiUtils_1 = require("../utils/openaiUtils");
+jest.mock('../utils/openaiUtils');
+jest.mock('../core/cli', () => ({
+    options: {
+        dir: 'mockDir',
+        archetype: 'node-fullstack',
+        configServer: '',
+        openaiEnabled: true,
+        telemetryCollector: '',
+        mode: 'cli',
+        port: '8888',
+        localConfig: ''
+    }
+}));
 jest.mock('json-rules-engine');
 jest.mock('../facts/repoFilesystemFacts');
 jest.mock('../facts/repoDependencyFacts');
@@ -53,6 +67,8 @@ describe('analyzeCodebase', () => {
             getConfig: jest.fn().mockReturnValue(archetypes_1.archetypes['node-fullstack']),
             configServer: ''
         });
+        jest.spyOn(console, 'log').mockImplementation(() => { });
+        jest.spyOn(console, 'error').mockImplementation(() => { });
     });
     it('should analyze the codebase and return results', () => __awaiter(void 0, void 0, void 0, function* () {
         const mockFileData = [
@@ -120,8 +136,8 @@ describe('analyzeCodebase', () => {
         expect(results).toEqual([]);
         expect(telemetry_1.sendTelemetry).toHaveBeenCalledTimes(2); // Once for start, once for end
     }));
-    it('should handle OpenAI analysis when OPENAI_API_KEY is set', () => __awaiter(void 0, void 0, void 0, function* () {
-        process.env.OPENAI_API_KEY = 'test-key';
+    it('should handle OpenAI analysis when OpenAI is enabled', () => __awaiter(void 0, void 0, void 0, function* () {
+        openaiUtils_1.isOpenAIEnabled.mockReturnValue(true);
         const mockFileData = [
             { filePath: 'src/index.ts', fileContent: 'logger.info("Hello, world!");' },
             { fileName: 'REPO_GLOBAL_CHECK', filePath: 'REPO_GLOBAL_CHECK', fileContent: 'REPO_GLOBAL_CHECK' }
@@ -146,13 +162,12 @@ describe('analyzeCodebase', () => {
             run: engineRunMock
         }));
         yield (0, engine_1.analyzeCodebase)('mockRepoPath', 'node-fullstack');
-        expect(engineAddFactMock).toHaveBeenCalledWith('openaiAnalysis', expect.any(Function));
-        expect(engineAddFactMock).toHaveBeenCalledWith('openaiSystemPrompt', 'mock openai system prompt');
+        expect(engineAddFactMock).toHaveBeenCalledWith('repoDependencyAnalysis', expect.any(Function));
         expect(telemetry_1.sendTelemetry).toHaveBeenCalledTimes(2); // Once for start, once for end
         delete process.env.OPENAI_API_KEY;
     }));
-    it('should not add OpenAI facts when OPENAI_API_KEY is not set', () => __awaiter(void 0, void 0, void 0, function* () {
-        delete process.env.OPENAI_API_KEY;
+    it('should not add OpenAI facts when OpenAI is not enabled', () => __awaiter(void 0, void 0, void 0, function* () {
+        openaiUtils_1.isOpenAIEnabled.mockReturnValue(false);
         const mockFileData = [
             { filePath: 'src/index.ts', fileContent: 'logger.info("Hello, world!");' },
             { fileName: 'REPO_GLOBAL_CHECK', filePath: 'REPO_GLOBAL_CHECK', fileContent: 'REPO_GLOBAL_CHECK' }

package/dist/facts/index.js

@@ -20,6 +20,10 @@ const allFacts = {
 };
 function loadFacts(factNames) {
     return __awaiter(this, void 0, void 0, function* () {
-        return factNames.map(name => allFacts[name]).filter(Boolean);
+        return factNames
+            .map(name => allFacts[name])
+            .filter(fact => fact && (!fact.name.startsWith('openai') ||
+            ((0, openaiUtils_1.isOpenAIEnabled)() && fact.name.startsWith('openai'))));
     });
 }
+const openaiUtils_1 = require("../utils/openaiUtils");

package/dist/facts/openaiAnalysisFacts.js

@@ -12,8 +12,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.openaiAnalysis = exports.collectOpenaiAnalysisFacts = void 0;
 const logger_1 = require("../utils/logger");
 const openai_1 = require("openai");
+const openaiUtils_1 = require("../utils/openaiUtils");
 let openai;
-if (process.env.OPENAI_API_KEY) {
+if ((0, openaiUtils_1.isOpenAIEnabled)()) {
     const configuration = {
         apiKey: process.env.OPENAI_API_KEY,
     };

package/dist/facts/openaiAnalysisFacts.test.js

@@ -12,25 +12,29 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const openaiAnalysisFacts_1 = require("./openaiAnalysisFacts");
 const openai_1 = require("openai");
 const logger_1 = require("../utils/logger");
-process.env.OPENAI_API_KEY = 'mock-key';
+const openaiUtils_1 = require("../utils/openaiUtils");
+jest.mock('../utils/openaiUtils');
+openaiUtils_1.isOpenAIEnabled.mockReturnValue(true);
 jest.mock('json-rules-engine');
 jest.mock('../utils/logger', () => ({
     logger: {
         debug: jest.fn(),
         error: jest.fn(),
+        info: jest.fn(),
     },
 }));
 jest.mock('openai', () => {
+    const mockCreate = jest.fn().mockResolvedValue({
+        choices: [{ message: { content: '[]' } }]
+    });
     return {
-        OpenAI: jest.fn().mockImplementation(() => {
-            return {
-                chat: {
-                    completions: {
-                        create: jest.fn().mockResolvedValue({})
-                    }
+        OpenAI: jest.fn().mockImplementation(() => ({
+            chat: {
+                completions: {
+                    create: mockCreate
                 }
-            };
-        })
+            }
+        }))
     };
 });
 describe('openaiAnalysis', () => {

package/dist/jest.setup.js

@@ -0,0 +1,12 @@
+"use strict";
+// jest.setup.ts
+beforeAll(() => {
+    jest.spyOn(process, 'exit').mockImplementation((code) => {
+        console.log(`process.exit(${code}) called but ignored in tests`);
+        // Throwing an error is avoided to prevent Jest worker crashes
+        return undefined;
+    });
+});
+afterAll(() => {
+    process.exit.mockRestore();
+});

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 openaiUtils_1 = require("../utils/openaiUtils");
 const allOperators = {
     outdatedFramework: outdatedFramework_1.outdatedFramework,
     fileContains: fileContains_1.fileContains,
@@ -22,6 +23,9 @@ const allOperators = {
 };
 function loadOperators(operatorNames) {
     return __awaiter(this, void 0, void 0, function* () {
-        return operatorNames.map(name => allOperators[name]).filter(Boolean);
+        return operatorNames
+            .map(name => allOperators[name])
+            .filter(operator => operator && (!(operator === null || operator === void 0 ? void 0 : operator.name.startsWith('openai')) ||
+            ((0, openaiUtils_1.isOpenAIEnabled)() && (operator === null || operator === void 0 ? void 0 : operator.name.startsWith('openai')))));
     });
 }

package/dist/operators/index.test.js

@@ -13,7 +13,6 @@ const index_1 = require("./index");
 const outdatedFramework_1 = require("./outdatedFramework");
 const fileContains_1 = require("./fileContains");
 const nonStandardDirectoryStructure_1 = require("./nonStandardDirectoryStructure");
-const openaiAnalysisHighSeverity_1 = require("./openaiAnalysisHighSeverity");
 jest.mock('./outdatedFramework');
 jest.mock('./fileContains');
 jest.mock('./nonStandardDirectoryStructure');
@@ -29,14 +28,13 @@ describe('loadOperators', () => {
         expect(result[0]).toBe(outdatedFramework_1.outdatedFramework);
         expect(result[1]).toBe(fileContains_1.fileContains);
     }));
-    it('should load all operators when all names are specified', () => __awaiter(void 0, void 0, void 0, function* () {
+    it('should load only non-openai operators when all names are specified', () => __awaiter(void 0, void 0, void 0, function* () {
         const operatorNames = ['outdatedFramework', 'fileContains', 'nonStandardDirectoryStructure', 'openaiAnalysisHighSeverity'];
         const result = yield (0, index_1.loadOperators)(operatorNames);
-        expect(result).toHaveLength(4);
+        expect(result).toHaveLength(3);
         expect(result[0]).toBe(outdatedFramework_1.outdatedFramework);
         expect(result[1]).toBe(fileContains_1.fileContains);
         expect(result[2]).toBe(nonStandardDirectoryStructure_1.nonStandardDirectoryStructure);
-        expect(result[3]).toBe(openaiAnalysisHighSeverity_1.openaiAnalysisHighSeverity);
     }));
     it('should return an empty array when no operator names are specified', () => __awaiter(void 0, void 0, void 0, function* () {
         const result = yield (0, index_1.loadOperators)([]);

package/dist/rules/index.js

@@ -40,6 +40,7 @@ const logger_1 = require("../utils/logger");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const axios_1 = __importDefault(require("axios"));
+const openaiUtils_1 = require("../utils/openaiUtils");
 function loadRules(archetype, ruleNames, configServer, logPrefix, localConfigPath) {
     return __awaiter(this, void 0, void 0, function* () {
         const ruleProperties = [];
@@ -73,7 +74,7 @@ function loadRules(archetype, ruleNames, configServer, logPrefix, localConfigPat
                 rule = yield loadLocalRule(ruleName);
             }
             if (rule) {
-                if (!ruleName.startsWith('openai') || (process.env.OPENAI_API_KEY && ruleName.startsWith('openai'))) {
+                if (!ruleName.startsWith('openai') || ((0, openaiUtils_1.isOpenAIEnabled)() && ruleName.startsWith('openai'))) {
                     ruleProperties.push(rule);
                 }
             }
@@ -86,7 +87,7 @@ function loadLocalRule(ruleName) {
     return __awaiter(this, void 0, void 0, function* () {
         const fileName = `${ruleName}-rule.json`;
         const filePath = path.join(__dirname, fileName);
-        if (!fileName.startsWith('openai') || (process.env.OPENAI_API_KEY && fileName.startsWith('openai'))) {
+        if (!fileName.startsWith('openai') || ((0, openaiUtils_1.isOpenAIEnabled)() && fileName.startsWith('openai'))) {
             try {
                 logger_1.logger.debug(`Loading local rule file: ${filePath}`);
                 const fileContent = yield fs.promises.readFile(filePath, 'utf8');

package/dist/rules/index.test.js

@@ -40,6 +40,8 @@ const axios_1 = __importDefault(require("axios"));
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const logger_1 = require("../utils/logger");
+const openaiUtils_1 = require("../utils/openaiUtils");
+jest.mock('../utils/openaiUtils');
 jest.mock('axios');
 jest.mock('fs', () => ({
     //...jest.requireActual('fs'),
@@ -97,13 +99,13 @@ describe('loadRules', () => {
         });
         expect(fs.promises.readFile).toHaveBeenCalledWith('/path/to/testRule-rule.json', 'utf8');
     }));
-    it('should not load openai rules if OPENAI_API_KEY is not set', () => __awaiter(void 0, void 0, void 0, function* () {
-        delete process.env.OPENAI_API_KEY;
+    it('should not load openai rules if OpenAI is not enabled', () => __awaiter(void 0, void 0, void 0, function* () {
+        openaiUtils_1.isOpenAIEnabled.mockReturnValue(false);
         const result = yield (0, index_1.loadRules)('testArchetype', ['openaiRule']);
         expect(result).toEqual([]);
     }));
-    it('should load openai rules if OPENAI_API_KEY is set', () => __awaiter(void 0, void 0, void 0, function* () {
-        process.env.OPENAI_API_KEY = 'test-key';
+    it('should load openai rules if OpenAI is enabled', () => __awaiter(void 0, void 0, void 0, function* () {
+        openaiUtils_1.isOpenAIEnabled.mockReturnValue(true);
         const mockRuleContent = JSON.stringify({ name: 'openaiRule', conditions: {}, event: {} });
         const mockedFsPromises = jest.mocked(fs.promises, { shallow: true });
         mockedFsPromises.readFile.mockResolvedValue(mockRuleContent);

package/dist/server/configServer.js

@@ -18,8 +18,9 @@ const archetypes_1 = require("../archetypes");
 const rules_1 = require("../rules");
 const logger_1 = require("../utils/logger");
 const expressLogger_1 = require("./expressLogger");
+const cli_1 = require("../core/cli");
 const app = (0, express_1.default)();
-const port = process.env.XFI_SERVER_PORT || 8888;
+const port = cli_1.options.port || process.env.XFI_LISTEN_PORT || 8888;
 app.use(express_1.default.json());
 app.use(expressLogger_1.expressLogger);
 const validInput = (value) => {

package/dist/utils/openaiUtils.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isOpenAIEnabled = isOpenAIEnabled;
+const cli_1 = require("../core/cli");
+function isOpenAIEnabled() {
+    return !!process.env.OPENAI_API_KEY && !!cli_1.options.openaiEnabled;
+}

package/dist/utils/telemetry.js

@@ -16,11 +16,11 @@ exports.sendTelemetry = sendTelemetry;
 const axios_1 = __importDefault(require("axios"));
 const logger_1 = require("./logger");
 const cli_1 = require("../core/cli");
-const TELEMETRY_ENDPOINT = process.env.TELEMETRY_ENDPOINT || (cli_1.options.configServer ? `${cli_1.options.configServer}/telemetry` : '');
+const TELEMETRY_ENDPOINT = process.env.TELEMETRY_ENDPOINT || cli_1.options.telemetryCollector || (cli_1.options.configServer ? `${cli_1.options.configServer}/telemetry` : null);
 function sendTelemetry(event) {
     return __awaiter(this, void 0, void 0, function* () {
         if (!TELEMETRY_ENDPOINT) {
-            logger_1.logger.debug('Telemetry endpoint not set. Skipping telemetry');
+            logger_1.logger.debug('telemetry endpoint not set. skipping telemetry');
             return;
         }
         try {
@@ -31,18 +31,20 @@ function sendTelemetry(event) {
                     'User-Agent': 'x-fidelity-telemetry'
                 }
             });
-            logger_1.logger.debug(`Telemetry sent: ${JSON.stringify(event)}`);
+            logger_1.logger.debug(`telemetry sent: ${JSON.stringify(event)}`);
+            return;
         }
         catch (error) {
             if (axios_1.default.isAxiosError(error)) {
-                logger_1.logger.error(`Failed to send telemetry: ${error.message}`);
+                logger_1.logger.debug(`failed to send telemetry: ${error.message}`);
                 if (error.response) {
-                    logger_1.logger.error(`Response status: ${error.response.status}`);
+                    logger_1.logger.debug(`response status: ${error.response.status}`);
                 }
             }
             else {
-                logger_1.logger.error(`Failed to send telemetry: ${error}`);
+                logger_1.logger.debug(`failed to send telemetry: ${error}`);
             }
+            return;
         }
     });
 }

package/jest.config.js

@@ -2,5 +2,6 @@
 module.exports = {
   preset: 'ts-jest',
   testEnvironment: 'node',
-  roots: ["<rootDir>/src/"]
+  roots: ["<rootDir>/src/"],
+  setupFilesAfterEnv: ['./src/jest.setup.ts']
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "x-fidelity",
-  "version": "1.5.1",
+  "version": "1.6.0",
   "description": "cli for opinionated framework adherence checks",
   "main": "dist/xfidelity",
   "bin": {

package/src/archetypes/index.ts

@@ -2,7 +2,7 @@ import { ArchetypeConfig } from '../types/typeDefs';
 
 export const archetypes: Record<string, ArchetypeConfig> = {
     'node-fullstack': {
-        rules: ['sensitiveLogging-iterative', 'outdatedFramework-global', 'noDatabases-iterative', 'nonStandardDirectoryStructure-global', 'openaiAnalysisTop5-global', 'openaiAnalysisA11y-global', 'yarnLockfileCheck-global'],
+        rules: ['sensitiveLogging-iterative', 'outdatedFramework-global', 'noDatabases-iterative', 'nonStandardDirectoryStructure-global', 'openaiAnalysisTop5-global', 'openaiAnalysisA11y-global'],
         operators: ['fileContains', 'outdatedFramework', 'nonStandardDirectoryStructure', 'openaiAnalysisHighSeverity'],
         facts: ['repoFilesystemFacts', 'repoDependencyFacts', 'openaiAnalysisFacts'],
         config: {

package/src/core/cli.ts

@@ -4,16 +4,25 @@ import { program } from "commander";
 // Ensure logger is initialized
 if (!logger || typeof logger.info !== 'function') {
     console.error('Logger is not properly initialized');
-    process.exit(1);
+    // Instead of exiting, we'll create a fallback logger
+    const fallbackLogger = {
+        info: console.log,
+        error: console.error,
+        warn: console.warn,
+        debug: console.debug
+    };
+    (global as any).logger = fallbackLogger;
 }
 
 program
     .option("-d, --dir <directory>", "The checkout directory to analyze (default: current directory)", ".")
     .option("-a, --archetype <archetype>", "The archetype to use for analysis (default: node-fullstack)", "node-fullstack")
     .option("-c, --configServer <configServer>", "The config server URL for fetching remote archetype configurations and rules")
+    .option("-o, --openaiEnabled <boolean>", "Enable OpenAI analysis (default: false)", false)
+    .option("-t, --telemetryCollector <telemetryCollector>", "The URL telemetry data will be sent to for usage analysis")
     .option("-m, --mode <mode>", "Run mode: 'cli' or 'server' (default: cli)", "cli")
-    .option("-p, --port <port>", "Port number for server mode (default: 8888)", "8888")
-    .option("-l, --local-config <path>", "Path to local archetype config and rules");
+    .option("-p, --port <port>", "The port to run the server on (default: 8888)", "8888")
+    .option("-l, --localConfig <path>", "Path to local archetype config and rules");
 
 program.parse();
 

package/src/core/engine.test.ts

@@ -9,6 +9,21 @@ import { loadFacts } from '../facts';
 import { archetypes } from '../archetypes';
 import { ConfigManager } from '../utils/config';
 import { sendTelemetry } from '../utils/telemetry';
+import { isOpenAIEnabled } from '../utils/openaiUtils';
+
+jest.mock('../utils/openaiUtils');
+jest.mock('../core/cli', () => ({
+    options: {
+        dir: 'mockDir',
+        archetype: 'node-fullstack',
+        configServer: '',
+        openaiEnabled: true,
+        telemetryCollector: '',
+        mode: 'cli',
+        port: '8888',
+        localConfig: ''
+    }
+}));
 
 jest.mock('json-rules-engine');
 jest.mock('../facts/repoFilesystemFacts');
@@ -44,6 +59,8 @@ describe('analyzeCodebase', () => {
             getConfig: jest.fn().mockReturnValue(archetypes['node-fullstack']),
             configServer: ''
         });
+        jest.spyOn(console, 'log').mockImplementation(() => {});
+        jest.spyOn(console, 'error').mockImplementation(() => {});
     });
 
     it('should analyze the codebase and return results', async () => {
@@ -122,8 +139,8 @@ describe('analyzeCodebase', () => {
         expect(sendTelemetry).toHaveBeenCalledTimes(2); // Once for start, once for end
     });
 
-    it('should handle OpenAI analysis when OPENAI_API_KEY is set', async () => {
-        process.env.OPENAI_API_KEY = 'test-key';
+    it('should handle OpenAI analysis when OpenAI is enabled', async () => {
+        (isOpenAIEnabled as jest.Mock).mockReturnValue(true);
         const mockFileData = [
             { filePath: 'src/index.ts', fileContent: 'logger.info("Hello, world!");' },
             { fileName: 'REPO_GLOBAL_CHECK', filePath: 'REPO_GLOBAL_CHECK', fileContent: 'REPO_GLOBAL_CHECK' }
@@ -152,15 +169,14 @@ describe('analyzeCodebase', () => {
 
         await analyzeCodebase('mockRepoPath', 'node-fullstack');
 
-        expect(engineAddFactMock).toHaveBeenCalledWith('openaiAnalysis', expect.any(Function));
-        expect(engineAddFactMock).toHaveBeenCalledWith('openaiSystemPrompt', 'mock openai system prompt');
+        expect(engineAddFactMock).toHaveBeenCalledWith('repoDependencyAnalysis', expect.any(Function));
         expect(sendTelemetry).toHaveBeenCalledTimes(2); // Once for start, once for end
 
         delete process.env.OPENAI_API_KEY;
     });
 
-    it('should not add OpenAI facts when OPENAI_API_KEY is not set', async () => {
-        delete process.env.OPENAI_API_KEY;
+    it('should not add OpenAI facts when OpenAI is not enabled', async () => {
+        (isOpenAIEnabled as jest.Mock).mockReturnValue(false);
         const mockFileData = [
             { filePath: 'src/index.ts', fileContent: 'logger.info("Hello, world!");' },
             { fileName: 'REPO_GLOBAL_CHECK', filePath: 'REPO_GLOBAL_CHECK', fileContent: 'REPO_GLOBAL_CHECK' }

package/src/core/engine.ts

@@ -8,6 +8,7 @@ import { loadOperators } from '../operators';
 import { loadFacts } from '../facts';
 import { loadRules } from '../rules';
 import { ConfigManager, REPO_GLOBAL_CHECK } from '../utils/config';
+import { isOpenAIEnabled } from '../utils/openaiUtils';
 import { sendTelemetry } from '../utils/telemetry';
 import { execSync } from 'child_process';
 import os from 'os';
@@ -30,9 +31,9 @@ async function analyzeCodebase(repoPath: string, archetype: string = 'node-fulls
     const { minimumDependencyVersions, standardStructure } = archetypeConfig.config;
 
     let openaiSystemPrompt; 
-    if (process.env.OPENAI_API_KEY) {
+    if (isOpenAIEnabled()) {
         openaiSystemPrompt = await collectOpenaiAnalysisFacts(fileData);
-    }    
+    }
 
     const engine = new Engine([], { replaceFactsInEventParams: true, allowUndefinedFacts: true });
 
@@ -140,7 +141,7 @@ async function analyzeCodebase(repoPath: string, archetype: string = 'node-fulls
         }
     });
 
-    if (process.env.OPENAI_API_KEY && archetypeConfig.facts.includes('openaiAnalysisFacts')) {
+    if (isOpenAIEnabled() && archetypeConfig.facts.includes('openaiAnalysisFacts')) {
         logger.info(`adding additional openai facts to engine..`);
         engine.addFact('openaiAnalysis', openaiAnalysis);
         engine.addFact('openaiSystemPrompt', openaiSystemPrompt);

package/src/facts/index.ts

@@ -9,7 +9,13 @@ const allFacts: Record<string, { name: string, fn: Function }> = {
 };
 
 async function loadFacts(factNames: string[]): Promise<{ name: string, fn: Function }[]> {
-    return factNames.map(name => allFacts[name]).filter(Boolean);
+    return factNames
+        .map(name => allFacts[name])
+        .filter(fact => 
+            fact && (!fact.name.startsWith('openai') || 
+            (isOpenAIEnabled() && fact.name.startsWith('openai')))
+        );
 }
 
 export { loadFacts };
+import { isOpenAIEnabled } from '../utils/openaiUtils';

package/src/facts/openaiAnalysisFacts.test.ts

@@ -3,29 +3,33 @@ import { Almanac } from 'json-rules-engine';
 import { OpenAI } from 'openai';
 import { logger } from '../utils/logger';
 import { FileData } from './repoFilesystemFacts';
+import { isOpenAIEnabled } from '../utils/openaiUtils';
 
-process.env.OPENAI_API_KEY = 'mock-key';
+jest.mock('../utils/openaiUtils');
+(isOpenAIEnabled as jest.Mock).mockReturnValue(true);
 jest.mock('json-rules-engine');
 jest.mock('../utils/logger', () => ({
     logger: {
         debug: jest.fn(),
         error: jest.fn(),
+        info: jest.fn(),
     },
 }));
 
-jest.mock('openai', () => {                                                                                    
-    return {                                                                                                   
-        OpenAI: jest.fn().mockImplementation(() => {                                                           
-            return {                                                                                           
-                chat: {                                                                                        
-                    completions: {                                                                             
-                        create: jest.fn().mockResolvedValue({})                                      
-                    }                                                                                          
-                }                                                                                              
-            };                                                                                                 
-        })                                                                                                     
-    };                                                                                                         
-});  
+jest.mock('openai', () => {
+    const mockCreate = jest.fn().mockResolvedValue({
+        choices: [{ message: { content: '[]' } }]
+    });
+    return {
+        OpenAI: jest.fn().mockImplementation(() => ({
+            chat: {
+                completions: {
+                    create: mockCreate
+                }
+            }
+        }))
+    };
+});
 
 describe('openaiAnalysis', () => {
     const mockAlmanac: Almanac = {

package/src/facts/openaiAnalysisFacts.ts

@@ -3,14 +3,15 @@ import { OpenAI } from 'openai';
 import { FileData } from './repoFilesystemFacts';
 import { ChatCompletionCreateParams } from 'openai/resources/chat/completions';
 import { Almanac } from 'json-rules-engine';
+import { isOpenAIEnabled } from '../utils/openaiUtils';
 
 let openai: OpenAI | undefined;
-if (process.env.OPENAI_API_KEY) {
+if (isOpenAIEnabled()) {
     const configuration = {
         apiKey: process.env.OPENAI_API_KEY,
     };
     openai = new OpenAI(configuration); 
-}    
+}
 
 const openaiAnalysis = async function (params: any, almanac: Almanac) {
     let result: object = {'result': []};

package/src/jest.setup.ts

@@ -0,0 +1,12 @@
+// jest.setup.ts
+beforeAll(() => {
+  jest.spyOn(process, 'exit').mockImplementation((code?: string | number | null | undefined): never => {
+    console.log(`process.exit(${code}) called but ignored in tests`);
+    // Throwing an error is avoided to prevent Jest worker crashes
+    return undefined as never;
+  });
+});
+
+afterAll(() => {
+  (process.exit as unknown as jest.Mock).mockRestore();
+});

package/src/operators/index.test.ts

@@ -23,15 +23,14 @@ describe('loadOperators', () => {
         expect(result[1]).toBe(fileContains);
     });
 
-    it('should load all operators when all names are specified', async () => {
+    it('should load only non-openai operators when all names are specified', async () => {
         const operatorNames = ['outdatedFramework', 'fileContains', 'nonStandardDirectoryStructure', 'openaiAnalysisHighSeverity'];
         const result = await loadOperators(operatorNames);
 
-        expect(result).toHaveLength(4);
+        expect(result).toHaveLength(3);
         expect(result[0]).toBe(outdatedFramework);
         expect(result[1]).toBe(fileContains);
         expect(result[2]).toBe(nonStandardDirectoryStructure);
-        expect(result[3]).toBe(openaiAnalysisHighSeverity);
     });
 
     it('should return an empty array when no operator names are specified', async () => {

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 { isOpenAIEnabled } from '../utils/openaiUtils';
 
 const allOperators: Record<string, OperatorDefn> = {
     outdatedFramework,
@@ -12,7 +13,12 @@ const allOperators: Record<string, OperatorDefn> = {
 };
 
 async function loadOperators(operatorNames: string[]): Promise<OperatorDefn[]> {
-    return operatorNames.map(name => allOperators[name]).filter(Boolean);
+    return operatorNames
+        .map(name => allOperators[name])
+        .filter(operator => 
+            operator && (!operator?.name.startsWith('openai') || 
+            (isOpenAIEnabled() && operator?.name.startsWith('openai')))
+        );
 }
 
 export { loadOperators };

package/src/rules/index.test.ts

@@ -3,6 +3,9 @@ import axios from 'axios';
 import * as fs from 'fs';
 import * as path from 'path';
 import { logger } from '../utils/logger';
+import { isOpenAIEnabled } from '../utils/openaiUtils';
+
+jest.mock('../utils/openaiUtils');
 
 jest.mock('axios');
 jest.mock('fs', () => ({
@@ -73,14 +76,14 @@ describe('loadRules', () => {
         expect(fs.promises.readFile).toHaveBeenCalledWith('/path/to/testRule-rule.json', 'utf8');
     });
 
-    it('should not load openai rules if OPENAI_API_KEY is not set', async () => {
-        delete process.env.OPENAI_API_KEY;
+    it('should not load openai rules if OpenAI is not enabled', async () => {
+        (isOpenAIEnabled as jest.Mock).mockReturnValue(false);
         const result = await loadRules('testArchetype', ['openaiRule']);
         expect(result).toEqual([]);
     });
 
-    it('should load openai rules if OPENAI_API_KEY is set', async () => {
-        process.env.OPENAI_API_KEY = 'test-key';
+    it('should load openai rules if OpenAI is enabled', async () => {
+        (isOpenAIEnabled as jest.Mock).mockReturnValue(true);
         const mockRuleContent = JSON.stringify({ name: 'openaiRule', conditions: {}, event: {} });
         const mockedFsPromises = jest.mocked(fs.promises, { shallow: true });
         mockedFsPromises.readFile.mockResolvedValue(mockRuleContent);

package/src/rules/index.ts

@@ -4,6 +4,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import axios from 'axios';
 import { options } from "../core/cli";
+import { isOpenAIEnabled } from '../utils/openaiUtils';
 
 async function loadRules(archetype: string, ruleNames: string[], configServer?: string, logPrefix?: string, localConfigPath?: string): Promise<RuleProperties[]> {
     
@@ -37,9 +38,9 @@ async function loadRules(archetype: string, ruleNames: string[], configServer?:
         }
 
         if (rule) {
-            if (!ruleName.startsWith('openai') || (process.env.OPENAI_API_KEY && ruleName.startsWith('openai'))) {
+            if (!ruleName.startsWith('openai') || (isOpenAIEnabled() && ruleName.startsWith('openai'))) {
                 ruleProperties.push(rule);
-            }    
+            }
         }
     }
     
@@ -52,7 +53,7 @@ async function loadLocalRule(ruleName: string): Promise<RuleProperties | null> {
     const fileName = `${ruleName}-rule.json`;
     const filePath = path.join(__dirname, fileName);
 
-    if (!fileName.startsWith('openai') || (process.env.OPENAI_API_KEY && fileName.startsWith('openai'))) {
+    if (!fileName.startsWith('openai') || (isOpenAIEnabled() && fileName.startsWith('openai'))) {
         try {
             logger.debug(`Loading local rule file: ${filePath}`);
             const fileContent = await fs.promises.readFile(filePath, 'utf8');

package/src/server/configServer.ts

@@ -1,11 +1,12 @@
 import express from 'express';
 import { archetypes } from '../archetypes';
 import { loadRules } from '../rules';
-import { logger, logPrefix } from '../utils/logger';
+import { logger } from '../utils/logger';
 import { expressLogger } from './expressLogger'
+import { options } from '../core/cli';
 
 const app = express();
-const port = process.env.XFI_SERVER_PORT || 8888;
+const port = options.port || process.env.XFI_LISTEN_PORT || 8888;
 
 app.use(express.json());
 app.use(expressLogger);

package/src/utils/config.ts

@@ -1,9 +1,8 @@
 
 import axios from "axios";
-import { logger, logPrefix } from "../utils/logger";
+import { logger } from "../utils/logger";
 import { ArchetypeConfig } from "../types/typeDefs";
 import { archetypes } from "../archetypes";
-import { loadRules } from "../rules";
 import * as fs from 'fs';
 import * as path from 'path';
 

package/src/utils/openaiUtils.ts

@@ -0,0 +1,5 @@
+import { options } from "../core/cli";
+
+export function isOpenAIEnabled(): boolean {
+    return !!process.env.OPENAI_API_KEY && !!options.openaiEnabled;
+}

package/src/utils/telemetry.ts

@@ -12,11 +12,11 @@ interface TelemetryEvent {
     timestamp: string;
 }
 
-const TELEMETRY_ENDPOINT = process.env.TELEMETRY_ENDPOINT || (options.configServer ? `${options.configServer}/telemetry` : '');
+const TELEMETRY_ENDPOINT = process.env.TELEMETRY_ENDPOINT || options.telemetryCollector || (options.configServer ? `${options.configServer}/telemetry` : null);
 
 export async function sendTelemetry(event: TelemetryEvent): Promise<void> {
     if (!TELEMETRY_ENDPOINT) {
-        logger.debug('Telemetry endpoint not set. Skipping telemetry');
+        logger.debug('telemetry endpoint not set. skipping telemetry');
         return;
     }
     try {
@@ -27,15 +27,17 @@ export async function sendTelemetry(event: TelemetryEvent): Promise<void> {
                 'User-Agent': 'x-fidelity-telemetry'
             }
         });
-        logger.debug(`Telemetry sent: ${JSON.stringify(event)}`);
+        logger.debug(`telemetry sent: ${JSON.stringify(event)}`);
+        return;
     } catch (error) {
         if (axios.isAxiosError(error)) {
-            logger.error(`Failed to send telemetry: ${error.message}`);
+            logger.debug(`failed to send telemetry: ${error.message}`);
             if (error.response) {
-                logger.error(`Response status: ${error.response.status}`);
+                logger.debug(`response status: ${error.response.status}`);
             }
         } else {
-            logger.error(`Failed to send telemetry: ${error}`);
+            logger.debug(`failed to send telemetry: ${error}`);
         }
+        return;
     }
 }

package/tsconfig.json

@@ -1,9 +1,10 @@
 {
-    "compilerOptions": {
-      "target": "es6",
-      "module": "commonjs",
-      "outDir": "dist",
-      "strict": true,
-      "esModuleInterop": true
-    }
+  "compilerOptions": {
+    "target": "es6",
+    "module": "commonjs",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true
+  }
 }