x-fidelity 1.0.0

package/.czrc

@@ -0,0 +1,3 @@
+{
+  "path": "cz-conventional-changelog"
+}

package/.github/dependabot.yml

@@ -0,0 +1,11 @@
+# To get started with Dependabot version updates, you'll need to specify which
+# package ecosystems to update and where the package manifests are located.
+# Please see the documentation for all configuration options:
+# https://docs.github.com/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file
+
+version: 2
+updates:
+  - package-ecosystem: "npm" # See documentation for possible values
+    directory: "/" # Location of package manifests
+    schedule:
+      interval: "weekly"

package/.github/workflows/ci.yml

@@ -0,0 +1,28 @@
+name: CI
+
+on:
+  pull_request:
+    branches:
+      - master
+  push:
+    branches:
+      - master    
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v2
+
+    - name: Set up Node.js
+      uses: actions/setup-node@v2
+      with:
+        node-version: '20'
+
+    - name: Install dependencies
+      run: yarn install
+
+    - name: Run tests
+      run: yarn test

package/.github/workflows/release.yml

@@ -0,0 +1,34 @@
+name: Release
+
+on:
+  push:
+    branches:
+      - master
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v2
+
+    - name: Set up Node.js
+      uses: actions/setup-node@v2
+      with:
+        node-version: '20'
+
+    - name: Install dependencies
+      run: yarn install
+
+    - name: Run Build
+      run: yarn build  
+
+    - name: Run tests
+      run: yarn test  
+
+    - name: Run semantic-release
+      run: npx semantic-release
+      env:
+        GH_TOKEN: ${{ secrets.GH_TOKEN }}
+        NPM_TOKEN: ${{ secrets.NPM_TOKEN }}

package/.releaserc

@@ -0,0 +1,11 @@
+{
+  "branches": ["master"],
+  "plugins": [
+    "@semantic-release/commit-analyzer",
+    "@semantic-release/release-notes-generator",
+    "@semantic-release/changelog",
+    "@semantic-release/npm",
+    "@semantic-release/github",
+    "@semantic-release/git"
+  ]
+}

package/CHANGELOG.md

