x-fidelity 1.5.0 → 1.5.1

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+## [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

@@ -2,6 +2,24 @@
 
 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:
+   ```
+   yarn global add x-fidelity
+   export PATH="$PATH:$(yarn global bin)"
+   ```
+
+2. Run in your project directory:
+   ```
+   xfidelity
+   ```
+
+3. For more options:
+   ```
+   xfidelity --help
+   ```
+
 ```
 =====================================
  __    __          ________  ______ 

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'],
+        rules: ['sensitiveLogging-iterative', 'outdatedFramework-global', 'noDatabases-iterative', 'nonStandardDirectoryStructure-global', 'openaiAnalysisTop5-global', 'openaiAnalysisA11y-global', 'yarnLockfileCheck-global'],
         operators: ['fileContains', 'outdatedFramework', 'nonStandardDirectoryStructure', 'openaiAnalysisHighSeverity'],
         facts: ['repoFilesystemFacts', 'repoDependencyFacts', 'openaiAnalysisFacts'],
         config: {
@@ -16,10 +16,6 @@ exports.archetypes = {
                     frontend: null,
                     server: null
                 }
-                // app: {
-                //     frontend: 'required',
-                //     server: 'required'
-                // }
             },
             blacklistPatterns: [
                 '.*\\/\\..*', // dot files

package/dist/core/cli.js

@@ -9,11 +9,12 @@ if (!logger_1.logger || typeof logger_1.logger.info !== 'function') {
     process.exit(1);
 }
 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("-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");
 commander_1.program.parse();
 const options = commander_1.program.opts();
 exports.options = options;
@@ -35,6 +36,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");
@@ -20,10 +23,12 @@ const facts_1 = require("../facts");
 const rules_1 = require("../rules");
 const config_1 = require("../utils/config");
 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 +39,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 (process.env.OPENAI_API_KEY) {
+            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 +94,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 {
@@ -154,9 +189,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

@@ -80,7 +80,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,7 +113,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).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);

package/dist/rules/index.js

@@ -40,7 +40,7 @@ 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) {
+function loadRules(archetype, ruleNames, configServer, logPrefix, localConfigPath) {
     return __awaiter(this, void 0, void 0, function* () {
         const ruleProperties = [];
         for (const ruleName of ruleNames) {
@@ -63,6 +63,12 @@ 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);
             }
@@ -95,3 +101,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/utils/config.js

@@ -1,4 +1,27 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -16,12 +39,15 @@ exports.ConfigManager = exports.REPO_GLOBAL_CHECK = void 0;
 const axios_1 = __importDefault(require("axios"));
 const logger_1 = require("../utils/logger");
 const archetypes_1 = require("../archetypes");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
 exports.REPO_GLOBAL_CHECK = 'REPO_GLOBAL_CHECK';
 class ConfigManager {
     constructor() {
         this.config = archetypes_1.archetypes['node-fullstack'];
         this.rules = [];
         this.configServer = '';
+        this.localConfigPath = '';
     }
     static getInstance() {
         if (!ConfigManager.instance) {
@@ -30,10 +56,26 @@ class ConfigManager {
         return ConfigManager.instance;
     }
     initialize() {
-        return __awaiter(this, arguments, void 0, function* (archetype = 'node-fullstack', configServer) {
+        return __awaiter(this, arguments, void 0, function* (archetype = 'node-fullstack', configServer, localConfigPath) {
             this.config = archetypes_1.archetypes[archetype] || archetypes_1.archetypes['node-fullstack'];
             this.configServer = configServer || '';
+            this.localConfigPath = localConfigPath || '';
             logger_1.logger.debug(`Initializing config manager for archetype: ${archetype}`);
+            if (this.localConfigPath) {
+                try {
+                    const localConfig = yield this.loadLocalConfig(archetype);
+                    this.config = Object.assign(Object.assign({}, this.config), localConfig);
+                    logger_1.logger.debug(`Local config loaded successfully ${JSON.stringify(this.config)}`);
+                }
+                catch (error) {
+                    if (error instanceof Error) {
+                        logger_1.logger.error(`Error loading local config: ${error.message}`);
+                    }
+                    else {
+                        logger_1.logger.error('Error loading local config: Unknown error');
+                    }
+                }
+            }
             if (this.configServer) {
                 try {
                     const configUrl = `${this.configServer}/archetypes/${archetype}`;
@@ -53,6 +95,25 @@ class ConfigManager {
             }
         });
     }
+    loadLocalConfig(archetype) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const configPath = path.join(this.localConfigPath, `${archetype}.json`);
+            try {
+                const configContent = yield fs.promises.readFile(configPath, 'utf8');
+                const localConfig = JSON.parse(configContent);
+                return Object.assign(Object.assign({}, archetypes_1.archetypes[archetype]), localConfig);
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    logger_1.logger.error(`Error loading local config: ${error.message}`);
+                }
+                else {
+                    logger_1.logger.error('Error loading local config: Unknown error');
+                }
+                return archetypes_1.archetypes[archetype];
+            }
+        });
+    }
     getConfig() {
         return this.config;
     }

package/dist/utils/telemetry.js

@@ -15,15 +15,34 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.sendTelemetry = sendTelemetry;
 const axios_1 = __importDefault(require("axios"));
 const logger_1 = require("./logger");
-const TELEMETRY_ENDPOINT = process.env.TELEMETRY_ENDPOINT || 'https://example.com/telemetry';
+const cli_1 = require("../core/cli");
+const TELEMETRY_ENDPOINT = process.env.TELEMETRY_ENDPOINT || (cli_1.options.configServer ? `${cli_1.options.configServer}/telemetry` : '');
 function sendTelemetry(event) {
     return __awaiter(this, void 0, void 0, function* () {
+        if (!TELEMETRY_ENDPOINT) {
+            logger_1.logger.debug('Telemetry endpoint not set. Skipping telemetry');
+            return;
+        }
         try {
-            yield axios_1.default.post(TELEMETRY_ENDPOINT, event);
+            yield axios_1.default.post(TELEMETRY_ENDPOINT, event, {
+                timeout: 5000, // 5 seconds timeout
+                headers: {
+                    'Content-Type': 'application/json',
+                    'User-Agent': 'x-fidelity-telemetry'
+                }
+            });
             logger_1.logger.debug(`Telemetry sent: ${JSON.stringify(event)}`);
         }
         catch (error) {
-            logger_1.logger.debug(`Failed to send telemetry: ${error}`);
+            if (axios_1.default.isAxiosError(error)) {
+                logger_1.logger.error(`Failed to send telemetry: ${error.message}`);
+                if (error.response) {
+                    logger_1.logger.error(`Response status: ${error.response.status}`);
+                }
+            }
+            else {
+                logger_1.logger.error(`Failed to send telemetry: ${error}`);
+            }
         }
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "x-fidelity",
-  "version": "1.5.0",
+  "version": "1.5.1",
   "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'],
+        rules: ['sensitiveLogging-iterative', 'outdatedFramework-global', 'noDatabases-iterative', 'nonStandardDirectoryStructure-global', 'openaiAnalysisTop5-global', 'openaiAnalysisA11y-global', 'yarnLockfileCheck-global'],
         operators: ['fileContains', 'outdatedFramework', 'nonStandardDirectoryStructure', 'openaiAnalysisHighSeverity'],
         facts: ['repoFilesystemFacts', 'repoDependencyFacts', 'openaiAnalysisFacts'],
         config: {
@@ -15,10 +15,6 @@ export const archetypes: Record<string, ArchetypeConfig> = {
                     frontend: null,
                     server: null
                 }
-                // app: {
-                //     frontend: 'required',
-                //     server: 'required'
-                // }
             },
             blacklistPatterns: [
                 '.*\\/\\..*', // dot files

package/src/core/cli.ts

@@ -8,11 +8,12 @@ if (!logger || typeof logger.info !== 'function') {
 }
 
 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("-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");
 
 program.parse();
 
@@ -36,6 +37,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
 =====================================`);
 

