x-fidelity 1.0.0

package/dist/facts/repoFilesystemFacts.js

@@ -0,0 +1,91 @@
+"use strict";
+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) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        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.collectStandardDirectoryStructure = exports.collectRepoFileData = void 0;
+const logger_1 = require("../utils/logger");
+const axios_1 = __importDefault(require("axios"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function parseFile(filePath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return Promise.resolve({
+            fileName: path_1.default.basename(filePath),
+            filePath,
+            fileContent: fs_1.default.readFileSync(filePath, 'utf8')
+        });
+    });
+}
+function collectRepoFileData(repoPath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const filesData = [];
+        logger_1.logger.debug(`collectingRepoFileData from: ${repoPath}`);
+        const files = fs_1.default.readdirSync(repoPath);
+        for (const file of files) {
+            const filePath = path_1.default.join(repoPath, file);
+            if (!ignored(filePath)) {
+                const stats = yield fs_1.default.promises.lstat(filePath);
+                if (stats.isDirectory()) {
+                    const dirFilesData = yield collectRepoFileData(filePath);
+                    filesData.push(...dirFilesData);
+                }
+                else {
+                    const fileData = yield parseFile(filePath);
+                    filesData.push(fileData);
+                }
+            }
+        }
+        return filesData;
+    });
+}
+exports.collectRepoFileData = collectRepoFileData;
+function ignored(file) {
+    return file.startsWith('.')
+        || file.includes('node_modules')
+        || file.includes('/.')
+        || file.endsWith('-rule.json')
+        || file.includes('/dist/')
+        || file.includes('/lcov')
+        || file.startsWith('dist')
+        || file.endsWith('md')
+        || file.endsWith('.log')
+        || file.includes('LICENSE');
+}
+const standardStructure = {
+    "src": {
+        "core": null,
+        "utils": null,
+        "operators": null,
+        "rules": null,
+        "facts": null,
+        "FAIL": null
+    }
+};
+function collectStandardDirectoryStructure(configUrl) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (configUrl) {
+            try {
+                const response = yield axios_1.default.get(configUrl);
+                return response.data.standardStructure;
+            }
+            catch (error) {
+                logger_1.logger.error(`Error fetching standard structure from configUrl: ${error}`);
+                return standardStructure;
+            }
+        }
+        else {
+            return standardStructure;
+        }
+    });
+}
+exports.collectStandardDirectoryStructure = collectStandardDirectoryStructure;

package/dist/index.js

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+"use strict";
+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) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const logger_1 = require("./utils/logger");
+let json = require('format-json');
+const cli_1 = require("./core/cli");
+const engine_1 = require("./core/engine");
+//console.log(`analyzing repo at path: [${options.dir}]`);
+try {
+    (() => __awaiter(void 0, void 0, void 0, function* () {
+        let results = yield (0, engine_1.analyzeCodebase)(cli_1.options.dir, cli_1.options.configUrl);
+        if (results.length > 0) {
+            //console.log('WARNING: lo-fi attributes detected in codebase!');
+            //console.log(results);
+        }
+        else {
+            //console.log('hi-fi codebase detected!');
+        }
+        logger_1.logger.info(results);
+        console.log(JSON.stringify(results));
+        //console.log(`opinionated codebase analysis completed with ${results.length} failed checks.`);
+    }))().catch((e) => { console.log(e); });
+}
+catch (e) {
+    console.log(e);
+}

package/dist/operators/currentDependencies.js

@@ -0,0 +1,58 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.currentDependencies = void 0;
+const logger_1 = require("../utils/logger");
+const semver = __importStar(require("semver"));
+const currentDependencies = {
+    'name': 'currentDependencies',
+    'fn': (filePath, dependencyData) => {
+        let result = false;
+        // this is a special rule we only run on the root package.json, however it checks the entire dependency tree.
+        if (filePath !== 'package.json') {
+            return true;
+        }
+        logger_1.logger.debug(`currentDependencies: working..`);
+        try {
+            logger_1.logger.debug(`currentDependencies: processing ${dependencyData.installedDependencyVersions}`);
+            dependencyData.installedDependencyVersions.map((versionData) => {
+                logger_1.logger.debug(`currentDependencies: checking ${versionData.dep}`);
+                const requiredRange = new semver.Range(versionData.min);
+                if (!semver.gtr(versionData.ver, requiredRange)) {
+                    let msg = `dependency ${versionData.dep} is outdated. Current version: ${versionData.ver}, required: ${versionData.min}`;
+                    logger_1.logger.error(`currentDependencies: ${msg}`);
+                    throw new Error(msg);
+                }
+            });
+            result = true;
+        }
+        catch (e) {
+            result = false;
+        }
+        logger_1.logger.debug(`currentDependencies: ${result}`);
+        return result;
+    }
+};
+exports.currentDependencies = currentDependencies;