@@ -0,0 +1,20 @@
+# 1.0.0 (2024-06-15)
+
+
+### Bug Fixes
+
+* **access:** cd ([0016364](https://github.com/zotoio/x-fidelity/commit/0016364e94ca5175f46c76487363970f4378ada0))
+* **ascii:** readme fix ([86a4448](https://github.com/zotoio/x-fidelity/commit/86a444809f502ac60aad7076fb09b3674a32750a))
+* **ci:** branch name ([858a3cd](https://github.com/zotoio/x-fidelity/commit/858a3cd1f0f0290fed88ce70806e96eff65ecd69))
+* **ci:** node version ([8da6d00](https://github.com/zotoio/x-fidelity/commit/8da6d004eb73109daaad9c867a4aaec35a30a17f))
+* **config:** release ([ccf103c](https://github.com/zotoio/x-fidelity/commit/ccf103cfafdedd1c4bbf17ed2829bcc5392c7ab8))
+* **deps:** missing ([367c43e](https://github.com/zotoio/x-fidelity/commit/367c43e356b50560edfcace2b212c685d4a59033))
+* **pipeline:** test ([ee4a098](https://github.com/zotoio/x-fidelity/commit/ee4a0988ddf7f235fde6a454f86905b6c15ea6cf))
+* **release bin:** local install and cd ([750ab7a](https://github.com/zotoio/x-fidelity/commit/750ab7a7a71163709fde331ca17c8b17895223f2))
+* **test:** merge ([603ebc5](https://github.com/zotoio/x-fidelity/commit/603ebc58c930da0b2d8bdb465a457a02cfdbb28a))
+* **trigger:** cd ([c039356](https://github.com/zotoio/x-fidelity/commit/c039356ecd2d64724411b9333adb7078ab17a2b8))
+
+
+### Features
+
+* **pipelines:** setup gh actions ([ceca83a](https://github.com/zotoio/x-fidelity/commit/ceca83a2d0ea604dfb93a71d5a85fef4ffd8c6e7))

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 zoto.io
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,81 @@
+# x-fidelity
+
+cli for opinionated framework adherence checks
+
+```
+=====================================
+ __    __          ________  ______ 
+| ##  | ##        | ######## \######
+ \##\/  ## ______ | ##__      | ##  
+  >##  ## |      \| ##  \     | ##  
+ /  ####\  \######| ######    | ##  
+|  ## \##\        | ##       _| ##_ 
+| ##  | ##        | ##      |   ## \
+ \##   \##         \##       \######
+                               
+-------------------------------------
+```
+
+## What is x-fidelity?
+
+x-fidelity is a CLI tool designed to enforce adherence to a set of opinionated framework rules within a codebase. It checks for various conditions such as directory structure, dependency versions, and the presence of certain strings in files.
+
+## Features
+
+- Ensures the directory structure matches a predefined standard.
+- Verifies that dependencies are up-to-date according to a specified minimum version.
+- Checks for the presence or absence of specific strings in files.
+- Configurable via a remote JSON configuration file.
+
+## Installation
+
+To install x-fidelity, clone the repository and install the dependencies using yarn:
+
+```sh
+yarn global add x-fidelity
+```
+
+## Usage
+
+To run x-fidelity, use the following command:
+
+```sh
+xfidelity --dir <directory> [--configUrl <url>]
+```
+
+- `--dir <directory>`: The directory of the repository to analyze.
+- `--configUrl <url>`: (Optional) The URL to fetch the configuration from.
+
+Example:
+
+```sh
+xfidelity --dir my-repo --configUrl https://example.com/config.json
+```
+
+## Configuration
+
+The configuration file should be a JSON file containing the following structure:
+
+```json
+{
+  "minimumDependencyVersions": {
+    "commander": "^2.0.0",
+    "nodemon": "^3.9.0"
+  },
+  "standardStructure": {
+    "src": {
+      "core": null,
+      "utils": null,
+      "operators": null,
+      "rules": null,
+      "facts": null
+    }
+  }
+}
+```
+
+TODO REMOTE CONF + LLM
+
+## License
+
+This project is licensed under the MIT License.

package/commitlint.config.js

@@ -0,0 +1,3 @@
+module.exports = {
+  extends: ['@commitlint/config-conventional']
+};

package/dist/core/cli.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.options = void 0;
+const logger_1 = require("../utils/logger");
+const commander_1 = require("commander");
+const banner = (`
+=====================================
+ __    __          ________  ______ 
+| ##  | ##        | ######## \\######
+ \\##\\/  ## ______ | ##__      | ##  
+  >##  ## |      \\| ##  \\     | ##  
+ /  ####\\  \\######| ######    | ##  
+|  ## \\##\\        | ##       _| ##_ 
+| ##  | ##        | ##      |   ## \\
+ \\##   \\##         \\##       \\######
+                               
+-------------------------------------
+${new Date().toString()}`);
+console.log(banner);
+logger_1.logger.info([banner]);
+commander_1.program
+    .option("-d, --dir <directory>", "The repo checkout directory")
+    .option("-c, --configUrl <url>", "The URL used to fetch config");
+commander_1.program.parse();
+const options = commander_1.program.opts();
+exports.options = options;
+// print help if no arguments are passed
+if (commander_1.program.options.length === 0)
+    commander_1.program.help();
+if (!options.dir) {
+    console.error("Repo directory is required. Please specify the directory using the -d or --dir option.");
+    process.exit(1);
+}
+console.log(`Analysis of: ${process.env.PWD}/${options.dir}`);
+logger_1.logger.info(`Analysis of: ${process.env.PWD}/${options.dir}`);
+console.log('=====================================');
+logger_1.logger.info('=====================================');

package/dist/core/engine.js

@@ -0,0 +1,67 @@
+"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 });
+exports.analyzeCodebase = void 0;
+const logger_1 = require("../utils/logger");
+const json_rules_engine_1 = require("json-rules-engine");
+const repoFilesystemFacts_1 = require("../facts/repoFilesystemFacts");
+const rules_1 = require("../rules");
+const operators_1 = require("../operators");
+const repoDependencyFacts_1 = require("../facts/repoDependencyFacts");
+function analyzeCodebase(repoPath, configUrl) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const installedDependencyVersions = yield (0, repoDependencyFacts_1.getDependencyVersionFacts)();
+        const fileData = yield (0, repoFilesystemFacts_1.collectRepoFileData)(repoPath);
+        const minimumDependencyVersions = yield (0, repoDependencyFacts_1.collectMinimumDependencyVersions)(configUrl);
+        const standardStructure = yield (0, repoFilesystemFacts_1.collectStandardDirectoryStructure)(configUrl);
+        const engine = new json_rules_engine_1.Engine([], { replaceFactsInEventParams: true });
+        // Add operators to engine                                                                                         
+        operators_1.operators.map((operator) => engine.addOperator(operator.name, operator.fn));
+        // Add rules to engine                                                                                             
+        const rules = yield (0, rules_1.loadRules)();
+        rules.map((rule) => {
+            try {
+                engine.addRule(rule);
+            }
+            catch (e) {
+                console.error(`Error loading rule: ${rule === null || rule === void 0 ? void 0 : rule.name}`);
+                console.error(e.message);
+            }
+        });
+        engine.on('failure', function (event, almanac, ruleResult) {
+            //console.log(event)                                                                                           
+        });
+        // Run the engine for each file's data                                                                             
+        let results = [];
+        for (const file of fileData) {
+            logger_1.logger.info(`running engine for ${file.filePath}`);
+            const facts = { fileData: file, dependencyData: { installedDependencyVersions, minimumDependencyVersions },
+                standardStructure };
+            let fileFailures = [];
+            yield engine.run(facts)
+                .then(({ failureResults }) => {
+                failureResults.map((result) => {
+                    var _a;
+                    fileFailures.push({
+                        ruleFailure: result === null || result === void 0 ? void 0 : result.name,
+                        details: (_a = result === null || result === void 0 ? void 0 : result.event) === null || _a === void 0 ? void 0 : _a.params
+                    });
+                });
+            }).catch(e => logger_1.logger.error(e));
+            if (fileFailures.length > 0) {
+                results.push({ filePath: file.filePath, errors: fileFailures });
+            }
+        }
+        logger_1.logger.info(`${fileData.length} files analyzed. ${results.length} files with errors.`);
+        return results;
+    });
+}
+exports.analyzeCodebase = analyzeCodebase;

package/dist/core/engine.test.js

@@ -0,0 +1,79 @@
+"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 engine_1 = require("./engine");
+const json_rules_engine_1 = require("json-rules-engine");
+const repoFilesystemFacts_1 = require("../facts/repoFilesystemFacts");
+const repoDependencyFacts_1 = require("../facts/repoDependencyFacts");
+const rules_1 = require("../rules");
+jest.mock('json-rules-engine');
+jest.mock('../facts/repoFilesystemFacts');
+jest.mock('../facts/repoDependencyFacts');
+jest.mock('../rules');
+jest.mock('../operators');
+jest.mock('../utils/logger');
+describe('analyzeCodebase', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it('should analyze the codebase and return results', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mockFileData = [{ filePath: 'src/index.ts', fileContent: 'console.log("Hello, world!");' }];
+        const mockDependencyData = [{ dep: 'commander', ver: '2.0.0', min: '^2.0.0' }];
+        const mockStandardStructure = { src: { core: null, utils: null, operators: null, rules: null, facts: null } };
+        const mockRules = [{ name: 'mockRule', conditions: { all: [] }, event: { type: 'mockEvent' } }];
+        repoFilesystemFacts_1.collectRepoFileData.mockResolvedValue(mockFileData);
+        repoDependencyFacts_1.getDependencyVersionFacts.mockResolvedValue(mockDependencyData);
+        repoDependencyFacts_1.collectMinimumDependencyVersions.mockResolvedValue({});
+        repoFilesystemFacts_1.collectStandardDirectoryStructure.mockResolvedValue(mockStandardStructure);
+        rules_1.loadRules.mockResolvedValue(mockRules);
+        const engineRunMock = jest.fn().mockResolvedValue({ failureResults: [] });
+        json_rules_engine_1.Engine.mockImplementation(() => ({
+            addOperator: jest.fn(),
+            addRule: jest.fn(),
+            on: jest.fn(),
+            run: engineRunMock
+        }));
+        const results = yield (0, engine_1.analyzeCodebase)('mockRepoPath');
+        expect(repoFilesystemFacts_1.collectRepoFileData).toHaveBeenCalledWith('mockRepoPath');
+        expect(repoDependencyFacts_1.getDependencyVersionFacts).toHaveBeenCalled();
+        expect(repoDependencyFacts_1.collectMinimumDependencyVersions).toHaveBeenCalled();
+        expect(repoFilesystemFacts_1.collectStandardDirectoryStructure).toHaveBeenCalled();
+        expect(rules_1.loadRules).toHaveBeenCalled();
+        expect(engineRunMock).toHaveBeenCalledTimes(mockFileData.length);
+        expect(results).toEqual([]);
+    }));
+    it('should handle errors during analysis', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mockFileData = [{ filePath: 'src/index.ts', fileContent: 'console.log("Hello, world!");' }];
+        const mockDependencyData = [{ dep: 'commander', ver: '2.0.0', min: '^2.0.0' }];
+        const mockStandardStructure = { src: { core: null, utils: null, operators: null, rules: null, facts: null } };
+        const mockRules = [{ name: 'mockRule', conditions: { all: [] }, event: { type: 'mockEvent' } }];
+        repoFilesystemFacts_1.collectRepoFileData.mockResolvedValue(mockFileData);
+        repoDependencyFacts_1.getDependencyVersionFacts.mockResolvedValue(mockDependencyData);
+        repoDependencyFacts_1.collectMinimumDependencyVersions.mockResolvedValue({});
+        repoFilesystemFacts_1.collectStandardDirectoryStructure.mockResolvedValue(mockStandardStructure);
+        rules_1.loadRules.mockResolvedValue(mockRules);
+        const engineRunMock = jest.fn().mockRejectedValue(new Error('mock error'));
+        json_rules_engine_1.Engine.mockImplementation(() => ({
+            addOperator: jest.fn(),
+            addRule: jest.fn(),
+            on: jest.fn(),
+            run: engineRunMock
+        }));
+        const results = yield (0, engine_1.analyzeCodebase)('mockRepoPath');
+        expect(repoFilesystemFacts_1.collectRepoFileData).toHaveBeenCalledWith('mockRepoPath');
+        expect(repoDependencyFacts_1.getDependencyVersionFacts).toHaveBeenCalled();
+        expect(repoDependencyFacts_1.collectMinimumDependencyVersions).toHaveBeenCalled();
+        expect(repoFilesystemFacts_1.collectStandardDirectoryStructure).toHaveBeenCalled();
+        expect(rules_1.loadRules).toHaveBeenCalled();
+        expect(engineRunMock).toHaveBeenCalledTimes(mockFileData.length);
+        expect(results).toEqual([]);
+    }));
+});

package/dist/facts/repoDependencyFacts.js

@@ -0,0 +1,105 @@
+"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.findPropertiesInTree = exports.getDependencyVersionFacts = exports.collectLocalDependencies = exports.collectMinimumDependencyVersions = void 0;
+const logger_1 = require("../utils/logger");
+const lodash_1 = __importDefault(require("lodash"));
+const axios_1 = __importDefault(require("axios"));
+const child_process_1 = require("child_process");
+/**
+  * Collects the minimum dependency versions.
+  * @returns The minimum dependency versions.
+  */
+function collectMinimumDependencyVersions(configUrl) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (configUrl) {
+            try {
+                const response = yield axios_1.default.get(configUrl);
+                return response.data.minimumDependencyVersions;
+            }
+            catch (error) {
+                logger_1.logger.error(`Error fetching minimum dependency versions from configUrl: ${error}`);
+                return {};
+            }
+        }
+        else {
+            return {
+                commander: '^2.0.0',
+                nodemon: '^3.9.0'
+            };
+        }
+    });
+}
+exports.collectMinimumDependencyVersions = collectMinimumDependencyVersions;
+/**
+ * Collects the local dependencies.
+ * @returns The local dependencies.
+ */
+function collectLocalDependencies() {
+    let result = {};
+    try {
+        let stdout = (0, child_process_1.execSync)('npm ls -a --json');
+        result = JSON.parse(stdout.toString());
+    }
+    catch (e) {
+        logger_1.logger.error(`exec error: ${e}`);
+        //console.error(`exec error: ${e}`);
+    }
+    return result;
+}
+exports.collectLocalDependencies = collectLocalDependencies;
+/**
+ * Gets the installed dependency versions.
+ * @returns The installed dependency versions.
+ */
+function getDependencyVersionFacts() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const localDependencies = yield collectLocalDependencies();
+        const minimumDependencyVersions = yield collectMinimumDependencyVersions();
+        //console.log(localDependencies);
+        const installedDependencyVersions = findPropertiesInTree(localDependencies, minimumDependencyVersions);
+        return installedDependencyVersions;
+    });
+}
+exports.getDependencyVersionFacts = getDependencyVersionFacts;
+/**
+ * Recursively search for properties in a tree of objects.
+ * @param depGraph - The object to search.
+ * @param minVersions - The minimum dependency versions to search for.
+ * @returns An array of results.
+ */
+function findPropertiesInTree(depGraph, minVersions) {
+    let results = [];
+    logger_1.logger.debug(`depGraph: ${depGraph}`);
+    function walk(depGraph) {
+        if (lodash_1.default.isObject(depGraph) && !lodash_1.default.isArray(depGraph)) {
+            for (let depName in depGraph) {
+                if (Object.keys(minVersions).includes(depName)) {
+                    results.push({ dep: depName, ver: depGraph[depName].version, min: minVersions[depName] });
+                }
+                if (lodash_1.default.isObject(depGraph[depName])) {
+                    walk(depGraph[depName]);
+                }
+            }
+        }
+        else if (lodash_1.default.isArray(depGraph)) {
+            for (let item of depGraph) {
+                walk(item);
+            }
+        }
+    }
+    walk(depGraph);
+    return results;
+}
+exports.findPropertiesInTree = findPropertiesInTree;

package/dist/facts/repoDependencyFacts.test.js

@@ -0,0 +1,149 @@
+"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 child_process_1 = require("child_process");
+const repoDependencyFacts_1 = require("./repoDependencyFacts");
+const logger_1 = require("../utils/logger");
+jest.mock('child_process', () => ({
+    execSync: jest.fn(),
+}));
+jest.mock('../utils/logger', () => ({
+    logger: {
+        error: jest.fn(),
+        debug: jest.fn(),
+    },
+}));
+describe('collectMinimumDependencyVersions', () => {
+    it('should return the correct minimum dependency versions', () => __awaiter(void 0, void 0, void 0, function* () {
+        const result = yield (0, repoDependencyFacts_1.collectMinimumDependencyVersions)();
+        expect(result).toEqual({
+            commander: '^2.0.0',
+            nodemon: '^3.9.0'
+        });
+    }));
+});
+describe('collectLocalDependencies', () => {
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+    it('should return parsed JSON result when execSync succeeds', () => {
+        const mockResult = JSON.stringify({ dependencies: {} });
+        child_process_1.execSync.mockReturnValue(Buffer.from(mockResult));
+        const result = (0, repoDependencyFacts_1.collectLocalDependencies)();
+        expect(result).toEqual({ dependencies: {} });
+    });
+    it('should log error and return empty object when execSync fails', () => {
+        child_process_1.execSync.mockImplementation(() => {
+            throw new Error('mock error');
+        });
+        const result = (0, repoDependencyFacts_1.collectLocalDependencies)();
+        expect(logger_1.logger.error).toHaveBeenCalledWith('exec error: Error: mock error');
+        //expect(console.error).toHaveBeenCalledWith('exec error: Error: mock error');
+        expect(result).toEqual({});
+    });
+    it('should handle non-JSON response gracefully', () => {
+        child_process_1.execSync.mockReturnValue(Buffer.from('invalid json'));
+        const result = (0, repoDependencyFacts_1.collectLocalDependencies)();
+        expect(result).toEqual({});
+    });
+});
+describe('getDependencyVersionFacts', () => {
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+    it('should return installed dependency versions correctly', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mockLocalDependencies = { dependencies: { commander: { version: '2.0.0' }, nodemon: { version: '3.9.0' } } };
+        const mockMinimumVersions = { commander: '^2.0.0', nodemon: '^3.9.0' };
+        child_process_1.execSync.mockReturnValue(Buffer.from(JSON.stringify(mockLocalDependencies)));
+        const result = yield (0, repoDependencyFacts_1.getDependencyVersionFacts)();
+        expect(result).toEqual([
+            { dep: 'commander', ver: '2.0.0', min: '^2.0.0' },
+            { dep: 'nodemon', ver: '3.9.0', min: '^3.9.0' }
+        ]);
+    }));
+    it('should return an empty array if no dependencies match minimum versions', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mockLocalDependencies = { dependencies: { someOtherDep: { version: '1.0.0' } } };
+        const mockMinimumVersions = { commander: '^2.0.0', nodemon: '^3.9.0' };
+        child_process_1.execSync.mockReturnValue(Buffer.from(JSON.stringify(mockLocalDependencies)));
+        const result = yield (0, repoDependencyFacts_1.getDependencyVersionFacts)();
+        expect(result).toEqual([]);
+    }));
+});
+describe('findPropertiesInTree', () => {
+    it('should find properties in the tree correctly', () => {
+        const depGraph = {
+            commander: { version: '2.0.0' },
+            nodemon: { version: '3.9.0' }
+        };
+        const minVersions = { commander: '^2.0.0', nodemon: '^3.9.0' };
+        const result = (0, repoDependencyFacts_1.findPropertiesInTree)(depGraph, minVersions);
+        expect(result).toEqual([
+            { dep: 'commander', ver: '2.0.0', min: '^2.0.0' },
+            { dep: 'nodemon', ver: '3.9.0', min: '^3.9.0' }
+        ]);
+    });
+    it('should return an empty array if no properties match', () => {
+        const depGraph = {
+            someOtherDep: { version: '1.0.0' }
+        };
+        const minVersions = { commander: '^2.0.0', nodemon: '^3.9.0' };
+        const result = (0, repoDependencyFacts_1.findPropertiesInTree)(depGraph, minVersions);
+        expect(result).toEqual([]);
+    });
+    it('should handle nested dependencies correctly', () => {
+        const depGraph = {
+            commander: { version: '2.0.0',
+                dependencies: {
+                    nodemon: { version: '3.9.0' }
+                }
+            }
+        };
+        const minVersions = { commander: '^2.0.0', nodemon: '^3.9.0' };
+        const result = (0, repoDependencyFacts_1.findPropertiesInTree)(depGraph, minVersions);
+        expect(result).toEqual([
+            { dep: 'commander', ver: '2.0.0', min: '^2.0.0' },
+            { dep: 'nodemon', ver: '3.9.0', min: '^3.9.0' }
+        ]);
+    });
+    it('should not add non-matching dependencies to results', () => {
+        const depGraph = {
+            someOtherDep: { version: '1.0.0' }
+        };
+        const minVersions = { commander: '^2.0.0', nodemon: '^3.9.0' };
+        const result = (0, repoDependencyFacts_1.findPropertiesInTree)(depGraph, minVersions);
+        expect(result).toEqual([]);
+    });
+    it('should handle complex mixed structures', () => {
+        const depGraph = {
+            commander: {
+                version: '2.0.0',
+                dependencies: {
+                    nodemon: {
+                        version: '3.9.0',
+                        dependencies: {
+                            lodash: {
+                                version: '4.17.21'
+                            }
+                        }
+                    }
+                }
+            }
+        };
+        const minVersions = { commander: '^2.0.0', nodemon: '^3.9.0', lodash: '^4.17.20' };
+        const result = (0, repoDependencyFacts_1.findPropertiesInTree)(depGraph, minVersions);
+        //console.log(result);
+        expect(result).toEqual([
+            { dep: 'commander', ver: '2.0.0', min: '^2.0.0' },
+            { dep: 'nodemon', ver: '3.9.0', min: '^3.9.0' },
+            { dep: 'lodash', ver: '4.17.21', min: '^4.17.20' }
+        ]);
+    });
+});