@c6fc/spellcraft 0.0.1 → 0.0.2

package/README.md

@@ -7,7 +7,7 @@ Spellcraft is an opinionated approach to manifesting and applying configurations
 Install spellcraft with `npm install` and add plugins with `npx spellcraft importModule`
 
 ```sh
-$ npm i -p spellcraft
+$ npm i -p @c6fc/spellcraft
 $ npx spellcraft importModule @c6fc/spellcraft-packer packer
 ```
 

package/package.json

@@ -7,7 +7,7 @@
   },
   "name": "@c6fc/spellcraft",
   "description": "Extensible JSonnet CLI platform",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "main": "src/index.js",
   "directories": {
     "lib": "lib"

package/src/index.js

@@ -314,7 +314,6 @@ exports.SpellFrame = class SpellFrame {
      */
     async importSpellCraftModuleFromNpm(npmPackage, name = false) {
         const npmPath = path.resolve(baseDir, 'node_modules', npmPackage);
-
         if (!fs.existsSync(npmPath)) {
             console.log(`[+] Attempting to install ${npmPackage}...`);
             // Note: `spawnSync` is blocking. For a CLI tool, this might be acceptable.
@@ -342,40 +341,54 @@ exports.SpellFrame = class SpellFrame {
             throw new Error(`[!] No import name specified for ${npmPackage}, and it has no 'spellcraft_module_default_name' in its package.json config.`);
         }
 
-        const packagesDirPath = path.join(baseDir, 'spellcraft_modules');
-        if (!fs.existsSync(packagesDirPath)) {
-            fs.mkdirSync(packagesDirPath, { recursive: true });
+        // Check if this project is also a module, which shouldn't contain a spellcraft_modules directory.
+        const thisPackageJsonPath = path.join(baseDir, 'package.json');
+        if (!fs.existsSync(npmPath)) {
+            throw new Error(`[!] There's no package.json for your project. Create one with 'npm init' first`);
         }
 
-        const packagesFilePath = path.join(packagesDirPath, 'packages.json');
-        let packages = {};
-        if (fs.existsSync(packagesFilePath)) {
-            try {
-                packages = JSON.parse(fs.readFileSync(packagesFilePath, 'utf-8'));
-            } catch (e) {
-                console.warn(`[!] Could not parse existing ${packagesFilePath}. Starting fresh. Error: ${e.message}`);
-                packages = {};
+        const thisPackageConfig = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+        const thisSpellcraftConfig = packageConfig.config || packageConfig.spellcraft; // Allow 'spellcraft' key too
+
+        // Only link if this package is not a module itself.
+        if (!!!thisSpellcraftConfig?.spellcraft_module_default_name) {
+
+            const packagesDirPath = path.join(baseDir, 'spellcraft_modules');
+            if (!fs.existsSync(packagesDirPath)) {
+                fs.mkdirSync(packagesDirPath, { recursive: true });
             }
-        }
 
-        // Derive the base name to store (e.g., "my-package" from "my-package@1.0.0")
-        const npmPackageBaseName = npmPackage.startsWith("@") ?
-            `@${npmPackage.split('/')[1].split('@')[0]}` : // Handles @scope/name and @scope/name@version
-            npmPackage.split('@')[0]; // Handles name and name@version
+            const packagesFilePath = path.join(packagesDirPath, 'packages.json');
+            let packages = {};
+            if (fs.existsSync(packagesFilePath)) {
+                try {
+                    packages = JSON.parse(fs.readFileSync(packagesFilePath, 'utf-8'));
+                } catch (e) {
+                    console.warn(`[!] Could not parse existing ${packagesFilePath}. Starting fresh. Error: ${e.message}`);
+                    packages = {};
+                }
+            }
 
-        const packagesKey = name || spellcraftConfig.spellcraft_module_default_name;
-        packages[packagesKey] = npmPackageBaseName; // Store the clean package name
+            // Derive the base name to store (e.g., "my-package" from "my-package@1.0.0")
+            const npmPackageBaseName = npmPackage.startsWith("@") ?
+                `@${npmPackage.split('/')[1].split('@')[0]}` : // Handles @scope/name and @scope/name@version
+                npmPackage.split('@')[0]; // Handles name and name@version
 
-        fs.writeFileSync(packagesFilePath, JSON.stringify(packages, null, "\t"));
-        console.log(`[+] Linked ${npmPackage} as SpellCraft module '${packagesKey}'`);
+            const packagesKey = name || spellcraftConfig.spellcraft_module_default_name;
+            packages[packagesKey] = npmPackageBaseName; // Store the clean package name
 
-        // After linking, ensure it's loaded for the current session
-        this.loadModuleByName(packagesKey, npmPackageBaseName);
+            fs.writeFileSync(packagesFilePath, JSON.stringify(packages, null, "\t"));
+            console.log(`[+] Linked ${npmPackage} as SpellCraft module '${packagesKey}'`);
+            
+        } else {
+            console.log(`[+] Module installed, but not linked because the current project is also a module.`);
+            console.log(`    You can use the module's JS native functions, or import its JSonnet modules.`);
+        }
     }
 
     /**
      * Evaluates a Jsonnet file and stores the result.
-     * This also sets up the dynamic `modules/modules.libsonnet` import aggregator.
+     * This also sets up the dynamic `modules/modules` import aggregator.
      * @param {string} file - The path to the main Jsonnet file to evaluate.
      * @async
      * @returns {Promise<object>} The parsed JSON object from the Jsonnet evaluation.
@@ -390,7 +403,7 @@ exports.SpellFrame = class SpellFrame {
         this.activePath = path.dirname(absoluteFilePath); // Set active path for relative 'path()' calls
 
         // Path to the dynamically generated libsonnet file that imports all modules
-        const dynamicModulesImportFile = path.resolve(__dirname, '../modules/modules.libsonnet');
+        const dynamicModulesImportFile = path.resolve(__dirname, '../modules/modules');
 
         // It's crucial this file is managed carefully.
         // If it exists from a previous failed run or other reasons, it might cause issues.
@@ -416,16 +429,17 @@ exports.SpellFrame = class SpellFrame {
             throw new Error(`Jsonnet Evaluation Error for ${absoluteFilePath}: ${e.message || e}`);
         }
 
-        // Clean up the dynamically generated modules.libsonnet after rendering,
+        // Clean up the modules folder after rendering,
         // as it's specific to this render pass and its discovered modules.
-        // This was previously cleaning the whole modules directory, which might be too broad
-        // if other static .libsonnet files are meant to be there.
-        if (fs.existsSync(dynamicModulesImportFile)) {
-            try {
-                fs.unlinkSync(dynamicModulesImportFile);
-            } catch (e) {
-                console.warn(`[!] Could not clean up temporary module file ${dynamicModulesImportFile}: ${e.message}`);
-            }
+        try {
+            const modulePath = path.resolve(__dirname, '../modules');
+
+            fs.readdirSync(modulePath)
+                .map(e => path.join(modulePath, e))
+                // .forEach(e => fs.unlinkSync(e));
+
+        } catch (e) {
+            console.warn(`[!] Could not clean up temporary module file ${dynamicModulesImportFile}: ${e.message}`);
         }
         
         return this.lastRender;
@@ -433,7 +447,7 @@ exports.SpellFrame = class SpellFrame {
 
     /**
      * Loads SpellCraft modules by scanning the `spellcraft_modules` directory for `.js` files.
-     * Generates a `modules.libsonnet` file in `../modules/` to make them importable in Jsonnet.
+     * Generates a `modules` file in `../modules/` to make them importable in Jsonnet.
      * @param {string} aggregateModuleFile - The path where the aggregating libsonnet file will be written.
      * @returns {Array<string>} A list of registered function names from the loaded modules.
      */
@@ -445,6 +459,13 @@ exports.SpellFrame = class SpellFrame {
             return [];
         }
 
+        const spellcraftConfig = packageConfig.config || packageConfig.spellcraft; // Allow 'spellcraft' key too
+
+        if (!!spellcraftConfig?.spellcraft_module_default_name) {
+            console.log("This package is a SpellCraft module. Skipping directory-based module import.");
+            return []
+        }
+
         const jsModuleFiles = fs.readdirSync(spellcraftModulesPath)
             .filter(f => f.endsWith('.js')) // Simpler check for .js files
             .map(f => path.join(spellcraftModulesPath, f));
@@ -484,13 +505,13 @@ exports.SpellFrame = class SpellFrame {
      * @private
      * @param {string} moduleKey - The key (alias) under which the module is registered.
      * @param {string} npmPackageName - The actual npm package name.
-     * @returns {string|null} The moduleKey if successful, null otherwise.
+     * @returns {string|false} The moduleKey if successful, null otherwise.
      */
     loadModuleByName(moduleKey, npmPackageName) {
         const packageJsonPath = path.join(baseDir, 'node_modules', npmPackageName, 'package.json');
         if (!fs.existsSync(packageJsonPath)) {
             console.warn(`[!] package.json not found for module '${moduleKey}' (package: ${npmPackageName}) at ${packageJsonPath}. Skipping.`);
-            return null;
+            return false;
         }
 
         let packageConfig;
@@ -498,7 +519,7 @@ exports.SpellFrame = class SpellFrame {
             packageConfig = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
         } catch (e) {
             console.warn(`[!] Error parsing package.json for module '${moduleKey}' (package: ${npmPackageName}): ${e.message}. Skipping.`);
-            return null;
+            return false;
         }
 
         if (!packageConfig.main) {
@@ -506,7 +527,8 @@ exports.SpellFrame = class SpellFrame {
         } else {
             const jsMainFilePath = path.resolve(baseDir, 'node_modules', npmPackageName, packageConfig.main);
             if (fs.existsSync(jsMainFilePath)) {
-                this.loadFunctionsFromFile(jsMainFilePath);
+                const { functions } = this.loadFunctionsFromFile(jsMainFilePath);
+                console.log(`[+] Imported JavaScript native [${functions.join(', ')}] into module '${moduleKey}'`);
             } else {
                 console.warn(`[!] Main JS file '${jsMainFilePath}' not found for module '${moduleKey}'. Skipping JS function loading.`);
             }
@@ -537,7 +559,7 @@ exports.SpellFrame = class SpellFrame {
                 // Ensure the target directory exists
                 fs.mkdirSync(path.dirname(targetLibsonnetPath), { recursive: true });
                 fs.copyFileSync(sourceLibsonnetPath, targetLibsonnetPath);
-                console.log(`[+] Copied libsonnet module for '${moduleKey}' from ${sourceLibsonnetPath} to ${targetLibsonnetPath}`);
+                console.log(`[+] Copied libsonnet module for '${moduleKey}'`);
             } catch (e) {
                 console.warn(`[!] Failed to copy libsonnet module for '${moduleKey}': ${e.message}`);
             }
@@ -550,7 +572,7 @@ exports.SpellFrame = class SpellFrame {
 
     /**
      * Loads native functions from a list of JavaScript module files and generates
-     * an aggregate Jsonnet import file (`modules.libsonnet` by default convention).
+     * an aggregate Jsonnet import file (`modules` by default convention).
      * @param {string[]} jsModuleFiles - An array of absolute paths to JS module files.
      * @param {string} aggregateModuleFile - The path to the Jsonnet file that will aggregate imports.
      * @returns {{registeredFunctions: string[], magicContent: string[]}}
@@ -579,66 +601,8 @@ exports.SpellFrame = class SpellFrame {
         if (!fs.existsSync(aggregateFileDir)) {
             fs.mkdirSync(aggregateFileDir, { recursive: true });
         }
-        // This content creates a Jsonnet object where keys are module names
-        // and values are their corresponding .libsonnet imports.
-        // It's assumed that loadModuleByName has already copied relevant .libsonnet files
-        // into the ../modules directory, named like <moduleKey>.libsonnet
-        const packagesConfigPath = path.join(baseDir, 'spellcraft_modules', 'packages.json');
-        let moduleImportsString = "";
-        if (fs.existsSync(packagesConfigPath)) {
-            try {
-                const packages = JSON.parse(fs.readFileSync(packagesConfigPath, 'utf-8'));
-                moduleImportsString = Object.keys(packages)
-                    .map(key => `  ${key}: import "${key}.libsonnet"`) // Assumes <key>.libsonnet exists in jpath
-                    .join(",\n");
-            } catch (e) {
-                console.warn(`[!] Error processing packages.json for libsonnet aggregation: ${e.message}`);
-            }
-        }
         
-        // The aggregateModuleFile ('modules/modules.libsonnet') will now look like:
-        // {
-        //   moduleKey1: import "moduleKey1.libsonnet",
-        //   moduleKey2: import "moduleKey2.libsonnet",
-        //   // ... any other native functions directly defined
-        // }
-        // Native functions defined via loadFunctionsFromFile are added directly to jsonnet instance,
-        // and their `std.native` calls are generated by loadFunctionsFromFile's `magicContent`.
-        // The `modules.libsonnet` is primarily for importing `.libsonnet` files from packages.
-        // The `magicContent` from JS files might need a different aggregation strategy
-        // if they are meant to be part of this central `modules.libsonnet`.
-        // For now, `allMagicContent` seems to be intended for a different purpose or needs clarification.
-        // If `magicContent` is for defining native functions in a libsonnet structure, it needs to be integrated.
-        // The current `magicContent.join(",\n")` assumes it's creating entries for a Jsonnet object.
-        // Let's assume modules.libsonnet is for Jsonnet library imports, and native functions are separate.
-        //
-        // Revision: If `allMagicContent` is for `std.native` declarations,
-        // those are typically not put inside `modules.libsonnet` but rather are available globally
-        // once `addNativeFunction` is called. The `modules.libsonnet` file is for Jsonnet code.
-        // The `magicContent` was generating strings like `\t${e}(${parameters.join(', ')}):: std.native('${e}')(${parameters.join(', ')})`
-        // This is Jsonnet code. If this is meant to be *the* content of `modules.libsonnet`,
-        // then the `moduleImportsString` part is separate.
-        //
-        // Let's clarify:
-        // 1. `../modules/<moduleKey>.libsonnet`: Copied from each package.
-        // 2. `../modules/modules.libsonnet`: This file should make #1 easily accessible.
-        //    Example: `{ myModule: import "myModule.libsonnet" }`
-        // 3. Native JS functions: Registered directly with `this.jsonnet.nativeCallback`.
-        //    They are globally available in Jsonnet via `std.native('funcName')`.
-        // The `magicContent` seems to be an attempt to create a .libsonnet wrapper for native functions.
-        // This is good practice! So `modules.libsonnet` could combine these.
-
-        let finalModulesContent = "{\n";
-        if (moduleImportsString) {
-            finalModulesContent += moduleImportsString;
-        }
-        if (allMagicContent.length > 0) {
-            if (moduleImportsString) finalModulesContent += ",\n"; // Add comma if previous content exists
-            finalModulesContent += allMagicContent.join(",\n");
-        }
-        finalModulesContent += "\n}";
-
-        fs.writeFileSync(aggregateModuleFile, finalModulesContent, 'utf-8');
+        fs.writeFileSync(aggregateModuleFile, `{\n${magicContent.join(",\n")}\n}`, 'utf-8');
 
         if (jsModuleFiles.length > 0) {
             console.log(`[+] Processed ${jsModuleFiles.length} JS module file(s) for native functions.`);
@@ -698,7 +662,7 @@ exports.SpellFrame = class SpellFrame {
                     return null;
                 }
                 
-                // For `modules.libsonnet` to provide convenient wrappers:
+                // For `modules` to provide convenient wrappers:
                 // e.g. myNativeFunc(a,b):: std.native('myNativeFunc')(a,b)
                 const paramString = params.join(', ');
                 magicContentSnippets.push(`  ${funcName}(${paramString}):: std.native('${funcName}')(${paramString})`);

package/bin/spellcraft.js.bak

@@ -1,47 +0,0 @@
-#! /usr/bin/env node
-
-const fs = require('fs');
-const yargs = require('yargs')
-const { SpellFrame } = require('../src/index.js');
-
-const spellframe = new SpellFrame();
-
-(async () => {
-
-	yargs
-		.usage("Syntax: $0 <command> [options]")
-		.command("*", "That's too arcane", (yargs) => {
-			yargs
-		}, (argv) => {
-			console.log("[~] That's too arcane. (Unrecognized command)");
-		})
-		.command("generate <filename>", "Generates files from a configuration", (yargs) => {
-			return yargs.positional('filename', {
-				describe: 'Jsonnet configuration file to consume'
-			})
-		}, async (argv) => {
-
-			await spellframe.init();
-			await spellframe.render(argv.filename);
-			await spellframe.write();
-
-		})
-		.command("importModule <npmPackage> [name]", "Configures the current project to use a SpellCraft plugin as an import", (yargs) => {
-			return yargs.positional('npmPackage', {
-				describe: 'The NPM package name of a SpellCraft Plugin to import'
-			}).positional('name', {
-				describe: 'What name to use as the import namespace for this plugin'
-			})
-		}, async (argv) => {
-
-			await spellframe.importSpellCraftModuleFromNpm(argv['npmPackage'], argv['name']);
-
-		});
-
-	spellframe.cliExtensions.forEach((e, i) => e(yargs, spellframe));
-
-	yargs
-		.showHelpOnFail(false)
-		.help("help")
-		.argv;
-})();

package/src/index.js.bak

@@ -1,403 +0,0 @@
-'use strict';
-
-const fs = require("fs");
-const os = require("os");
-const ini = require("ini");
-const path = require("path");
-const yaml = require('js-yaml');
-const crypto = require('crypto');
-const readline = require("readline");
-const { spawnSync } = require('child_process');
-const { Jsonnet } = require("@hanazuki/node-jsonnet");
-
-const baseDir = process.cwd();
-
-exports.SpellFrame = class {
-	renderPath; cliExtensions; cleanBeforeRender; fileTypeHandlers; initFn; jsonnet; lastRender; activePath; functionContext; useDefaultFileHandlers;
-
-	constructor(options) {
-
-		const defaults = {
-			renderPath: "./render",
-			cleanBeforeRender: true,
-			useDefaultFileHandlers: true
-		};
-
-		Object.keys(defaults).forEach(e => {
-			this[e] = options?.[e] ?? defaults[e];
-		});
-
-		// An array of functions aggregated from all plugins that must all succeed before files are processed
-		this.initFn = [];
-
-		// A cache of synchronous function execution results.
-		this.cache = {};
-
-		// An array of functions that extend the CLI 'yargs' argument.
-		this.cliExtensions = [];
-
-		this.fileTypeHandlers = (this.useDefaultFileHandlers) ? defaultFileTypeHandlers : {};
-		
-		// An object to pass as `this` to all functions invoked via JSonnet.
-		this.functionContext = {};
-
-		this.jsonnet = new Jsonnet()
-			.addJpath(path.join(__dirname, '../lib'))
-			.addJpath(path.join(__dirname, '../modules'));
-
-		this.addFunction("envvar", (name) => {
-			return process.env?.[name] ?? false;
-		}, "name");
-
-		this.addFunction("path", () => {
-			return `${process.cwd()}`;
-		});
-
-		this.loadModulesFromPackageList();
-
-		return this;
-	}
-
-	_cacheKey(...args) {
-		return crypto.createHash('sha256').update(JSON.stringify(args)).digest('hex');
-	}
-
-	addFileTypeHander(pattern, handler) {
-		Object.defineProperty(this.fileTypeHandlers, pattern, {
-			value: handler,
-			writable: false
-		});
-
-		return this.fileTypeHandlers;
-	}
-
-	addFunction(name, fn, ...parameters) {
-		this.jsonnet.nativeCallback(name, (...args) => {
-
-			let key = this._cacheKey(name, args);
-			if (!!this.cache?.[key]) {
-				return this.cache[key];
-			}
-
-			this.cache[key] = fn.call(this.functionContext, ...args);
-
-			return this.cache[key];
-		}, ...parameters);
-	}
-
-	export(name, value) {
-		if (typeof value !== "string") {
-			value = JSON.stringify(value);
-		}
-
-		this.jsonnet = this.jsonnet.extCode(name, value);
-		return this;
-	}
-
-	extendWithModuleMetadata(metadata) {
-		
-	}
-
-	import(path) {
-		this.jsonnet = this.jsonnet.addJpath(path);
-
-		return this;
-	}
-
-	async init() {
-		for (const step of this.initFn) {
-			await step();
-		}
-	}
-
-	async importSpellCraftModuleFromNpm(npmPackage, name = false) {
-		const npmPath = path.resolve(path.join(baseDir, 'node_modules', npmPackage));
-		if (!fs.existsSync(npmPath)) {
-			const install = spawnSync(`npm`, ['install', '-p', npmPackage], {
-				cwd: this.renderPath,
-				stdio: [process.stdin, process.stdout, process.stderr]
-			});
-		}
-
-		const configFile = path.join(npmPath, 'package.json');
-		
-		if (!fs.existsSync(configFile)) {
-			console.log(`[!] Package ${npmPackage} is missing package.json`);
-			process.exit(1);
-		}
-
-		const { config } = JSON.parse(fs.readFileSync(path.join(configFile)));
-
-		if (!name && !config?.spellcraft_module_default_name) {
-			console.log(config);
-			console.log(`[!] No import name specified, and ${npmPackage} has no default import name`);
-			process.exit(1);
-		}
-
-		const packagesDirPath = path.join(baseDir, 'spellcraft_modules');
-		if (!fs.existsSync(packagesDirPath)) {
-			fs.mkdirSync(packagesDirPath);
-		}
-
-		let packages = {};
-		const packagesFilePath = path.join(baseDir, 'spellcraft_modules', 'packages.json')
-		if (fs.existsSync(packagesFilePath)) {
-			packages = JSON.parse(fs.readFileSync(packagesFilePath));
-		}
-
-		let npmPackageBaseName;
-
-		// If the package is namespaced, 
-		if (npmPackage[0] == "@") {
-			[ , npmPackageBaseName ] = npmPackage.split('@');
-			npmPackageBaseName = `@${npmPackageBaseName}`;
-		} else {
-			[ npmPackageBaseName ] = npmPackage.split('@');
-		}
-
-		const packagesKey = name || config.spellcraft_module_default_name;
-		packages[packagesKey] = npmPackageBaseName;
-
-		fs.writeFileSync(packagesFilePath, JSON.stringify(packages, null, "\t"));
-
-		console.log(`[+] Linked ${npmPackage} as ${packagesKey}`);
-
-	}
-
-	async render(file) {
-		if (!fs.existsSync(file)) {
-			throw new Error(`Sonnetry Error: ${file} does not exist.`);
-		}
-
-		this.activePath = path.dirname(path.resolve(file));
-
-		const moduleFile = path.resolve(path.join(__dirname, '../modules/modules'));
-
-		if (fs.existsSync(moduleFile)) {
-			throw new Error(`[!] The module target file [${moduleFile}] already exists. Remove or rename it before continuing.`);
-		}
-
-		this.loadModulesFromModuleDirectory(moduleFile);
-
-		console.log(this.renderPath);
-
-		this.renderPath = (this.renderPath.split("").slice(-1)[0] == "/") ?
-			this.renderPath.split("").slice(0, -1).join("") :
-			this.renderPath;
-
-		try {
-			this.lastRender = JSON.parse(await this.jsonnet.evaluateFile(file));
-		} catch (e) {
-			throw new Error(`Error parsing Jsonnet file: ${e}`);
-		}
-
-		const modulePath = path.resolve(path.join(__dirname, '../modules/'));
-		
-		fs.readdirSync(modulePath)
-			.map(e => path.join(modulePath, e))
-			.forEach(e => fs.unlinkSync(e));
-
-		return this.lastRender;
-	}
-
-	loadModulesFromModuleDirectory(moduleFile) {
-
-		const modulePath = path.join(baseDir, 'spellcraft_modules');
-
-		if (!fs.existsSync(modulePath)) {
-			return [];
-		}
-
-		const regex = /.*?\.js$/
-		const fileList = fs.readdirSync(modulePath)
-			.filter(f => regex.test(f))
-			.map(f => path.join(modulePath, f));
-
-		return this.loadModulesFromFileList(fileList, moduleFile);
-	}
-
-	loadModulesFromPackageList() {
-		const packagePath = path.join(baseDir, 'spellcraft_modules', 'packages.json');
-
-		if (!fs.existsSync(packagePath)) {
-			console.log('No spellcraft_modules/packages.json file found. Skip package-based module import');
-			return [];
-		}
-
-		const packages = JSON.parse(fs.readFileSync(packagePath));
-
-		return Object.keys(packages).map(k => {
-			const configFile = path.join(baseDir, 'node_modules', packages[k], 'package.json');
-			const config = JSON.parse(fs.readFileSync(configFile));
-
-			const jsMainFile = path.join(baseDir, 'node_modules', packages[k], config.main);
-			this.loadFunctionsFromFile(jsMainFile);
-
-			const moduleFile = path.resolve(path.join(__dirname, '..', 'modules', k));
-			const importFile = path.resolve(path.join(jsMainFile, '..', 'module.libsonnet'));
-
-			if (fs.existsSync(importFile)) {
-				fs.copyFileSync(importFile, moduleFile);
-			}
-
-			return k;
-		});
-	}
-
-	loadModulesFromFileList(fileList, moduleFile) {
-
-		let registeredFunctions = [];
-
-		if (fileList.length < 1) {
-			return [];
-		}
-
-		let magicContent = [];
-
-		fileList.map(file => {
-			const { functions, magic } = this.loadFunctionsFromFile(file);
-			registeredFunctions = registeredFunctions.concat(functions);
-			magicContent = magicContent.concat(magic);
-		});
-
-		fs.writeFileSync(moduleFile, `{\n${magicContent.join(",\n")}\n}`);
-
-		console.log(`[+] Registered ${fileList.length} module${(fileList.length > 1) ? 's' : ''} as '${path.basename(moduleFile)}' comprising ${registeredFunctions.length} function${(registeredFunctions.length > 1) ? 's' : ''}: [ ${registeredFunctions.sort().join(', ')} ]`)
-
-		return { registeredFunctions, magicContent };
-	}
-
-	loadFunctionsFromFile(file) {
-		const functions = require(file);
-
-		const magicContent = [];
-		if (functions._spellcraft_metadata) {
-			const metadata = functions._spellcraft_metadata;
-			['fileTypeHandlers', 'functionContext'].forEach(e => Object.assign(this[e], metadata[e] ?? {}));
-
-			['cliExtensions'].forEach(e => metadata[e] && this[e].push(metadata[e]));
-
-			metadata.initFn && this.init.push(metadata.initFn);
-		}
-
-		const registeredFunctions = Object.keys(functions).filter(e => e !== '_spellcraft_metadata').map(e => {
-
-			let fn, parameters;
-
-			if (typeof functions[e] == "object") {
-				[fn, ...parameters] = functions[e];
-			}
-
-			if (typeof functions[e] == "function") {
-				fn = functions[e];
-				parameters = getFunctionParameterList(fn);
-			}
-
-			magicContent.push(`\t${e}(${parameters.join(', ')}):: std.native('${e}')(${parameters.join(', ')})`);
-
-			this.addFunction(e, fn, ...parameters);
-			return e;
-		});
-
-		return { functions: registeredFunctions, magic: magicContent };
-	}
-
-	toString() {
-		if (this?.lastRender) {
-			return this.lastRender
-		}
-
-		return null;
-	}
-
-	write(files = this.lastRender) {
-		try {
-			if (!fs.existsSync(this.renderPath)) {
-				fs.mkdirSync(this.renderPath, { recursive: true });
-			}
-		} catch (e) {
-			throw new Error(`Spellcraft Error: renderPath could not be created. ${e}`);
-		}
-
-		if (this.cleanBeforeRender) {
-			try {
-				Object.keys(this.fileTypeHandlers).forEach(regex => {
-					// console.log(regex);
-					fs.readdirSync(this.renderPath)
-						.filter(f => new RegExp(regex, "i").test(f))
-						.map(f => fs.unlinkSync(`${this.renderPath}/${f}`));
-				});
-			} catch (e) {
-				throw new Error(`Failed to remove files from renderPath. ${e}`);
-			}
-		}
-
-		try {
-			for (const filename in files) {
-				const outputPath = `${this.renderPath}/${filename}`;
-
-				const [, handler] = Object.entries(this.fileTypeHandlers)
-					.find(([pattern, ]) => new RegExp(pattern).test(filename)) || [false, defaultFileHandler];
-
-				fs.writeFileSync(outputPath, handler(files[filename]));
-				console.log('  ' + path.basename(outputPath));
-			}
-		} catch (e) {
-			throw new Error(`Failed to write to renderPath. ${e}`);
-		}
-
-		return this;
-	}
-};
-
-const defaultFileTypeHandlers = {
-	// JSON files
-	'.*?\.json$': (e) => {
-		// console.log('Using JSON encoder');
-		return JSON.stringify(e, null, 4)
-	},
-
-	// YAML files
-	'.*?\.yaml$': (e) => {
-		// console.log('Using YAML encoder');
-		yaml.dump(e, {
-			indent: 4
-		})
-	},
-
-	'.*?\.yml$': (e) => {
-		// console.log('Using YAML encoder');
-		yaml.dump(e, {
-			indent: 4
-		})
-	},
-};
-
-const defaultFileHandler = (e) => JSON.stringify(e, null, 4);
-
-function getFunctionParameterList(fn) {
-
-	let str = fn.toString();
-
-	str = str.replace(/\/\*[\s\S]*?\*\//g, '')
-		.replace(/\/\/(.)*/g, '')
-		.replace(/{[\s\S]*}/, '')
-		.replace(/=>/g, '')
-		.trim();
-
-	const start = str.indexOf("(") + 1;
-	const end = str.length - 1;
-
-	const result = str.substring(start, end).split(", ");
-
-	const params = [];
-	result.forEach(element => {
-		element = element.replace(/=[\s\S]*/g, '').trim();
-
-		if(element.length > 0) {
-			params.push(element);
-		}
-	});
-
-	return params;
-}