x-fidelity 1.8.0 → 1.9.0

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+# [1.9.0](https://github.com/zotoio/x-fidelity/compare/v1.8.0...v1.9.0) (2024-08-06)
+
+
+### Bug Fixes
+
+* **config:** local paths and config option resolutions ([52a8144](https://github.com/zotoio/x-fidelity/commit/52a81448eab3376f063f867b0ab476fbfc0e210f))
+
+
+### Features
+
+* add support for relative and absolute paths in directory and local-config options ([c67f0fe](https://github.com/zotoio/x-fidelity/commit/c67f0fe802139d9b4422cfb77bf0ed46e820f73a))
+
 # [1.8.0](https://github.com/zotoio/x-fidelity/compare/v1.7.0...v1.8.0) (2024-08-01)
 
 

package/dist/core/cli.js

@@ -1,8 +1,12 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.options = void 0;
 const logger_1 = require("../utils/logger");
 const commander_1 = require("commander");
+const path_1 = __importDefault(require("path"));
 // Ensure logger is initialized
 if (!logger_1.logger || typeof logger_1.logger.info !== 'function') {
     console.error('Logger is not properly initialized');
@@ -16,17 +20,23 @@ if (!logger_1.logger || typeof logger_1.logger.info !== 'function') {
     global.logger = fallbackLogger;
 }
 commander_1.program
-    .option("-d, --dir <directory>", "The checkout directory to analyze (default: current directory)", ".")
-    .option("-a, --archetype <archetype>", "The archetype to use for analysis (default: node-fullstack)", "node-fullstack")
+    .option("-d, --dir <directory>", "The checkout directory to analyze", ".")
+    .option("-a, --archetype <archetype>", "The archetype to use for analysis", "node-fullstack")
     .option("-c, --configServer <configServer>", "The config server URL for fetching remote archetype configurations and rules")
-    .option("-o, --openaiEnabled <boolean>", "Enable OpenAI analysis (default: false)", false)
+    .option("-o, --openaiEnabled <boolean>", "Enable OpenAI analysis", false)
     .option("-t, --telemetryCollector <telemetryCollector>", "The URL telemetry data will be sent to for usage analysis")
-    .option("-m, --mode <mode>", "Run mode: 'client' or 'server' (default: client)", "client")
-    .option("-p, --port <port>", "The port to run the server on (default: 8888)", "8888")
+    .option("-m, --mode <mode>", "Run mode: 'client' or 'server'", "client")
+    .option("-p, --port <port>", "The port to run the server on", "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;
+// Resolve paths
+const resolvePath = (inputPath) => path_1.default.resolve(process.cwd(), inputPath);
+options.dir = resolvePath(options.dir);
+if (options.localConfig) {
+    options.localConfig = resolvePath(options.localConfig);
+}
 const banner = (`
 =====================================
  __    __          ________  ______ 
@@ -38,14 +48,14 @@ const banner = (`
 | ##  | ##        | ##      |   ## \\
  \\##   \\##         \\##       \\######
                                
---------------------
+-------------------------------------
 ${new Date().toString().slice(0, 24)}
 archetype: ${options.archetype}
-directory: ${process.env.PWD}/${options.dir}
+directory: ${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'}
+localConfig: ${options.localConfig ? options.localConfig : 'none'}
 for available options run: xfidelity --help
 =====================================`);
 logger_1.logger.info(banner);

package/dist/index.js

@@ -25,7 +25,7 @@ try {
     }
     else {
         (() => __awaiter(void 0, void 0, void 0, function* () {
-            const results = yield (0, engine_1.analyzeCodebase)(`${process.env.PWD}/${cli_1.options.dir}`, cli_1.options.archetype, cli_1.options.configServer);
+            const results = yield (0, engine_1.analyzeCodebase)(cli_1.options.dir, cli_1.options.archetype, cli_1.options.configServer, cli_1.options.localConfig);
             // if results are found, there were warning level issues found in the codebase
             if (results.length > 0) {
                 logger_1.logger.warn('WARNING: lo-fi attributes detected in codebase!');

package/dist/rules/index.js

@@ -86,12 +86,12 @@ function loadLocalRule(ruleName) {
         const filePath = path.join(__dirname, fileName);
         if (!fileName.startsWith('openai') || ((0, openaiUtils_1.isOpenAIEnabled)() && fileName.startsWith('openai'))) {
             try {
-                logger_1.logger.debug(`Loading local rule file: ${filePath}`);
+                logger_1.logger.info(`Loading default rule file: ${filePath}`);
                 const fileContent = yield fs.promises.readFile(filePath, 'utf8');
                 return JSON.parse(fileContent);
             }
             catch (error) {
-                logger_1.logger.error(`FATAL: Error loading local rule file: ${fileName}`);
+                logger_1.logger.error(`FATAL: Error loading default rule file: ${fileName}`);
                 logger_1.logger.error(error);
                 return null;
             }
@@ -103,6 +103,7 @@ function loadLocalConfigRule(ruleName, localConfigPath) {
     return __awaiter(this, void 0, void 0, function* () {
         const fileName = `${ruleName}-rule.json`;
         const filePath = path.join(localConfigPath, 'rules', fileName);
+        logger_1.logger.info(`Loading local config rule file: ${filePath}`);
         if (!fileName.startsWith('openai') || (process.env.OPENAI_API_KEY && fileName.startsWith('openai'))) {
             try {
                 logger_1.logger.debug(`Loading local config rule file: ${filePath}`);

package/dist/server/configServer.js

@@ -33,7 +33,7 @@ app.get('/archetypes/:archetype', (req, res) => __awaiter(void 0, void 0, void 0
     const archetype = req.params.archetype;
     if (validInput(archetype)) {
         const configManager = config_1.ConfigManager.getInstance();
-        yield configManager.initialize(archetype);
+        yield configManager.initialize(archetype, cli_1.options.configServer, cli_1.options.localConfig);
         const archetypeConfig = configManager.getConfig();
         logger_1.logger.debug(`Found archetype ${archetype} config: ${JSON.stringify(archetypeConfig)}`);
         res.json(archetypeConfig);
@@ -53,10 +53,10 @@ app.get('/archetypes/:archetype/rules', (req, res) => __awaiter(void 0, void 0,
     const archetype = req.params.archetype;
     if (validInput(archetype)) {
         const configManager = config_1.ConfigManager.getInstance();
-        yield configManager.initialize(archetype);
+        yield configManager.initialize(archetype, cli_1.options.configServer, cli_1.options.localConfig);
         const archetypeConfig = configManager.getConfig();
         if (archetypeConfig && archetypeConfig.rules) {
-            const rules = yield (0, rules_1.loadRules)(archetype, archetypeConfig.rules);
+            const rules = yield (0, rules_1.loadRules)(archetype, archetypeConfig.rules, cli_1.options.configServer, '', cli_1.options.localConfig);
             res.json(rules);
         }
         else {
@@ -73,10 +73,10 @@ app.get('/archetypes/:archetype/rules/:rule', (req, res) => __awaiter(void 0, vo
     const rule = req.params.rule;
     if (validInput(archetype) && validInput(rule)) {
         const configManager = config_1.ConfigManager.getInstance();
-        yield configManager.initialize(archetype);
+        yield configManager.initialize(archetype, cli_1.options.configServer, cli_1.options.localConfig);
         const archetypeConfig = configManager.getConfig();
         if (archetypeConfig && archetypeConfig.rules && archetypeConfig.rules.includes(rule)) {
-            const rules = yield (0, rules_1.loadRules)(archetype, archetypeConfig.rules);
+            const rules = yield (0, rules_1.loadRules)(archetype, archetypeConfig.rules, cli_1.options.configServer, '', cli_1.options.localConfig);
             const ruleJson = rules.find((r) => r.name === rule);
             res.json(ruleJson);
         }

package/dist/utils/config.js

@@ -69,17 +69,17 @@ class ConfigManager {
             if (this.configServer) {
                 try {
                     const configUrl = `${this.configServer}/archetypes/${archetype}`;
-                    logger_1.logger.debug(`Fetching remote config from: ${configUrl}`);
+                    logger_1.logger.debug(`Fetching remote archetype config from: ${configUrl}`);
                     const response = yield axios_1.default.get(configUrl);
                     this.config = Object.assign(Object.assign({}, this.config), response.data);
-                    logger_1.logger.debug(`Remote config fetched successfully ${JSON.stringify(this.config)}`);
+                    logger_1.logger.debug(`Remote archetype config fetched successfully ${JSON.stringify(this.config)}`);
                 }
                 catch (error) {
                     if (error instanceof Error) {
-                        logger_1.logger.error(`Error fetching remote config: ${error.message}`);
+                        logger_1.logger.error(`Error fetching remote archetype config: ${error.message}`);
                     }
                     else {
-                        logger_1.logger.error('Error fetching remote config: Unknown error');
+                        logger_1.logger.error('Error fetching remote archetype config: Unknown error');
                     }
                     // If remote fetch fails, fall back to local config
                     if (this.localConfigPath) {
@@ -96,16 +96,17 @@ class ConfigManager {
         return __awaiter(this, void 0, void 0, function* () {
             try {
                 const configPath = path.join(this.localConfigPath, `${archetype}.json`);
+                logger_1.logger.info(`Loading local archetype config from: ${configPath}`);
                 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}`);
+                    logger_1.logger.error(`Error loading local archetype config: ${error.message}`);
                 }
                 else {
-                    logger_1.logger.error('Error loading local config: Unknown error');
+                    logger_1.logger.error('Error loading local archetype config: Unknown error');
                 }
                 return archetypes_1.archetypes[archetype];
             }

package/dist/xfidelity

@@ -25,7 +25,7 @@ try {
     }
     else {
         (() => __awaiter(void 0, void 0, void 0, function* () {
-            const results = yield (0, engine_1.analyzeCodebase)(`${process.env.PWD}/${cli_1.options.dir}`, cli_1.options.archetype, cli_1.options.configServer);
+            const results = yield (0, engine_1.analyzeCodebase)(cli_1.options.dir, cli_1.options.archetype, cli_1.options.configServer, cli_1.options.localConfig);
             // if results are found, there were warning level issues found in the codebase
             if (results.length > 0) {
                 logger_1.logger.warn('WARNING: lo-fi attributes detected in codebase!');

package/package.json

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

package/src/core/cli.ts

@@ -1,5 +1,6 @@
 import { logger } from '../utils/logger';
 import { program } from "commander";
+import path from "path";
 
 // Ensure logger is initialized
 if (!logger || typeof logger.info !== 'function') {
@@ -15,19 +16,26 @@ if (!logger || typeof logger.info !== 'function') {
 }
 
 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("-d, --dir <directory>", "The checkout directory to analyze", ".")
+    .option("-a, --archetype <archetype>", "The archetype to use for analysis", "node-fullstack")
     .option("-c, --configServer <configServer>", "The config server URL for fetching remote archetype configurations and rules")
-    .option("-o, --openaiEnabled <boolean>", "Enable OpenAI analysis (default: false)", false)
+    .option("-o, --openaiEnabled <boolean>", "Enable OpenAI analysis", false)
     .option("-t, --telemetryCollector <telemetryCollector>", "The URL telemetry data will be sent to for usage analysis")
-    .option("-m, --mode <mode>", "Run mode: 'client' or 'server' (default: client)", "client")
-    .option("-p, --port <port>", "The port to run the server on (default: 8888)", "8888")
+    .option("-m, --mode <mode>", "Run mode: 'client' or 'server'", "client")
+    .option("-p, --port <port>", "The port to run the server on", "8888")
     .option("-l, --localConfig <path>", "Path to local archetype config and rules");
 
 program.parse();
 
 const options = program.opts();
 
+// Resolve paths
+const resolvePath = (inputPath: string) => path.resolve(process.cwd(), inputPath);
+options.dir = resolvePath(options.dir);
+if (options.localConfig) {
+    options.localConfig = resolvePath(options.localConfig);
+}
+
 const banner = (`
 =====================================
  __    __          ________  ______ 
@@ -39,14 +47,14 @@ const banner = (`
 | ##  | ##        | ##      |   ## \\
  \\##   \\##         \\##       \\######
                                
---------------------
+-------------------------------------
 ${new Date().toString().slice(0, 24)}
 archetype: ${options.archetype}
-directory: ${process.env.PWD}/${options.dir}
+directory: ${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'}
+localConfig: ${options.localConfig ? options.localConfig : 'none'}
 for available options run: xfidelity --help
 =====================================`);
 

package/src/index.ts

@@ -12,7 +12,7 @@ try {
         startServer(options.port);
     } else {
         (async () => {
-            const results = await analyzeCodebase(`${process.env.PWD}/${options.dir}`, options.archetype, options.configServer);
+            const results = await analyzeCodebase(options.dir, options.archetype, options.configServer, options.localConfig);
 
             // if results are found, there were warning level issues found in the codebase
             if (results.length > 0) {

package/src/rules/index.ts

@@ -52,11 +52,11 @@ async function loadLocalRule(ruleName: string): Promise<RuleProperties | null> {
 
     if (!fileName.startsWith('openai') || (isOpenAIEnabled() && fileName.startsWith('openai'))) {
         try {
-            logger.debug(`Loading local rule file: ${filePath}`);
+            logger.info(`Loading default rule file: ${filePath}`);
             const fileContent = await fs.promises.readFile(filePath, 'utf8');
             return JSON.parse(fileContent);
         } catch (error) {
-            logger.error(`FATAL: Error loading local rule file: ${fileName}`);
+            logger.error(`FATAL: Error loading default rule file: ${fileName}`);
             logger.error(error);
             return null;
         }
@@ -68,6 +68,7 @@ export { loadRules };
 async function loadLocalConfigRule(ruleName: string, localConfigPath: string): Promise<RuleProperties | null> {
     const fileName = `${ruleName}-rule.json`;
     const filePath = path.join(localConfigPath, 'rules', fileName);
+    logger.info(`Loading local config rule file: ${filePath}`);
 
     if (!fileName.startsWith('openai') || (process.env.OPENAI_API_KEY && fileName.startsWith('openai'))) {
         try {

package/src/server/configServer.ts

@@ -22,7 +22,7 @@ app.get('/archetypes/:archetype', async (req, res) => {
     const archetype = req.params.archetype;
     if (validInput(archetype)) {
         const configManager = ConfigManager.getInstance();
-        await configManager.initialize(archetype);
+        await configManager.initialize(archetype, options.configServer, options.localConfig);
         const archetypeConfig = configManager.getConfig();
         logger.debug(`Found archetype ${archetype} config: ${JSON.stringify(archetypeConfig)}`);
         res.json(archetypeConfig);
@@ -43,10 +43,10 @@ app.get('/archetypes/:archetype/rules', async (req, res) => {
     const archetype = req.params.archetype;
     if (validInput(archetype)) {
         const configManager = ConfigManager.getInstance();
-        await configManager.initialize(archetype);
+        await configManager.initialize(archetype, options.configServer, options.localConfig);
         const archetypeConfig = configManager.getConfig();
         if (archetypeConfig && archetypeConfig.rules) {
-            const rules = await loadRules(archetype, archetypeConfig.rules);
+            const rules = await loadRules(archetype, archetypeConfig.rules, options.configServer, '', options.localConfig);
             res.json(rules);
         } else {
             res.status(404).json({ error: 'archetype not found or has no rules' });
@@ -62,10 +62,10 @@ app.get('/archetypes/:archetype/rules/:rule', async (req, res) => {
     const rule = req.params.rule;
     if (validInput(archetype) && validInput(rule)) {
         const configManager = ConfigManager.getInstance();
-        await configManager.initialize(archetype);
+        await configManager.initialize(archetype, options.configServer, options.localConfig);
         const archetypeConfig = configManager.getConfig();
         if (archetypeConfig && archetypeConfig.rules && archetypeConfig.rules.includes(rule)) {
-            const rules = await loadRules(archetype, archetypeConfig.rules);
+            const rules = await loadRules(archetype, archetypeConfig.rules, options.configServer, '', options.localConfig);
             const ruleJson = rules.find((r) => r.name === rule);
             res.json(ruleJson);
         } else {

package/src/utils/config.ts

@@ -41,18 +41,18 @@ export class ConfigManager {
         if (this.configServer) {
             try {
                 const configUrl = `${this.configServer}/archetypes/${archetype}`;
-                logger.debug(`Fetching remote config from: ${configUrl}`);
+                logger.debug(`Fetching remote archetype config from: ${configUrl}`);
                 const response = await axios.get(configUrl);
                 this.config = {
                     ...this.config,
                     ...response.data
                 };
-                logger.debug(`Remote config fetched successfully ${JSON.stringify(this.config)}`);
+                logger.debug(`Remote archetype config fetched successfully ${JSON.stringify(this.config)}`);
             } catch (error) {
                 if (error instanceof Error) {
-                    logger.error(`Error fetching remote config: ${error.message}`);
+                    logger.error(`Error fetching remote archetype config: ${error.message}`);
                 } else {
-                    logger.error('Error fetching remote config: Unknown error');
+                    logger.error('Error fetching remote archetype config: Unknown error');
                 }
                 // If remote fetch fails, fall back to local config
                 if (this.localConfigPath) {
@@ -68,6 +68,7 @@ export class ConfigManager {
         
         try {
             const configPath = path.join(this.localConfigPath, `${archetype}.json`);
+            logger.info(`Loading local archetype config from: ${configPath}`);
             const configContent = await fs.promises.readFile(configPath, 'utf8');
             const localConfig = JSON.parse(configContent);
             return {
@@ -76,9 +77,9 @@ export class ConfigManager {
             };
         } catch (error) {
             if (error instanceof Error) {
-                logger.error(`Error loading local config: ${error.message}`);
+                logger.error(`Error loading local archetype config: ${error.message}`);
             } else {
-                logger.error('Error loading local config: Unknown error');
+                logger.error('Error loading local archetype config: Unknown error');
             }
             return archetypes[archetype];
         }