package/dist/operators/currentDependencies.test.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const logger_1 = require("../utils/logger");
+const currentDependencies_1 = require("./currentDependencies");
+describe('currentDependencies', () => {
+    it('returns true when filePath is not package.json', () => {
+        const filePath = 'notPackage.json';
+        const dependencyData = {};
+        expect(currentDependencies_1.currentDependencies.fn(filePath, JSON.stringify(dependencyData))).toBe(true);
+    });
+    it('returns true when all dependencies are up-to-date', () => {
+        const filePath = 'package.json';
+        const dependencyData = {
+            installedDependencyVersions: [
+                { dep: 'dep1', ver: '2.0.0', min: '1.0.0' },
+                { dep: 'dep2', ver: '3.0.0', min: '2.0.0' }
+            ]
+        };
+        expect(currentDependencies_1.currentDependencies.fn(filePath, dependencyData)).toBe(true);
+    });
+    it('returns false when at least one dependency is outdated', () => {
+        const filePath = 'package.json';
+        const dependencyData = {
+            installedDependencyVersions: [
+                { dep: 'dep1', ver: '.0.0', min: '1.0.0' },
+                { dep: 'dep2', ver: '1.0.0', min: '2.0.0' }
+            ]
+        };
+        expect(currentDependencies_1.currentDependencies.fn(filePath, dependencyData)).toBe(false);
+    });
+    it('logs an error when at least one dependency is outdated', () => {
+        const filePath = 'package.json';
+        const dependencyData = {
+            installedDependencyVersions: [
+                { dep: 'dep1', ver: '1.0.0', min: '1.0.0' },
+                { dep: 'dep2', ver: '1.0.0', min: '2.0.0' }
+            ]
+        };
+        const errorSpy = jest.spyOn(logger_1.logger, 'error');
+        currentDependencies_1.currentDependencies.fn(filePath, dependencyData);
+        expect(errorSpy).toHaveBeenCalled();
+    });
+});

package/dist/operators/directoryStructureMatches.js

@@ -0,0 +1,63 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.directoryStructureMatches = void 0;
+const logger_1 = require("../utils/logger");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+let hasChecked = false;
+const directoryStructureMatches = {
+    'name': 'directoryStructureMatches',
+    'fn': (filePath, standardStructure) => {
+        if (filePath !== 'yarn.lock' || hasChecked) {
+            return true;
+        }
+        const repoPath = path.dirname(filePath);
+        let result = true;
+        // check the directory structure of the repo against the standard structure
+        function checkStructure(currentPath, structure) {
+            for (const key in structure) {
+                const newPath = path.join(currentPath, key);
+                logger_1.logger.debug(`checking ${newPath}`);
+                if (!fs.existsSync(newPath) || !fs.lstatSync(newPath).isDirectory()) {
+                    logger_1.logger.debug(`Missing or invalid directory: ${newPath}`);
+                    return false;
+                }
+                else {
+                    result = checkStructure(newPath, structure[key]);
+                }
+            }
+            return result;
+        }
+        const checkResult = checkStructure(repoPath, standardStructure);
+        //console.log(checkResult)
+        if (!checkResult) {
+            result = false;
+        }
+        hasChecked = true;
+        return result;
+    }
+};
+exports.directoryStructureMatches = directoryStructureMatches;

package/dist/operators/directoryStructureMatches.test.js

