modpack-lock 0.3.1 → 0.4.0

package/README.md

@@ -18,6 +18,8 @@ This script generates a `modpack.lock` file in the current directory containing
 
 The lockfile could also serve as a basis for restoring modpack contents after cloning the repository to a new machine.
 
+Using the `scripts` field in `modpack.json`, you can also define reusable, tracked shell commands for common modpack tasks (like publishing, generating assets or CI/CD workflows).
+
 ## Installation
 
 To install the script globally with `npm`:
@@ -115,6 +117,38 @@ INFORMATION
   --help                                             display help for modpack-lock init
 ```
 
+### Running Scripts
+
+To run a script defined in `modpack.json` run:
+
+```bash
+modpack-lock run <script>
+```
+
+This command takes the name of the script as its first argument. Use the `-f` option to specify a different path to the modpack directory. For debug logging, use the `-D` option.
+
+To pass additional arguments and options to the script, write them after a `--` separator:
+
+```bash
+modpack-lock run <script> -- [options] <args> 
+```
+
+The `scripts` field in `modpack.json` is a key-value pair of script names and their corresponding shell commands. The `scripts` field is optional and is omitted by default.
+
+```text
+Usage: modpack-lock run [options] <script>
+
+Run a script (shell command) defined in modpack.json's 'scripts' object
+
+Arguments:
+  script               The name of the script to run
+
+Options:
+  -f, --folder <path>  Path to the modpack directory
+  -D, --debug          Debug mode -- show more information about how the command is being parsed
+  -h, --help           display help for modpack-lock run
+```
+
 > [!TIP]
 >
 > You can run this script as a pre-commit hook to ensure that the modpack lockfile is up to date before committing your changes to your repository.
@@ -199,6 +233,9 @@ If created via `modpack-lock init`, the JSON file combines your modpack metadata
     "resourcepacks": [ ... ],
     "datapacks": [ ... ],
     "shaderpacks": [ ... ]
+  },
+  "scripts": {
+    "example": "echo 'example script'"
   }
 }
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "modpack-lock",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "Creates a modpack lockfile for files hosted on Modrinth (mods, resource packs, shaders and datapacks)",
   "bugs": {
     "url": "https://github.com/nickesc/modpack-lock/issues"

package/src/cli.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env NODE_OPTIONS=--no-warnings node
 
 import { Command } from 'commander';
-import path from 'path';
 import slugify from 'slugify';
+import path from 'path';
+import { spawn } from 'child_process';
 import {generateLockfile} from './generate_lockfile.js';
-import generateJson from './generate_json.js';
 import { generateModpackFiles } from './modpack-lock.js';
 import promptUserForInfo from './modpack_info.js';
 import { getModpackInfo } from './directory_scanning.js';
@@ -43,6 +43,28 @@ function restoreConsole() {
     console.error = originalLogs.error;
 }
 
+/**
+ * Merge modpack info with priority: options > existingInfo > defaults
+ * Preserves all fields from existingInfo
+ */
+function mergeModpackInfo(existingInfo, options, defaults) {
+    const result = {};
+    for (const [key, defaultValue] of Object.entries(defaults)) {
+        result[key] = options[key] || existingInfo?.[key] || defaultValue;
+    }
+
+    // Then, add any fields from existingInfo that aren't in defaults
+    if (existingInfo) {
+        for (const [key, value] of Object.entries(existingInfo)) {
+            if (!(key in defaults)) {
+                result[key] = value;
+            }
+        }
+    }
+
+    return result;
+}
+
 modpackLock
     .name(pkg.name)
     .description(pkg.description)
@@ -101,31 +123,36 @@ modpackLock.command('init')
     .option('--targetModloaderVersion <targetModloaderVersion>', 'Target modloader version')
     .option('--targetMinecraftVersion <targetMinecraftVersion>', 'Target Minecraft version; required')
     .optionsGroup("INFORMATION")
-    .helpOption("--help", `display help for ${pkg.name} init`)
+    .helpOption("-h, --help", `display help for ${pkg.name} init`)
     .action(async (options) => {
         const currDir = options.folder || process.cwd();
 
+        let existingInfo = await getModpackInfo(currDir);
+
         if (options.noninteractive) {
             quietConsole();
-            if (!options.author || !options.modloader || !options.targetMinecraftVersion) {
+            if ( (!options.author && !existingInfo?.author) || (!options.modloader && !existingInfo?.modloader) || (!options.targetMinecraftVersion && !existingInfo?.targetMinecraftVersion)) {
                 console.error('Error: Must provide options for required fields');
                 process.exitCode = 1;
                 return;
             } else {
-                const name = options.name || path.basename(currDir);
-                const modpackInfo = {
-                    name: name,
-                    version: options.version || '1.0.0',
-                    id: slugify(options.id || name, config.SLUGIFY_OPTIONS),
-                    description: options.description || '',
-                    author: options.author,
-                    projectUrl: options.projectUrl || '',
-                    sourceUrl: options.sourceUrl || '',
-                    license: options.license || '',
-                    modloader: options.modloader,
-                    targetModloaderVersion: options.targetModloaderVersion || '',
-                    targetMinecraftVersion: options.targetMinecraftVersion,
+                const defaultName = path.basename(currDir);
+                const defaults = {
+                    name: defaultName,
+                    version: config.DEFAULT_MODPACK_VERSION,
+                    id: defaultName,
+                    description: '',
+                    author: options.author, // Required, no default
+                    projectUrl: '',
+                    sourceUrl: '',
+                    license: '',
+                    modloader: options.modloader, // Required, no default
+                    targetModloaderVersion: '',
+                    targetMinecraftVersion: options.targetMinecraftVersion, // Required, no default
                 };
+
+                const modpackInfo = mergeModpackInfo(existingInfo, options, defaults);
+                modpackInfo.id = slugify(modpackInfo.id, config.SLUGIFY_OPTIONS);
                 try {
                     await generateModpackFiles(modpackInfo, currDir, { dryRun: false });
                 } catch (error) {
@@ -138,19 +165,23 @@ modpackLock.command('init')
             console.log("\nSee `modpack-lock init --help` for definitive documentation on these fields and exactly what they do.\n");
             console.log("Press ^C at any time to quit.\n");
             try {
-                const modpackInfo = await promptUserForInfo({
-                    name: options.name || path.basename(currDir),
-                    version: options.version,
-                    id: options.id,
-                    description: options.description,
-                    author: options.author,
-                    projectUrl: options.projectUrl,
-                    sourceUrl: options.sourceUrl,
-                    license: options.license,
-                    modloader: options.modloader,
-                    targetModloaderVersion: options.targetModloaderVersion,
-                    targetMinecraftVersion: options.targetMinecraftVersion,
-                });
+                const defaults = {
+                    name: path.basename(currDir),
+                    version: config.DEFAULT_MODPACK_VERSION,
+                    id: undefined,
+                    description: undefined,
+                    author: undefined,
+                    projectUrl: undefined,
+                    sourceUrl: undefined,
+                    license: config.DEFAULT_MODPACK_LICENSE,
+                    modloader: undefined,
+                    targetModloaderVersion: undefined,
+                    targetMinecraftVersion: undefined,
+                };
+
+                const modpackInfo = await promptUserForInfo(
+                    mergeModpackInfo(existingInfo, options, defaults)
+                );
 
                 await generateModpackFiles(modpackInfo, currDir, { dryRun: false });
             } catch (error) {
@@ -160,6 +191,69 @@ modpackLock.command('init')
         }
     });
 
+modpackLock.command('run')
+    .description(`Run a script (shell command) defined in ${config.MODPACK_JSON_NAME}\'s \'scripts\' object`)
+    .argument('<script>', 'The name of the script to run')
+    .option('-f, --folder <path>', 'Path to the modpack directory')
+    .option('-D, --debug', 'Debug mode -- show more information about how the command is being parsed')
+    .helpOption("-h, --help", `display help for ${pkg.name} run`)
+    .allowExcessArguments(true)
+    .allowUnknownOption(true)
+    .action(async (script, options, command) => {
+        try {
+            if (options.debug) {
+                console.log("COMMAND:", command);
+            }
+
+            const currDir = options.folder || process.cwd();
+            const modpackInfo = await getModpackInfo(currDir);
+
+            // verify neccecary files and information exist
+            if (!modpackInfo) {
+                throw new Error('No modpack.json file found');
+            }
+            if (!modpackInfo.scripts) {
+                throw new Error('No scripts defined in modpack.json');
+            }
+            if (!modpackInfo.scripts[script]) {
+                throw new Error(`Script ${script} not found in modpack.json`);
+            }
+
+            // build the full command
+            const scriptCommand = modpackInfo.scripts[script];
+            const args = command.args ? command.args.slice(1) : [];
+            const fullCommand = `${scriptCommand} ${args.join(' ')}`;
+
+            // debug logging
+            if (options.debug) {
+                console.log("CURR DIR:", currDir);
+                console.log("OPTIONS:", options);
+                console.log("SCRIPT:", script);
+                console.log("SCRIPT COMMAND:", scriptCommand);
+                console.log("ARGS:", args);
+                console.log("FULL COMMAND:", fullCommand);
+            }
+
+            // spawn the command
+            const child = spawn(fullCommand, [], {
+                shell: true,
+                stdio: 'inherit',
+                cwd: currDir
+            });
+
+            // preserve exit code on completion
+            const exitCode = await new Promise((resolve) => {
+                child.on('close', (code) => {
+                    resolve(code || 0);
+                });
+            });
+            process.exitCode = exitCode;
+        } catch (error) {
+            console.error('Error:', error.message);
+            process.exitCode = 1;
+        }
+    });
+
 modpackLock.parseAsync().catch((error) => {
     console.error('Error:', error);
     process.exit(1);

package/src/config/defaults.js

@@ -0,0 +1,8 @@
+export const DEFAULT_MODPACK_VERSION = '1.0.0';
+export const DEFAULT_MODPACK_LICENSE = 'MIT';
+export const DEFAULT_PROJECT_URL = (id) => {
+    return `https://modrinth.com/modpack/${id}`;
+};
+export const DEFAULT_SOURCE_URL = (id, author) => {
+    return `https://github.com/${author}/${id}`;
+};

package/src/config/index.js

@@ -2,3 +2,4 @@ export * from './constants.js';
 export * from './api.js';
 export * from './files.js';
 export * from './options.js';
+export * from './defaults.js';

package/src/modpack_info.js

@@ -33,64 +33,63 @@ export default async function promptUserForInfo(defaults = {}) {
             return validateNotEmpty(value, 'Name');
         },
     });
