@intecoag/inteco-cli 1.3.0 → 1.4.0

package/.github/dependabot.yml

@@ -1,7 +1,15 @@
 version: 2
 updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+      day: "monday"
+      time: "03:00"
+      timezone: "UTC"
   - package-ecosystem: "npm"
     directory: "/"
+    versioning-strategy: increase
     schedule:
       interval: "weekly"
       day: "monday"
@@ -14,3 +22,7 @@ updates:
         patterns:
           - "*"
     open-pull-requests-limit: 10
+    commit-message:
+      prefix: fix
+      prefix-development: chore
+      include: scope

package/.github/workflows/publish.yml

@@ -14,11 +14,11 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
         with:
           fetch-depth: 0
       - name: Setup Node.js
-        uses: actions/setup-node@v4
+        uses: actions/setup-node@v6
         with:
           node-version: "lts/*"
       - name: Install dependencies

package/.vscode/settings.json

@@ -0,0 +1,6 @@
+{
+    "conventionalCommits.scopes": [
+        "dependabot",
+        "actions"
+    ]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intecoag/inteco-cli",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "CLI-Tools for Inteco",
   "main": "src/index.js",
   "type": "module",
@@ -19,6 +19,7 @@
     "cli-meow-help": "^4.0.0",
     "cli-table3": "^0.6.5",
     "csv-parser": "^3.0.0",
+    "fast-glob": "^3.3.3",
     "fuzzysort": "^3.1.0",
     "graphql": "^16.6.0",
     "meow": "^14.0.0",
@@ -36,10 +37,10 @@
     "inteco": "src/index.js"
   },
   "devDependencies": {
-    "@commitlint/cli": "^20.2.0",
-    "@commitlint/config-conventional": "^20.2.0",
+    "@commitlint/cli": "^20.4.0",
+    "@commitlint/config-conventional": "^20.4.0",
     "husky": "^9.1.7",
-    "semantic-release": "^25.0.2"
+    "semantic-release": "^25.0.3"
   },
   "release": {
     "branches": [

package/src/index.js

@@ -18,6 +18,7 @@ import commands from "./ressources/cmds.json" with {type: 'json'};
 import packageJson from "../package.json" with {type: 'json'}
 import extdSearch from './modules/extdSearch.js';
 import syncConfig from './modules/syncConfig.js';
+import configMutation from './modules/configMutation.js';
 import bundleProduct from './modules/bundleProduct.js';
 
 import updateNotifier from 'update-notifier';
@@ -87,6 +88,9 @@ switch (cli.input[0]) {
     case "sync_config":
         syncConfig();
         break;
+    case "config_mutation":
+        configMutation();
+        break;
     case "bundle_product":
         bundleProduct(cli);
         break;

package/src/modules/configMutation.js

@@ -0,0 +1,360 @@
+import prompts from "prompts";
+import chalk from "chalk";
+import { Config } from "../utils/config/config.js";
+import FS from "fs"
+import * as CliFS from "../utils/fs/FS.js";
+import YAML from "yaml";
+import { YAMLMap, YAMLSeq } from "yaml";
+import fg from "fast-glob";
+import path from "path";
+
+export default async function mutateConfig() {
+    console.log()
+
+    const config = await Config.getConfig();
+    const configDirectories = [
+        { title: '[Update all]', value: '*' },
+        ...FS.readdirSync(config.configIndividualPathEclipse, { withFileTypes: true }).filter(dirent => dirent.isDirectory())
+            .map(dirent => { return { title: dirent.name, value: dirent.name } })
+    ]
+
+    let success = true;
+
+    const responses = await prompts([
+        {
+            type: 'select',
+            name: 'mergeType',
+            message: 'Select Merge Type:',
+            choices: [
+                { title: 'Only Create missing Keys (add missing keys from source to target)', value: 'only_create' },
+                { title: 'Create, Update and Overwrite Keys (copy everything except keys that only exist in target)', value: 'create_update_overwrite' },
+                { title: 'Remove missing Keys (remove all keys from target that don\'t exist in source)', value: 'remove_missing' }
+            ]
+        },
+        {
+            type: 'toggle',
+            name: 'mergeClients',
+            message: 'Include Mand? (Apply changes to 1_, 2_, ...)',
+            active: false
+        },
+        {
+            type: 'autocomplete',
+            name: 'configDest',
+            message: 'Update Target?',
+            choices: configDirectories
+        },
+        {
+            type: 'toggle',
+            name: 'dryRun',
+            message: 'Dry run? (show what would happen without making changes)',
+            initial: false,
+            active: 'yes',
+            inactive: 'no'
+        }
+    ], {
+        onCancel: () => {
+            console.log();
+            console.log(chalk.red("Cancelled Operation!"));
+            console.log();
+            success = false;
+        }
+    });
+
+
+    if (success) {
+        const sourceConfigs = await CliFS.FS.filePicker(path.join(path.dirname(config.configIndividualPathEclipse), "config", "yaml"),
+            path.join(path.dirname(config.configIndividualPathEclipse), "config", "yaml"));
+
+        const configsToUpdate = responses.configDest == '*'
+            ? FS.readdirSync(config.configIndividualPathEclipse, { withFileTypes: true }).filter(f => f.isDirectory()).map(f => f.name)
+            : [responses.configDest];
+
+        switch (responses.mergeType) {
+            case 'only_create':
+                await processAddMissing(sourceConfigs, config.configIndividualPathEclipse, configsToUpdate, responses.mergeClients, responses.dryRun);
+                break;
+            case 'remove_missing':
+                await processRemoveMissing(sourceConfigs, config.configIndividualPathEclipse, configsToUpdate, responses.mergeClients, responses.dryRun);
+                break;
+            case 'create_update_overwrite':
+                await processMergeOverwrite(sourceConfigs, config.configIndividualPathEclipse, configsToUpdate, responses.mergeClients, responses.dryRun);
+                break;
+        }
+
+        if (responses.dryRun) {
+            console.log()
+            const confirmationResults = await prompts([
+                {
+                    type: 'confirm',
+                    name: 'confirmation',
+                    message: 'Would you like to execute the dry-run?',
+                    initial: true
+                }
+            ], {
+                onCancel: () => {
+                    console.log();
+                    console.log(chalk.red("Cancelled Operation!"));
+                    console.log();
+                    success = false;
+                }
+            })
+
+            if(confirmationResults.confirmation){
+                switch (responses.mergeType) {
+                    case 'only_create':
+                        await processAddMissing(sourceConfigs, config.configIndividualPathEclipse, configsToUpdate, responses.mergeClients, false);
+                        break;
+                    case 'remove_missing':
+                        await processRemoveMissing(sourceConfigs, config.configIndividualPathEclipse, configsToUpdate, responses.mergeClients, false);
+                        break;
+                    case 'create_update_overwrite':
+                        await processMergeOverwrite(sourceConfigs, config.configIndividualPathEclipse, configsToUpdate, responses.mergeClients, false);
+                        break;
+                }
+            }
+        }
+        console.log();
+    }
+}
+
+async function processMergeOverwrite(filesToUpdate, configIndividualPathEclipse, configsToUpdate, mergeClients, dryRun) {
+    await processInEachFile(filesToUpdate, configIndividualPathEclipse,
+        configsToUpdate, mergeClients, dryRun, mergeOverwriteNodes);
+}
+
+async function processRemoveMissing(filesToUpdate, configIndividualPathEclipse, configsToUpdate, mergeClients, dryRun) {
+    await processInEachFile(filesToUpdate, configIndividualPathEclipse,
+        configsToUpdate, mergeClients, dryRun, removeMissingNodes);
+}
+
+async function processAddMissing(filesToUpdate, configIndividualPathEclipse, configsToUpdate, mergeClients, dryRun) {
+    await processInEachFile(filesToUpdate, configIndividualPathEclipse,
+        configsToUpdate, mergeClients, dryRun, addMissingNodes);
+}
+
+async function processEachFile(filesToUpdate, configIndividualPathEclipse, configsToUpdate, mergeClients, dryRun, processAction) {
+    let updatedFiles = 0;
+    const globalConfig = path.join(path.dirname(configIndividualPathEclipse), "config");
+    for(const file of filesToUpdate) {
+        for(const c of configsToUpdate) {
+            const individualConfigPath = path.join(configIndividualPathEclipse, c, "yaml", file);
+            const relatedConfigsForFile = await getRelatedConfigs(individualConfigPath, mergeClients);
+            for(const config of relatedConfigsForFile) {
+                const hasUpdates = processAction(path.join(globalConfig, "yaml", file), config, dryRun);
+                if(hasUpdates) updatedFiles++;
+            }
+        }
+    }
+
+    console.log();
+    console.log(chalk.green(`Summary: Updated ${updatedFiles} files.`));
+    if (dryRun) {
+        console.log(chalk.yellow("Dry run complete — no changes were made."));
+    } else {
+        console.log(chalk.green("Config mutate completed successfully."));
+    }
+}
+
+// Loop through each file in filesToUpdate and executes processAction
+async function processInEachFile(filesToUpdate, configIndividualPathEclipse, configsToUpdate, mergeClients, dryRun, processAction) {
+    return await processEachFile(filesToUpdate, configIndividualPathEclipse,
+        configsToUpdate, mergeClients, dryRun,
+        (globalConfig, individualConfig, dryRun) => processInFile(globalConfig, individualConfig, dryRun, processAction));
+}
+
+// Executes processAction for a yaml config file
+function processInFile(compareFrom, compareTo, dryRun, processAction) {
+    try {
+        if(!FS.existsSync(compareFrom) || !FS.existsSync(compareTo)) return;
+        const fromDocument = YAML.parseDocument(FS.readFileSync(compareFrom, "utf-8"));
+        const toDocument = YAML.parseDocument(FS.readFileSync(compareTo, "utf-8"));
+        
+        const hasChanges = processAction(fromDocument.contents, toDocument.contents);
+        const resultText = toDocument.toString();
+        
+
+        if(hasChanges) {
+            if(dryRun) {
+                console.debug(chalk.gray(`[Debug] From file ${compareFrom}`));
+                console.log(chalk.green(`[DryRun] Would Update file: ${compareTo}`));
+            }
+            else {
+                console.log(chalk.green(`Updating file ${compareTo}`));
+                FS.writeFileSync(compareTo, resultText);
+            }
+        }
+        return hasChanges;
+    }
+    catch(error) {
+        if(dryRun) {
+            console.log(chalk.red(`[DryRun] Error in file: ${compareFrom} <-> ${compareTo}: ${error.message}`));
+        }
+        else {
+            console.log(chalk.red(`Could not update file ${compareFrom} <-> ${compareTo}: ${error.message}`));
+        }
+        return false;
+    }
+}
+
+// Returns related configs for a base config file (config.yaml, 1_config.yaml, 2_config.yaml, ...)
+async function getRelatedConfigs(file, withClients) {
+    const dir = path.dirname(file);
+    const ext = path.extname(file);
+    const name = path.basename(file, ext);
+
+    let patterns = [
+        path.join(dir, `${name}${ext}`), // name.yaml
+    ];
+
+    if(withClients)
+        patterns.push(path.join(dir, `*_${name}${ext}`)); // *_name.yaml (für mandanten)
+
+    patterns = patterns.map(p => p.replaceAll(path.sep, '/'));
+
+    return (await fg(patterns, {
+        onlyFiles: true,
+        unique: true
+    })).map(f => f.replaceAll('/', path.sep));
+}
+
+// only_create
+function addMissingNodes(fromNode, toNode) {
+    let hasChanges = false;
+
+    if (!fromNode || !toNode) return;
+
+    if (fromNode instanceof YAMLMap && toNode instanceof YAMLMap) {
+        for (const pair of fromNode.items) {
+            const keyNode = pair.key;
+            const fromVal = pair.value;
+
+            if (!toNode.has(keyNode)) {
+                toNode.items.push(pair);
+                hasChanges = true;
+                continue;
+            }
+
+            const toVal = toNode.get(keyNode, true);
+            hasChanges |= addMissingNodes(fromVal, toVal);
+        }
+        return hasChanges;
+    }
+
+    if (fromNode instanceof YAMLSeq && toNode instanceof YAMLSeq) {
+        for (const fromItem of fromNode.items) {
+            const fromJson = nodeToJs(fromItem);
+            let exists = false;
+
+            for (const toItem of toNode.items) {
+                if (deepEqual(fromJson, nodeToJs(toItem))) {
+                    exists = true;
+                    break;
+                }
+            }
+
+            if (!exists) {
+                toNode.items.push(fromItem);
+                hasChanges = true;
+            }
+        }
+        return hasChanges;
+    }
+}
+
+// remove_missing
+function removeMissingNodes(fromNode, toNode) {
+    let hasChanges = false;
+
+    if (!fromNode || !toNode) return false;
+
+    if (fromNode instanceof YAMLMap && toNode instanceof YAMLMap) {
+        for (let i = toNode.items.length - 1; i >= 0; i--) {
+            const toPair = toNode.items[i];
+            const keyNode = toPair.key;
+
+            if (!fromNode.has(keyNode)) {
+                toNode.items.splice(i, 1);
+                hasChanges = true;
+                continue;
+            }
+
+            const fromVal = fromNode.get(keyNode, true);
+            hasChanges |= removeMissingNodes(fromVal, toPair.value);
+        }
+        return hasChanges;
+    }
+
+    if (fromNode instanceof YAMLSeq && toNode instanceof YAMLSeq) {
+        for (let i = toNode.items.length - 1; i >= 0; i--) {
+            const toItem = toNode.items[i];
+            const toJson = nodeToJs(toItem);
+
+            let exists = false;
+            for (const fromItem of fromNode.items) {
+                if (deepEqual(toJson, nodeToJs(fromItem))) {
+                    exists = true;
+                    break;
+                }
+            }
+
+            if (!exists) {
+                toNode.items.splice(i, 1);
+                hasChanges = true;
+            }
+        }
+        return hasChanges;
+    }
+
+    return false;
+}
+
+// create_update_overwrite
+function mergeOverwriteNodes(fromNode, toNode) {
+    let hasChanges = false;
+
+    if (!fromNode || !toNode) return false;
+
+    if (fromNode instanceof YAMLMap && toNode instanceof YAMLMap) {
+        for (const fromPair of fromNode.items) {
+            const keyNode = fromPair.key;
+            const fromVal = fromPair.value;
+
+            if (!toNode.has(keyNode)) {
+                toNode.items.push(fromPair);
+                hasChanges = true;
+                continue;
+            }
+
+            const toVal = toNode.get(keyNode, true);
+
+            if (
+                fromVal?.constructor === toVal?.constructor &&
+                (fromVal instanceof YAMLMap || fromVal instanceof YAMLSeq)
+            ) {
+                hasChanges |= mergeOverwriteNodes(fromVal, toVal);
+            } else {
+                toNode.set(keyNode, fromVal);
+                hasChanges = true;
+            }
+        }
+        return hasChanges;
+    }
+
+    if (fromNode instanceof YAMLSeq && toNode instanceof YAMLSeq) {
+        toNode.items = [...fromNode.items];
+        return true;
+    }
+
+    return false;
+}
+
+
+function nodeToJs(node) {
+    return node && typeof node.toJSON === "function"
+        ? node.toJSON()
+        : node;
+}
+
+function deepEqual(a, b) {
+    return JSON.stringify(a) === JSON.stringify(b);
+}

package/src/modules/syncConfig.js

@@ -1,5 +1,5 @@
 import prompts from "prompts";
-import { mkdirSync, existsSync, readdirSync, rmSync } from "fs";
+import { mkdirSync, existsSync, readdirSync, rmSync, copyFileSync, statSync } from "fs";
 import path from "path";
 import chalk from "chalk";
 import { Config } from "../utils/config/config.js";
@@ -9,9 +9,7 @@ export default async function syncConfig() {
     console.log()
 
     const config = await Config.getConfig();
-
     const configDirectoriesEclipse = readdirSync(config.configIndividualPathEclipse, { withFileTypes: true }).filter(dirent => dirent.isDirectory()).map(dirent => { return { title: dirent.name } })
-
     const configDirectories = readdirSync(config.configIndividualPath, { withFileTypes: true }).filter(dirent => dirent.isDirectory()).map(dirent => { return { title: dirent.name } })
 
     let success = true;
@@ -29,7 +27,8 @@ export default async function syncConfig() {
                 { title: 'Import Everything (Repository → Work)', value: 'import_all' },
                 { title: 'Export Everything (Work → Repository)', value: 'export_all' },
                 { title: 'Import All ConfigIndividual (Repository → Work)', value: 'import_all_individuals' },
-                { title: 'Export All ConfigIndividual (Work → Repository)', value: 'export_all_individuals' }
+                { title: 'Export All ConfigIndividual (Work → Repository)', value: 'export_all_individuals' },
+                { title: 'Sync from Config to ConfigIndividual (Repository → Repository)', value: 'sync_to_configIndividual' },
             ]
         },
         {
@@ -61,6 +60,16 @@ export default async function syncConfig() {
                 return filtered;
             }
         },
+        {
+            type: (prev, values) => values.direction == 'sync_to_configIndividual' ? 'autocomplete' : null,
+            name: 'configIndividualSelection',
+            message: 'ConfigIndividual (Destination)?',
+            choices: readdirSync(config.configIndividualPathEclipse, { withFileTypes: true }).filter(e => e.isDirectory())
+                        .map(e => ({
+                            title: e.name,
+                            value: path.join(config.configIndividualPathEclipse, e.name)
+                        }))
+        },
         {
             type: 'toggle',
             name: 'dryRun',
@@ -73,8 +82,8 @@ export default async function syncConfig() {
             type: 'select',
             name: 'type',
             message: 'Sync Type?',
-            choices: [
-                { title: 'UPDATE', value: 'UPDATE' },
+            choices: (prev, values) => [
+                values.direction == 'sync_to_configIndividual' ? { title: 'CREATE (if not exists)', value: 'CREATE_IF_NOT_EXISTS' } : { title: 'UPDATE', value: 'UPDATE' },
                 { title: 'OVERWRITE', value: 'OVERWRITE' }
             ]
         }
@@ -90,7 +99,7 @@ export default async function syncConfig() {
 
 
     if (success) {
-        let sourcePaths, destPaths;
+        let sourcePaths, destPaths, syncFiles;
 
         switch (responses.direction) {
             case 'import':
@@ -140,9 +149,24 @@ export default async function syncConfig() {
                 destPaths = [findConfigDirNamedConfigIn(destParent)];
                 break;
             }
+
+            case 'sync_to_configIndividual': {
+                const sourceParent = path.resolve(config.configIndividualPathEclipse, '..');
+
+                sourcePaths = [findConfigDirNamedConfigIn(sourceParent)];
+                destPaths = [path.resolve(config.configIndividualPathEclipse, responses.configIndividualSelection)];
+
+                syncFiles = await FS.filePicker(path.resolve(config.configIndividualPathEclipse, '..', "config"), path.resolve(config.configIndividualPathEclipse, '..', "config"));
+            }
         }
 
-        processMultiple(responses, responses.dryRun, sourcePaths, destPaths);
+        if(responses.direction != "sync_to_configIndividual")
+            processMultiple(responses, responses.dryRun, sourcePaths, destPaths);
+        else
+            processSyncToIndividual(responses.dryRun, syncFiles,
+                responses.configIndividualSelection,
+                findConfigDirNamedConfigIn(path.resolve(config.configIndividualPathEclipse, '..')),
+                responses.type == "OVERWRITE");
 
         if (responses.dryRun) {
             console.log()
@@ -163,13 +187,61 @@ export default async function syncConfig() {
             })
 
             if(confirmationResults.confirmation){
-                processMultiple(responses, false, sourcePaths, destPaths);
+                        if(responses.direction != "sync_to_configIndividual")
+                            processMultiple(responses, false, sourcePaths, destPaths);
+                        else
+                            processSyncToIndividual(false, syncFiles,
+                                responses.configIndividualSelection,
+                                findConfigDirNamedConfigIn(path.resolve(config.configIndividualPathEclipse, '..')),
+                                responses.type == "OVERWRITE");
             }
         }
         console.log();
     }
 }
 
+function processSyncToIndividual(dryRun, sourceFiles, targetConfigIndividual, configPath, overwrite) {
+    console.log();
+    let changed = 0;
+
+    sourceFiles.forEach(sourceFile => {
+        let shouldCopy = false;
+
+        let destPath = path.join(targetConfigIndividual, sourceFile);
+        let sourcePath = path.join(configPath, sourceFile);
+
+        if (overwrite || !existsSync(destPath)) {
+            shouldCopy = true;
+        }
+
+        let shouldCreateDirectory = shouldCopy && !existsSync(path.dirname(destPath));
+
+        if (shouldCopy) {
+            if (dryRun) {
+                if(shouldCreateDirectory) {
+                    console.log(chalk.blue(`[DryRun] Would create directory: ${path.dirname(destPath)}`));
+                }
+                console.log(chalk.blue(`[DryRun] Would ${overwrite ? "overwrite" : "create"} file: ${destPath}`));
+            } else {
+                if(shouldCreateDirectory){
+                    mkdirSync(path.dirname(destPath));
+                }
+                copyFileSync(sourcePath, destPath);
+            }
+            changed++;
+        }
+    });
+
+    console.log();
+    console.log(chalk.green(`Summary: Changed ${changed} items.`));
+
+    console.log();
+    if (dryRun) {
+        console.log(chalk.yellow("Dry run complete — no changes were made."));
+    } else {
+        console.log(chalk.green("Config sync completed successfully."));
+    }
+}
 
 function processMultiple(responses, dryRun, sourcePaths, destPaths) {
     console.log();

package/src/ressources/cmds.json

@@ -8,6 +8,9 @@
     "config_rewrite": {
         "desc": "Rewrites WEGAS-Config"
     },
+    "config_mutation": {
+        "desc": "Synchronize Configs with new/changed properties"
+    },
     "sync_config": {
         "desc": "Synchronize Config/ConfigIndividual-Folders between Work and Repository (Eclipse-Repo)"
     },

package/src/utils/fs/FS.js

@@ -1,10 +1,10 @@
 import { statSync, mkdirSync, existsSync, copyFileSync, readdirSync } from "fs";
 import chalk from "chalk";
-import path from "path";
-
+import path, { relative } from "path";
+import prompts from "prompts";
 
 export class FS {
-    static copyUpdatedFiles(sourceDir, destDir, dryRun = false, stats = { added: 0, updated: 0 }, filenameBlacklist = []) {
+    static copyUpdatedFiles(sourceDir, destDir, dryRun = false, stats = { added: 0, updated: 0 }, filenameBlacklist = [], onlyCopyNonExistant = false) {
         if (!existsSync(destDir)) {
             if (dryRun) {
                 console.log(chalk.gray(`[DryRun] Would create directory: ${destDir}`));
@@ -30,7 +30,7 @@ export class FS {
 
                 if (!existsSync(destPath)) {
                     shouldCopy = true;
-                } else {
+                } else if(!onlyCopyNonExistant) {
                     const sourceStat = statSync(sourcePath);
                     const destStat = statSync(destPath);
 
@@ -84,5 +84,61 @@ export class FS {
         }
     }
 
+    
+    static async filePicker(startDir = process.cwd(), navRootDir = process.cwd()) {
+        let current = startDir;
+    
+        while(true) {
+            const entries = readdirSync(current, { withFileTypes: true });
+    
+            const choices = [
+                { title: '[Dir] .  (Select Current Directory)', value: '.', isDirectory: true },
+                ...entries.map(e => ({
+                    title: e.isDirectory() ? `${e.name} [Dir]` : e.name,
+                    value: e.name,
+                    isDirectory: e.isDirectory()
+                })).sort((a, b) => a.isDirectory && !b.isDirectory ? -1 : (!a.isDirectory && b.isDirectory ? 1 : a.value.localeCompare(b.value)))
+            ]
+    
+            if(path.relative(navRootDir, current) !== "") {
+                choices.unshift({ title: '[Dir] .. (Go Up one Directory)', value: '..', isDirectory: true });
+            }
+    
+            const { file } = await prompts({
+                type: 'autocomplete',
+                name: "file",
+                message: `Pick Files: ${current}`,
+                choices
+            });
+    
+            const picked = choices.find(c => c.value === file);
+    
+            if(picked.isDirectory) {
+                const dir = picked.value;
+                if(dir === ".") return FS.getAllFiles(current).map(e => path.relative(navRootDir, e));
+                current = dir === ".." ? path.dirname(current) : path.join(current, dir);
+            }
+            else {
+                return [path.relative(navRootDir, path.join(current, picked.value))];
+            }
+        }
+    }
+
+    static getAllFiles(dir) {
+        const entries = readdirSync(dir, { withFileTypes: true });
+        const files = [];
+
+        for(const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
 
+            if(entry.isDirectory()) {
+                files.push(...FS.getAllFiles(fullPath));
+            }
+            else {
+                files.push(fullPath);
+            }
+        }
+
+        return files;
+    }
 }