@@ -0,0 +1,61 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const directoryStructureMatches_1 = require("./directoryStructureMatches");
+jest.mock('fs');
+jest.mock('path');
+describe('directoryStructureMatches', () => {
+    const mockedFs = fs;
+    const mockedPath = path;
+    beforeEach(() => {
+        mockedFs.existsSync.mockReset();
+        mockedFs.lstatSync.mockReset();
+        mockedPath.dirname.mockReset();
+        mockedPath.join.mockReset();
+    });
+    it('should return true if filePath is not "yarn.lock" or hasChecked is true', () => {
+        const result = directoryStructureMatches_1.directoryStructureMatches.fn('notYarn.lock', {});
+        expect(result).toBe(true);
+    });
+    // ...
+    it('should return true if directory structure matches the standard structure', () => {
+        mockedPath.dirname.mockReturnValue('/repo');
+        mockedPath.join.mockImplementation((...args) => args.join('/'));
+        mockedFs.existsSync.mockReturnValue(true);
+        mockedFs.lstatSync.mockReturnValue({ isDirectory: () => true });
+        const result = directoryStructureMatches_1.directoryStructureMatches.fn('yarn.lock', { dir1: null, dir2: { subdir1: null } });
+        expect(result).toBe(true);
+    });
+    // it('should return false if directory structure does not match the standard structure', () => {
+    //     mockedPath.dirname.mockReturnValue('/repo');
+    //     mockedPath.join.mockImplementation((...args) => args.join('/'));
+    //     mockedFs.existsSync.mockReturnValue(false);
+    //     mockedFs.lstatSync.mockReturnValue({ isDirectory: () => false } as Stats);
+    //     const result = directoryStructureMatches.fn('yarn.lock', { dir1: null, dir2: { subdir1: null } });
+    //     expect(result).toBe(false);
+    // });
+});

package/dist/operators/fileContains.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fileContains = void 0;
+const logger_1 = require("../utils/logger");
+const fileContains = {
+    'name': 'fileContains',
+    'fn': (fileContent, checkString) => {
+        let result = false;
+        const regex = new RegExp(checkString, 'g');
+        if (regex.test(fileContent)) {
+            result = true;
+        }
+        logger_1.logger.debug(`fileContains '${checkString}': ${result}`);
+        return result;
+    }
+};
+exports.fileContains = fileContains;

package/dist/operators/fileContains.test.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fileContains_1 = require("./fileContains");
+describe('fileContains', () => {
+    it('returns true when the checkString is found in the fileContent', () => {
+        const fileContent = 'Hello, world!';
+        const checkString = 'world';
+        expect(fileContains_1.fileContains.fn(fileContent, checkString)).toBe(true);
+    });
+    it('returns false when the checkString is not found in the fileContent', () => {
+        const fileContent = 'Hello, world!';
+        const checkString = 'universe';
+        expect(fileContains_1.fileContains.fn(fileContent, checkString)).toBe(false);
+    });
+    it('returns true when the checkString is a regular expression that matches part of the fileContent', () => {
+        const fileContent = 'Hello, world!';
+        const checkString = '\\bworld\\b';
+        expect(fileContains_1.fileContains.fn(fileContent, checkString)).toBe(true);
+    });
+    it('returns false when the checkString is a regular expression that does not match any part of the fileContent', () => {
+        const fileContent = 'Hello, world!';
+        const checkString = '\\buniverse\\b';
+        expect(fileContains_1.fileContains.fn(fileContent, checkString)).toBe(false);
+    });
+});

package/dist/operators/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.operators = void 0;
+const currentDependencies_1 = require("./currentDependencies");
+const fileContains_1 = require("./fileContains");
+const directoryStructureMatches_1 = require("./directoryStructureMatches");
+let operators = [];
+exports.operators = operators;
+operators.push(currentDependencies_1.currentDependencies);
+operators.push(fileContains_1.fileContains);
+operators.push(directoryStructureMatches_1.directoryStructureMatches);

package/dist/rules/index.js