-    let answers = await prompts([
-        {
-            type: 'text',
-            name: 'version',
-            message: 'Modpack version',
-            initial: defaults.version || '1.0.0',
-            validate: (value) => {
-                return validateNotEmpty(value, 'Version');
-            },
-        },
-
-        {
-            type: 'text',
-            name: 'id',
-            message: 'Modpack slug/ID',
-            initial: slugify(defaults.id || name.name, config.SLUGIFY_OPTIONS),
-            validate: (value) => {
-                return validateNotEmpty(value, 'ID');
-            },
+    let version = await prompts({
+        type: 'text',
+        name: 'version',
+        message: 'Modpack version',
+        initial: defaults.version || config.DEFAULT_MODPACK_VERSION,
+        validate: (value) => {
+            return validateNotEmpty(value, 'Version');
         },
-        {
-            type: 'text',
-            name: 'description',
-            message: 'Modpack description',
-            initial: defaults.description || undefined,
+    });
+    let id = await prompts({
+        type: 'text',
+        name: 'id',
+        message: 'Modpack slug/ID',
+        initial: slugify(defaults.id || name.name, config.SLUGIFY_OPTIONS),
+        validate: (value) => {
+            return validateNotEmpty(value, 'ID');
         },
-        {
-            type: 'text',
-            name: 'author',
-            message: 'Modpack author',
-            initial: defaults.author || undefined,
-            validate: (value) => {
-                return validateNotEmpty(value, 'Author');
-            },
+    });
+    let description = await prompts({
+        type: 'text',
+        name: 'description',
+        message: 'Modpack description',
+        initial: defaults.description,
+    });
+    let author = await prompts({
+        type: 'text',
+        name: 'author',
+        message: 'Modpack author',
+        initial: defaults.author,
+        validate: (value) => {
+            return validateNotEmpty(value, 'Author');
         },
+    });
+    let answers = await prompts([
         {
             type: 'text',
             name: 'projectUrl',
             message: 'Modpack URL',
-            initial: defaults.projectUrl || undefined,
+            initial: defaults.projectUrl || config.DEFAULT_PROJECT_URL(id.id),
         },
         {
             type: 'text',
             name: 'sourceUrl',
             message: 'Modpack source code URL',
-            initial: defaults.sourceUrl || undefined,
+            initial: defaults.sourceUrl || config.DEFAULT_SOURCE_URL(id.id, author.author),
         },
         {
             type: 'text',
             name: 'license',
             message: 'Modpack license',
-            initial: defaults.license || undefined,
+            initial: defaults.license || config.DEFAULT_MODPACK_LICENSE,
         },
         {
             type: 'autocomplete',
             name: 'modloader',
             message: 'Modpack modloader',
-            initial: defaults.modloader || undefined,
+            initial: defaults.modloader,
             choices: [
                 { title: 'fabric' },
                 { title: 'forge' },
@@ -114,20 +113,20 @@ export default async function promptUserForInfo(defaults = {}) {
             type: 'text',
             name: 'targetModloaderVersion',
             message: 'Target modloader version',
-            initial: defaults.targetModloaderVersion || undefined,
+            initial: defaults.targetModloaderVersion,
         },
         {
             type: 'text',
             name: 'targetMinecraftVersion',
             message: 'Target Minecraft version',
-            initial: defaults.targetMinecraftVersion || undefined,
+            initial: defaults.targetMinecraftVersion,
             validate: (value) => {
                 return validateNotEmpty(value, 'Minecraft Version');
             },
         }
     ]);
 
-    let modpackInfo = {...name, ...answers};
+    let modpackInfo = {...name, ...version, ...id, ...description, ...author, ...answers};
     if (Object.keys(modpackInfo).length < 11) {
         console.warn('Modpack initialization was interrupted');
         process.exit(1);