x-fidelity 1.5.0 → 1.6.0

package/CHANGELOG.md

@@ -1,3 +1,22 @@
+# [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)
+
+
+### Bug Fixes
+
+* **scope:** logging correlation ([ea1c497](https://github.com/zotoio/x-fidelity/commit/ea1c4977cac418c49cd9f6778e7f72458c2c2a61))
+
 # [1.5.0](https://github.com/zotoio/x-fidelity/compare/v1.4.1...v1.5.0) (2024-07-24)
 
 

package/README.md

@@ -16,6 +16,24 @@ x-fidelity is an advanced CLI tool designed to enforce opinionated framework adh
 -------------------------------------
 ```
 
+## Quick Start
+
+1. Install x-fidelity:
+   ```
+   yarn global add x-fidelity
+   export PATH="$PATH:$(yarn global bin)"
+   ```
+
+2. Run in your project directory:
+   ```
+   xfidelity
+   ```
+
+3. For more options:
+   ```
+   xfidelity --help
+   ```
+
 ## Table of Contents
 
 1. [Intent and Purpose](#intent-and-purpose)
@@ -79,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:
 
@@ -94,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
 
 ```
 
@@ -147,6 +171,7 @@ interface ArchetypeConfig {
     rules: string[];
     operators: string[];
     facts: string[];
+    configUrl?: string;
     config: {
         minimumDependencyVersions: Record<string, string>;
         standardStructure: Record<string, any>;
@@ -156,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:
@@ -195,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

@@ -16,10 +16,6 @@ exports.archetypes = {
                     frontend: null,
                     server: null
                 }
-                // app: {
-                //     frontend: 'required',
-                //     server: 'required'
-                // }
             },
             blacklistPatterns: [
                 '.*\\/\\..*', // dot files

package/dist/core/cli.js

@@ -6,14 +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", ".")
-    .option("-a, --archetype <archetype>", "The archetype to use for analysis", "node-fullstack")
+    .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("-m, --mode <mode>", "Run mode: 'cli' or 'server'", "cli")
-    .option("-p, --port <port>", "Port number for server mode", "8888");
+    .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>", "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;
@@ -35,6 +45,7 @@ directory: ${process.env.PWD}/${options.dir}
 configServer: ${options.configServer ? options.configServer : 'none'}
 mode: ${options.mode}
 port: ${options.mode === 'server' ? options.port : 'N/A'}
+local-config: ${options.localConfig ? options.localConfig : 'none'}
 for available options run: xfidelity --help
 =====================================`);
 logger_1.logger.info(banner);

package/dist/core/engine.js

@@ -8,6 +8,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.analyzeCodebase = analyzeCodebase;
 const logger_1 = require("../utils/logger");
@@ -19,11 +22,14 @@ 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"));
 function analyzeCodebase(repoPath_1) {
-    return __awaiter(this, arguments, void 0, function* (repoPath, archetype = 'node-fullstack', configServer = '') {
+    return __awaiter(this, arguments, void 0, function* (repoPath, archetype = 'node-fullstack', configServer = '', localConfigPath = '') {
         const configManager = config_1.ConfigManager.getInstance();
-        yield configManager.initialize(archetype, configServer);
+        yield configManager.initialize(archetype, configServer, localConfigPath);
         const archetypeConfig = configManager.getConfig();
         const installedDependencyVersions = yield (0, repoDependencyFacts_1.getDependencyVersionFacts)(archetypeConfig);
         const fileData = yield (0, repoFilesystemFacts_1.collectRepoFileData)(repoPath, archetypeConfig);
@@ -34,16 +40,46 @@ function analyzeCodebase(repoPath_1) {
             fileContent: config_1.REPO_GLOBAL_CHECK
         });
         const { minimumDependencyVersions, standardStructure } = archetypeConfig.config;
-        const openaiSystemPrompt = yield (0, openaiAnalysisFacts_1.collectOpenaiAnalysisFacts)(fileData);
+        let openaiSystemPrompt;
+        if ((0, openaiUtils_1.isOpenAIEnabled)()) {
+            openaiSystemPrompt = yield (0, openaiAnalysisFacts_1.collectOpenaiAnalysisFacts)(fileData);
+        }
         const engine = new json_rules_engine_1.Engine([], { replaceFactsInEventParams: true, allowUndefinedFacts: true });
+        // Get GitHub repository URL
+        let repoUrl = '';
+        try {
+            repoUrl = (0, child_process_1.execSync)('git config --get remote.origin.url', { cwd: repoPath }).toString().trim();
+        }
+        catch (error) {
+            logger_1.logger.warn('Unable to get GitHub repository URL');
+        }
+        // Get host information
+        const hostInfo = {
+            platform: os_1.default.platform(),
+            release: os_1.default.release(),
+            type: os_1.default.type(),
+            arch: os_1.default.arch(),
+            cpus: os_1.default.cpus().length,
+            totalMemory: os_1.default.totalmem(),
+            freeMemory: os_1.default.freemem()
+        };
+        // Get user information
+        const userInfo = {
+            username: os_1.default.userInfo().username,
+            homedir: os_1.default.userInfo().homedir,
+            shell: os_1.default.userInfo().shell
+        };
         // Send telemetry for analysis start
         yield (0, telemetry_1.sendTelemetry)({
             eventType: 'analysisStart',
             metadata: {
                 archetype,
                 repoPath,
+                repoUrl,
                 fileCount: fileData.length,
-                configServer: configServer || 'none'
+                configServer: configServer || 'none',
+                hostInfo,
+                userInfo
             },
             timestamp: new Date().toISOString()
         });
@@ -59,7 +95,7 @@ function analyzeCodebase(repoPath_1) {
         });
         // Add rules to engine
         logger_1.logger.info(`### loading json rules..`);
-        const rules = yield (0, rules_1.loadRules)(archetype, archetypeConfig.rules, configManager.configServer, logger_1.logPrefix);
+        const rules = yield (0, rules_1.loadRules)(archetype, archetypeConfig.rules, configManager.configServer, logger_1.logPrefix, configManager.localConfigPath);
         logger_1.logger.debug(rules);
         rules.forEach((rule) => {
             try {
@@ -101,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);
@@ -154,9 +190,12 @@ function analyzeCodebase(repoPath_1) {
             metadata: {
                 archetype,
                 repoPath,
+                repoUrl,
                 fileCount: fileData.length,
                 failureCount: failures.length,
-                fatalityCount: fatalities.length
+                fatalityCount: fatalities.length,
+                hostInfo,
+                userInfo
             },
             timestamp: new Date().toISOString()
         });

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 = [
@@ -80,7 +96,7 @@ describe('analyzeCodebase', () => {
         const results = yield (0, engine_1.analyzeCodebase)('mockRepoPath', 'node-fullstack');
         expect(repoFilesystemFacts_1.collectRepoFileData).toHaveBeenCalledWith('mockRepoPath', expect.any(Object));
         expect(repoDependencyFacts_1.getDependencyVersionFacts).toHaveBeenCalledWith(expect.any(Object));
-        expect(rules_1.loadRules).toHaveBeenCalledWith('node-fullstack', ['mockRule'], '', expect.any(String));
+        expect(rules_1.loadRules).toHaveBeenCalledWith('node-fullstack', ['mockRule'], '', expect.any(String), undefined);
         expect(operators_1.loadOperators).toHaveBeenCalledWith(['mockOperator']);
         expect(facts_1.loadFacts).toHaveBeenCalledWith(['mockFact']);
         expect(engineRunMock).toHaveBeenCalledTimes(mockFileData.length);
@@ -113,15 +129,15 @@ describe('analyzeCodebase', () => {
         const results = yield (0, engine_1.analyzeCodebase)('mockRepoPath', 'node-fullstack');
         expect(repoFilesystemFacts_1.collectRepoFileData).toHaveBeenCalledWith('mockRepoPath', expect.any(Object));
         expect(repoDependencyFacts_1.getDependencyVersionFacts).toHaveBeenCalled();
-        expect(rules_1.loadRules).toHaveBeenCalledWith('node-fullstack', ['mockRule'], '', expect.any(String));
+        expect(rules_1.loadRules).toHaveBeenCalledWith('node-fullstack', ['mockRule'], '', expect.any(String), undefined);
         expect(operators_1.loadOperators).toHaveBeenCalledWith(['mockOperator']);
         expect(facts_1.loadFacts).toHaveBeenCalledWith(['mockFact']);
         expect(engineRunMock).toHaveBeenCalledTimes(mockFileData.length);
         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,7 +40,8 @@ const logger_1 = require("../utils/logger");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const axios_1 = __importDefault(require("axios"));
-function loadRules(archetype, ruleNames, configServer, logPrefix) {
+const openaiUtils_1 = require("../utils/openaiUtils");
+function loadRules(archetype, ruleNames, configServer, logPrefix, localConfigPath) {
     return __awaiter(this, void 0, void 0, function* () {
         const ruleProperties = [];
         for (const ruleName of ruleNames) {
@@ -63,11 +64,17 @@ function loadRules(archetype, ruleNames, configServer, logPrefix) {
                     rule = yield loadLocalRule(ruleName);
                 }
             }
+            else if (localConfigPath) {
+                rule = yield loadLocalConfigRule(ruleName, localConfigPath);
+            }
+            else if (localConfigPath) {
+                rule = yield loadLocalConfigRule(ruleName, localConfigPath);
+            }
             else {
                 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);
                 }
             }
@@ -80,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');
@@ -95,3 +102,22 @@ function loadLocalRule(ruleName) {
         return null;
     });
 }
+function loadLocalConfigRule(ruleName, localConfigPath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const fileName = `${ruleName}-rule.json`;
+        const filePath = path.join(localConfigPath, 'rules', fileName);
+        if (!fileName.startsWith('openai') || (process.env.OPENAI_API_KEY && fileName.startsWith('openai'))) {
+            try {
+                logger_1.logger.debug(`Loading local config rule file: ${filePath}`);
+                const fileContent = yield fs.promises.readFile(filePath, 'utf8');
+                return JSON.parse(fileContent);
+            }
+            catch (error) {
+                logger_1.logger.error(`Error loading local config rule file: ${fileName}`);
+                logger_1.logger.error(error);
+                return null;
+            }
+        }
+        return null;
+    });
+}

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) => {