@@ -0,0 +1,61 @@
+"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) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadRules = void 0;
+const logger_1 = require("../utils/logger");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+let rules = [];
+// import each json file in local directory and add to rules array as a RuleProperties object
+function loadRules() {
+    return __awaiter(this, void 0, void 0, function* () {
+        logger_1.logger.debug(`loading json rules..`);
+        const ruleFiles = (yield fs.promises.readdir(__dirname)).filter(file => file.endsWith('.json'));
+        logger_1.logger.debug(`found ${ruleFiles.length} rule files to load.`);
+        const rules = yield Promise.all(ruleFiles.map((file) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                logger_1.logger.debug(`loading ${file}...`);
+                const rule = yield Promise.resolve(`${path.join(__dirname, file)}`).then(s => __importStar(require(s)));
+                return rule;
+            }
+            catch (e) {
+                logger_1.logger.error(`FATAL: Error loading rule file: ${file}`);
+                logger_1.logger.error(e);
+                console.error(e);
+            }
+        })));
+        return rules;
+    });
+}
+exports.loadRules = loadRules;

package/dist/rules/noDatabases-rule.json

@@ -0,0 +1,21 @@
+{
+    "name": "noDatabases",
+    "conditions": {
+        "not": {
+            "any": [
+                {
+                    "fact": "fileData",
+                    "path": "$.fileContent",
+                    "operator": "fileContains",
+                    "value": "oracle"
+                }
+            ]
+        }
+    },
+    "event": {
+        "type": "violation",
+        "params": {
+            "message": "noDatabases: code must not directly call databases"
+        }
+    }
+}

package/dist/rules/standardDirectoryStructure-rule.json

@@ -0,0 +1,25 @@
+{
+    "name": "standardDirectoryStructure",
+    "conditions": {
+        "all": [
+            {
+                "fact": "fileData",
+                "path": "$.filePath",
+                "operator": "directoryStructureMatches",
+                "value": {
+                    "fact": "standardStructure"
+                }
+            }
+        ]
+    },
+    "event": {
+        "type": "violation",
+        "params": {
+            "message": "The directory structure does not match the standard.",
+            "details": {
+                "fact": "fileData",
+                "path": "$.filePath"
+            }
+        }
+    }
+}

package/dist/rules/supportedCoreDependencies-rule.json

@@ -0,0 +1,29 @@
+{
+    "name": "supportedCoreDependencies",
+    "conditions": {
+        "all": [
+            {
+                "fact": "fileData",
+                "path": "$.filePath",
+                "operator": "currentDependencies",
+                "value": {
+                    "fact": "dependencyData"
+                }
+            }    
+        ]
+    },
+    "event": {
+        "type": "violation",
+        "params": {
+            "message": "some important dependencies have expired!",
+            "filePath": {
+                "fact": "fileData",
+                "path": "$.filePath"
+            },
+            "minimumDependencyVersions": {
+                "fact": "dependencyData",
+                "path": "$.minimumDependencyVersions"
+            }
+        }
+    }
+}

package/dist/typeDefs.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/logger.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+const winston_1 = require("winston");
+const logger = (0, winston_1.createLogger)({
+    level: 'debug',
+    format: winston_1.format.combine(winston_1.format.timestamp({
+        format: 'YYYY-MM-DD HH:mm:ss.SSS ZZ'
+    }), winston_1.format.errors({ stack: true }), winston_1.format.splat(), winston_1.format.json(), winston_1.format.prettyPrint()),
+    transports: [
+        new winston_1.transports.File({ filename: 'x-fidelity.log' })
+    ]
+});
+exports.logger = logger;

package/dist/xfidelity

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+"use strict";
+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) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const logger_1 = require("./utils/logger");
+let json = require('format-json');
+const cli_1 = require("./core/cli");
+const engine_1 = require("./core/engine");
+//console.log(`analyzing repo at path: [${options.dir}]`);
+try {
+    (() => __awaiter(void 0, void 0, void 0, function* () {
+        let results = yield (0, engine_1.analyzeCodebase)(cli_1.options.dir, cli_1.options.configUrl);
+        if (results.length > 0) {
+            //console.log('WARNING: lo-fi attributes detected in codebase!');
+            //console.log(results);
+        }
+        else {
+            //console.log('hi-fi codebase detected!');
+        }
+        logger_1.logger.info(results);
+        console.log(JSON.stringify(results));
+        //console.log(`opinionated codebase analysis completed with ${results.length} failed checks.`);
+    }))().catch((e) => { console.log(e); });
+}
+catch (e) {
+    console.log(e);
+}

package/jest.config.js

@@ -0,0 +1,6 @@
+/** @type {import('ts-jest').JestConfigWithTsJest} */
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  roots: ["<rootDir>/src/"]
+};