package/src/core/engine.test.ts

@@ -76,7 +76,7 @@ describe('analyzeCodebase', () => {
 
         expect(collectRepoFileData).toHaveBeenCalledWith('mockRepoPath', expect.any(Object));
         expect(getDependencyVersionFacts).toHaveBeenCalledWith(expect.any(Object));
-        expect(loadRules).toHaveBeenCalledWith('node-fullstack', ['mockRule'], '', expect.any(String));
+        expect(loadRules).toHaveBeenCalledWith('node-fullstack', ['mockRule'], '', expect.any(String), undefined);
         expect(loadOperators).toHaveBeenCalledWith(['mockOperator']);
         expect(loadFacts).toHaveBeenCalledWith(['mockFact']);
         expect(engineRunMock).toHaveBeenCalledTimes(mockFileData.length);
@@ -114,7 +114,7 @@ describe('analyzeCodebase', () => {
 
         expect(collectRepoFileData).toHaveBeenCalledWith('mockRepoPath', expect.any(Object));
         expect(getDependencyVersionFacts).toHaveBeenCalled();
-        expect(loadRules).toHaveBeenCalledWith('node-fullstack', ['mockRule'], '', expect.any(String));
+        expect(loadRules).toHaveBeenCalledWith('node-fullstack', ['mockRule'], '', expect.any(String), undefined);
         expect(loadOperators).toHaveBeenCalledWith(['mockOperator']);
         expect(loadFacts).toHaveBeenCalledWith(['mockFact']);
         expect(engineRunMock).toHaveBeenCalledTimes(mockFileData.length);

package/src/core/engine.ts

@@ -9,10 +9,12 @@ import { loadFacts } from '../facts';
 import { loadRules } from '../rules';
 import { ConfigManager, REPO_GLOBAL_CHECK } from '../utils/config';
 import { sendTelemetry } from '../utils/telemetry';
+import { execSync } from 'child_process';
+import os from 'os';
 
-async function analyzeCodebase(repoPath: string, archetype: string = 'node-fullstack', configServer: string = ''): Promise<any[]> {
+async function analyzeCodebase(repoPath: string, archetype: string = 'node-fullstack', configServer: string = '', localConfigPath: string = ''): Promise<any[]> {
     const configManager = ConfigManager.getInstance();
-    await configManager.initialize(archetype, configServer);
+    await configManager.initialize(archetype, configServer, localConfigPath);
     const archetypeConfig = configManager.getConfig();
 
     const installedDependencyVersions = await getDependencyVersionFacts(archetypeConfig);
@@ -26,18 +28,51 @@ async function analyzeCodebase(repoPath: string, archetype: string = 'node-fulls
     });
 
     const { minimumDependencyVersions, standardStructure } = archetypeConfig.config;
-    const openaiSystemPrompt = await collectOpenaiAnalysisFacts(fileData);
+
+    let openaiSystemPrompt; 
+    if (process.env.OPENAI_API_KEY) {
+        openaiSystemPrompt = await collectOpenaiAnalysisFacts(fileData);
+    }    
 
     const engine = new Engine([], { replaceFactsInEventParams: true, allowUndefinedFacts: true });
 
+    // Get GitHub repository URL
+    let repoUrl = '';
+    try {
+        repoUrl = execSync('git config --get remote.origin.url', { cwd: repoPath }).toString().trim();
+    } catch (error) {
+        logger.warn('Unable to get GitHub repository URL');
+    }
+
+    // Get host information
+    const hostInfo = {
+        platform: os.platform(),
+        release: os.release(),
+        type: os.type(),
+        arch: os.arch(),
+        cpus: os.cpus().length,
+        totalMemory: os.totalmem(),
+        freeMemory: os.freemem()
+    };
+
+    // Get user information
+    const userInfo = {
+        username: os.userInfo().username,
+        homedir: os.userInfo().homedir,
+        shell: os.userInfo().shell
+    };
+
     // Send telemetry for analysis start
     await sendTelemetry({
         eventType: 'analysisStart',
         metadata: {
             archetype,
             repoPath,
+            repoUrl,
             fileCount: fileData.length,
-            configServer: configServer || 'none'
+            configServer: configServer || 'none',
+            hostInfo,
+            userInfo
         },
         timestamp: new Date().toISOString()
     });
@@ -54,7 +89,7 @@ async function analyzeCodebase(repoPath: string, archetype: string = 'node-fulls
 
     // Add rules to engine
     logger.info(`### loading json rules..`);
-    const rules: RuleProperties[] = await loadRules(archetype, archetypeConfig.rules, configManager.configServer, logPrefix);
+    const rules: RuleProperties[] = await loadRules(archetype, archetypeConfig.rules, configManager.configServer, logPrefix, configManager.localConfigPath);
     logger.debug(rules);
 
     rules.forEach((rule) => {
@@ -165,9 +200,12 @@ async function analyzeCodebase(repoPath: string, archetype: string = 'node-fulls
         metadata: {
             archetype,
             repoPath,
+            repoUrl,
             fileCount: fileData.length,
             failureCount: failures.length,
-            fatalityCount: fatalities.length
+            fatalityCount: fatalities.length,
+            hostInfo,
+            userInfo
         },
         timestamp: new Date().toISOString()
     });

package/src/rules/index.ts

@@ -5,7 +5,7 @@ import * as path from 'path';
 import axios from 'axios';
 import { options } from "../core/cli";
 
-async function loadRules(archetype: any, ruleNames: string[], configServer?: string, logPrefix?: string): Promise<RuleProperties[]> {
+async function loadRules(archetype: string, ruleNames: string[], configServer?: string, logPrefix?: string, localConfigPath?: string): Promise<RuleProperties[]> {
     
     const ruleProperties: RuleProperties[] = [];
 
@@ -28,6 +28,10 @@ async function loadRules(archetype: any, ruleNames: string[], configServer?: str
                 // If remote fetch fails, fall back to local file
                 rule = await loadLocalRule(ruleName);
             }
+        } else if (localConfigPath) {
+            rule = await loadLocalConfigRule(ruleName, localConfigPath);
+        } else if (localConfigPath) {
+            rule = await loadLocalConfigRule(ruleName, localConfigPath);
         } else {
             rule = await loadLocalRule(ruleName);
         }
@@ -63,3 +67,20 @@ async function loadLocalRule(ruleName: string): Promise<RuleProperties | null> {
 }
 
 export { loadRules };
+async function loadLocalConfigRule(ruleName: string, localConfigPath: string): Promise<RuleProperties | null> {
+    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.debug(`Loading local config rule file: ${filePath}`);
+            const fileContent = await fs.promises.readFile(filePath, 'utf8');
+            return JSON.parse(fileContent);
+        } catch (error) {
+            logger.error(`Error loading local config rule file: ${fileName}`);
+            logger.error(error);
+            return null;
+        }
+    }
+    return null;
+}

package/src/utils/config.ts

@@ -4,6 +4,8 @@ import { logger, logPrefix } 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';
 
 export const REPO_GLOBAL_CHECK = 'REPO_GLOBAL_CHECK';
 
@@ -12,11 +14,13 @@ export class ConfigManager {
     private config: ArchetypeConfig;
     private rules: any[];
     public configServer: string;
+    public localConfigPath: string;
 
     private constructor() {
         this.config = archetypes['node-fullstack'];
         this.rules = [];
         this.configServer = '';
+        this.localConfigPath = '';
     }
 
     public static getInstance(): ConfigManager {
@@ -26,10 +30,29 @@ export class ConfigManager {
         return ConfigManager.instance;
     }
 
-    public async initialize(archetype: string = 'node-fullstack', configServer?: string): Promise<void> {
+    public async initialize(archetype: string = 'node-fullstack', configServer?: string, localConfigPath?: string): Promise<void> {
         this.config = archetypes[archetype] || archetypes['node-fullstack'];
         this.configServer = configServer || '';
+        this.localConfigPath = localConfigPath || '';
         logger.debug(`Initializing config manager for archetype: ${archetype}`);
+        
+        if (this.localConfigPath) {
+            try {
+                const localConfig = await this.loadLocalConfig(archetype);
+                this.config = {
+                    ...this.config,
+                    ...localConfig
+                };
+                logger.debug(`Local config loaded successfully ${JSON.stringify(this.config)}`);
+            } catch (error) {
+                if (error instanceof Error) {
+                    logger.error(`Error loading local config: ${error.message}`);
+                } else {
+                    logger.error('Error loading local config: Unknown error');
+                }
+            }
+        }
+
         if (this.configServer) {
             try {
                 const configUrl = `${this.configServer}/archetypes/${archetype}`;
@@ -48,7 +71,25 @@ export class ConfigManager {
                 }
             }
         }
+    }
 
+    private async loadLocalConfig(archetype: string): Promise<ArchetypeConfig> {
+        const configPath = path.join(this.localConfigPath, `${archetype}.json`);
+        try {
+            const configContent = await fs.promises.readFile(configPath, 'utf8');
+            const localConfig = JSON.parse(configContent);
+            return {
+                ...archetypes[archetype],
+                ...localConfig
+            };
+        } catch (error) {
+            if (error instanceof Error) {
+                logger.error(`Error loading local config: ${error.message}`);
+            } else {
+                logger.error('Error loading local config: Unknown error');
+            }
+            return archetypes[archetype];
+        }
     }
 
     public getConfig(): ArchetypeConfig {

package/src/utils/telemetry.ts

@@ -1,5 +1,6 @@
 import axios from 'axios';
 import { logger } from './logger';
+import { options } from "../core/cli";
 
 interface TelemetryEvent {
     eventType: string;
@@ -11,13 +12,30 @@ interface TelemetryEvent {
     timestamp: string;
 }
 
-const TELEMETRY_ENDPOINT = process.env.TELEMETRY_ENDPOINT || 'https://example.com/telemetry';
+const TELEMETRY_ENDPOINT = process.env.TELEMETRY_ENDPOINT || (options.configServer ? `${options.configServer}/telemetry` : '');
 
 export async function sendTelemetry(event: TelemetryEvent): Promise<void> {
+    if (!TELEMETRY_ENDPOINT) {
+        logger.debug('Telemetry endpoint not set. Skipping telemetry');
+        return;
+    }
     try {
-        await axios.post(TELEMETRY_ENDPOINT, event);
+        await axios.post(TELEMETRY_ENDPOINT, event, {
+            timeout: 5000, // 5 seconds timeout
+            headers: {
+                'Content-Type': 'application/json',
+                'User-Agent': 'x-fidelity-telemetry'
+            }
+        });
         logger.debug(`Telemetry sent: ${JSON.stringify(event)}`);
     } catch (error) {
-        logger.debug(`Failed to send telemetry: ${error}`);
+        if (axios.isAxiosError(error)) {
+            logger.error(`Failed to send telemetry: ${error.message}`);
+            if (error.response) {
+                logger.error(`Response status: ${error.response.status}`);
+            }
+        } else {
+            logger.error(`Failed to send telemetry: ${error}`);
+        }
     }
 }