modpack-lock 0.4.0 → 0.5.0

package/src/config/strings.js

@@ -0,0 +1,85 @@
+import * as defaults from './defaults.js';
+import pkg from '../../package.json' with { type: 'json' };
+
+export const infoFields = {
+    name: {
+        prompt: 'modpack name',
+        option: 'Modpack name; defaults to the directory name'
+    },
+    version: {
+        prompt: 'modpack version',
+        option: `Modpack version; defaults to ${defaults.DEFAULT_MODPACK_VERSION}`
+    },
+    id: {
+        prompt: 'modpack slug/ID',
+        option: 'Modpack slug/ID; defaults to the directory name slugified'
+    },
+    description: {
+        prompt: 'modpack description',
+        option: 'Modpack description'
+    },
+    author: {
+        prompt: 'modpack author',
+        option: 'Modpack author; required'
+    },
+    projectUrl: {
+        prompt: 'modpack URL',
+        option: 'Modpack URL; defaults to a guessed Modrinth project URL'
+    },
+    sourceUrl: {
+        prompt: 'modpack source code URL',
+        option: 'Modpack source code URL; defaults to a guessed GitHub repository URL'
+    },
+    license: {
+        prompt: 'modpack license',
+        option: `Modpack license, popular licenses fetched from GitHub; defaults to ${defaults.DEFAULT_MODPACK_LICENSE} in interactive mode`
+    },
+    modloader: {
+        prompt: 'modpack modloader',
+        option: 'Modpack modloader, list of loaders fetched from Modrinth; required'
+    },
+    targetModloaderVersion: {
+        prompt: 'target modloader version',
+        option: 'Target modloader version'
+    },
+    targetMinecraftVersion: {
+        prompt: 'target Minecraft version',
+        option: 'Target Minecraft version, list of versions fetched from Modrinth; required'
+    }
+}
+
+export const fileFields = {
+    addLicense: {
+        prompt: 'Add the LICENSE file',
+        option: 'Add the LICENSE file to the modpack'
+    },
+    addGitignore: {
+        prompt: 'Update the .gitignore file',
+        option: 'Update the .gitignore file to ignore content hosted on Modrinth'
+    },
+    addReadme: {
+        prompt: 'Generate README.md files',
+        option: 'Generate README.md files for each category'
+    }
+}
+
+export const headings = {
+    options: "Options:",
+    generation: "GENERATION",
+    logging: "LOGGING",
+    packInfo: "MODPACK INFORMATION",
+    information: "INFORMATION"
+};
+
+export const dryRunText = (filename, location) => {
+    return `[DRY RUN] Would write ${filename} to: ${location}`;
+}
+
+/** All-Rights-Reserved license text */
+export const ARR_LICENSE_TEXT =
+    "Copyright (c) [year] [fullname]\n" +
+    "\n" +
+    "All rights reserved.\n";
+
+
+export {pkg};

package/src/config/types.js

@@ -42,4 +42,34 @@
  * @property {boolean} readme - Whether to generate README.md files
  */
 
+/**
+ * @typedef {Object} InitOptions
+ * Contains options for the initialization of the modpack files.
+ * @property {string} folder - The folder to generate the modpack files in
+ * @property {boolean} noninteractive - Whether to run the interactive mode
+ * @property {boolean} addLicense - Whether to add the license file to the modpack
+ * @property {boolean} gitignore - Whether to generate .gitignore rules
+ * @property {boolean} readme - Whether to generate README.md files
+ * @property {string} name - The name of the modpack
+ * @property {string} version - The version of the modpack
+ * @property {string} id - The slug/ID of the modpack
+ * @property {string} description - The description of the modpack
+ * @property {string} author - The author of the modpack
+ * @property {string} projectUrl - The modpack's project URL
+ * @property {string} sourceUrl - The modpack's source code URL
+ * @property {string} license - The modpack's license
+ * @property {string} modloader - The modpack's modloader
+ * @property {string} targetModloaderVersion - The target modloader version
+ * @property {string} targetMinecraftVersion - The target Minecraft version
+ * @property {boolean} _init - Internal boolean added to indicate options come from the `init` command.
+ */
+
+/**
+ * @typedef {Object} RunOptions
+ * Contains options for the running scripts defined in modpack.json.
+ * @property {string} folder - The folder to look for modpack.json in
+ * @property {boolean} debug - Whether to print debug information about the executed script
+ * @property {boolean} _run - Internal boolean added to indicate options come from the `run` command.
+ */
+
 export {};

package/src/directory_scanning.js

@@ -1,8 +1,7 @@
 import fs from 'fs/promises';
 import crypto from 'crypto';
 import path from 'path';
-import * as files from './config/files.js';
-import * as constants from './config/constants.js';
+import * as config from './config/index.js';
 
 /**
  * @typedef {import('./config/types.js').ModpackInfo} ModpackInfo
@@ -16,7 +15,7 @@ import * as constants from './config/constants.js';
  */
 export function getScanDirectories(directoryPath) {
     const scanDirectories = [];
-    for (const category of constants.DEPENDENCY_CATEGORIES) {
+    for (const category of config.DEPENDENCY_CATEGORIES) {
         scanDirectories.push({ name: category, path: path.join(directoryPath, category) });
     }
     return scanDirectories;
@@ -105,7 +104,7 @@ async function getJsonFile(directoryPath, filename) {
  * @returns {Promise<ModpackInfo|null>} The modpack info JSON object if the file exists, otherwise null
  */
 export async function getModpackInfo(directoryPath) {
-    return getJsonFile(directoryPath, files.MODPACK_JSON_NAME);
+    return getJsonFile(directoryPath, config.MODPACK_JSON_NAME);
 }
 
 /**
@@ -114,5 +113,5 @@ export async function getModpackInfo(directoryPath) {
  * @returns {Lockfile|null} The JSON object if the file exists, otherwise null
  */
 export async function getLockfile(directoryPath) {
-    return getJsonFile(directoryPath, files.MODPACK_LOCKFILE_NAME);
+    return getJsonFile(directoryPath, config.MODPACK_LOCKFILE_NAME);
 }

package/src/generate_json.js

@@ -6,6 +6,7 @@ import * as config from './config/index.js';
 /**
  * @typedef {import('./config/types.js').ModpackInfo} ModpackInfo
  * @typedef {import('./config/types.js').Options} Options
+ * @typedef {import('./config/types.js').InitOptions} InitOptions
  * @typedef {import('./config/types.js').Lockfile} Lockfile
  */
 
@@ -33,7 +34,7 @@ async function writeJson(jsonObject, outputPath) {
  * @param {ModpackInfo} modpackInfo - The modpack information
  * @param {Lockfile} lockfile - The lockfile
  * @param {string} outputDir - The path to write the JSON object to
- * @param {Options} options - The options object
+ * @param {Options | InitOptions} options - The options object
  * @returns {Promise<Lockfile>} The JSON file's object
  */
 export default async function generateJson(modpackInfo, lockfile, outputDir, options = {}) {
@@ -84,7 +85,6 @@ export default async function generateJson(modpackInfo, lockfile, outputDir, opt
                     packDependencies[category].push(projectSlug);
                 }
             }
-            //packDependencies[category].push(...packDependencies[category].map(item => item.path));
         }
     }
 
@@ -93,7 +93,7 @@ export default async function generateJson(modpackInfo, lockfile, outputDir, opt
 
     // Write modpack JSON object to disk
     if (options.dryRun) {
-        console.log(`[DRY RUN] Would write ${config.MODPACK_JSON_NAME} to: ${path.join(outputDir, config.MODPACK_JSON_NAME)}`);
+        console.log(config.dryRunText(config.MODPACK_JSON_NAME, path.join(outputDir, config.MODPACK_JSON_NAME)));
     } else {
         await writeJson(jsonObject, outputDir);
     }

package/src/generate_license.js

@@ -0,0 +1,50 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { getLicenseText } from './github_interactions.js';
+import * as config from './config/index.js';
+
+/**
+ * @typedef {import('./config/types.js').ModpackInfo} ModpackInfo
+ * @typedef {import('./config/types.js').Options} Options
+ * @typedef {import('./config/types.js').InitOptions} InitOptions
+ */
+
+async function writeLicense(licenseText, outputPath) {
+    await fs.writeFile(path.join(outputPath, config.MODPACK_LICENSE_NAME), licenseText, 'utf-8');
+    console.log(`${config.MODPACK_LICENSE_NAME} written to: ${path.join(outputPath, config.MODPACK_LICENSE_NAME)}`);
+}
+
+/**
+ * Write a license to a file
+ * @param {ModpackInfo} modpackInfo - The modpack information
+ * @param {string} outputPath - The path to write the license to
+ * @param {InitOptions} options - The initialization options object
+ * @param {string} licenseTextOverride - The license text to override the default license text with
+ * @returns {Promise<string> | null} The license text or null if the license text could not be generated
+ */
+export default async function generateLicense(modpackInfo, outputPath, options = {}, licenseTextOverride = null) {
+    try {
+        const spdxId = modpackInfo.license;
+        console.log(`Generating license for: ${spdxId}`);
+
+        let licenseText = licenseTextOverride || await getLicenseText(spdxId);
+        licenseText = licenseText.replace('[year]', new Date().getFullYear());
+        licenseText = licenseText.replace('{{year}}', new Date().getFullYear());
+        licenseText = licenseText.replace('[fullname]', modpackInfo.author);
+        licenseText = licenseText.replace('{{fullname}}', modpackInfo.author);
+        licenseText = licenseText.replace('[organization]', modpackInfo.author);
+        licenseText = licenseText.replace('{{organization}}', modpackInfo.author);
+        licenseText = licenseText.replace('[project]', modpackInfo.name);
+        licenseText = licenseText.replace('{{project}}', modpackInfo.name);
+
+        if (options.dryRun) {
+            console.log(config.dryRunText(config.MODPACK_LICENSE_NAME, path.join(outputPath, config.MODPACK_LICENSE_NAME)));
+        } else {
+            await writeLicense(licenseText, outputPath);
+        }
+        return licenseText;
+    } catch (error) {
+        console.warn(`Warning: unable to generate license for: ${modpackInfo.license}`);
+        return null;
+    }
+}

package/src/generate_lockfile.js

@@ -6,6 +6,7 @@ import * as config from './config/index.js';
 
 /**
  * @typedef {import('./config/types.js').Options} Options
+ * @typedef {import('./config/types.js').InitOptions} InitOptions
  * @typedef {import('./config/types.js').Lockfile} Lockfile
  */
 
@@ -137,11 +138,12 @@ function generateCategoryReadme(category, entries, projectsMap, usersMap) {
 }
 
 /**
- * Generate .gitignore rules for files not hosted on Modrinth
+ * Generate .gitignore rules for files not hosted on Modrinth and write them to .gitignore file
  * @param {Lockfile} lockfile - The lockfile object
- * @returns {string} The .gitignore rules
+ * @param {string} workingDir - The working directory
+ * @param {Options | InitOptions} options - The options object
  */
-export function generateGitignoreRules(lockfile) {
+export async function generateGitignoreRules(lockfile, workingDir, options = {}) {
     const rules = [];
     const exceptions = [];
 
@@ -149,7 +151,7 @@ export function generateGitignoreRules(lockfile) {
     for (const category of config.DEPENDENCY_CATEGORIES) {
         rules.push(`${category}/*.${category === "mods" ? "jar" : "zip"}`);
     }
-    rules.push('\n## Exceptions');
+    rules.push(`*/**/*.disabled`);
 
     // Find files not hosted on Modrinth
     for (const [category, entries] of Object.entries(lockfile.dependencies)) {
@@ -162,19 +164,104 @@ export function generateGitignoreRules(lockfile) {
 
     // Add exceptions if any
     if (exceptions.length > 0) {
+        rules.push('\n## Exceptions');
         rules.push(...exceptions);
+    }
+
+    const rulesContent = rules.join('\n');
+    const gitignorePath = path.join(workingDir, config.GITIGNORE_NAME);
+
+    // Read existing .gitignore file if it exists
+    let existingContent = '';
+    try {
+        existingContent = await fs.readFile(gitignorePath, 'utf-8');
+    } catch (error) {
+        // File doesn't exist, that's okay - we'll create it
+        if (error.code !== 'ENOENT') {
+            console.warn(`Warning: Could not read .gitignore file: ${error.message}`);
+            return;
+        }
+    }
+
+    // Find markers in existing content
+    const startMarkerIndex = existingContent.indexOf(config.GITIGNORE_START_MARKER);
+    const endMarkerIndex = existingContent.indexOf(config.GITIGNORE_END_MARKER);
+
+    let newContent = '';
+
+    if (startMarkerIndex !== -1 && endMarkerIndex !== -1 && endMarkerIndex > startMarkerIndex) {
+        // Both markers exist, replace content between them
+        const beforeSection = existingContent.substring(0, startMarkerIndex);
+        const afterSection = existingContent.substring(endMarkerIndex + config.GITIGNORE_END_MARKER.length);
+
+        // Remove trailing newlines from before section and leading newlines from after section
+        const beforeTrimmed = beforeSection.replace(/\n+$/, '');
+        const afterTrimmed = afterSection.replace(/^\n+/, '');
+
+        const parts = [beforeTrimmed];
+        if (beforeTrimmed) parts.push(''); // Add separator if there's content before
+        parts.push(
+            config.GITIGNORE_START_MARKER,
+            rulesContent,
+            config.GITIGNORE_END_MARKER
+        );
+        if (afterTrimmed) {
+            parts.push(''); // Add separator if there's content after
+            parts.push(afterTrimmed);
+        }
+
+        newContent = parts.join('\n');
+    } else if (startMarkerIndex !== -1 || endMarkerIndex !== -1) {
+        // Only one marker exists, append to end
+        const trimmed = existingContent.replace(/\n+$/, '');
+        newContent = [
+            trimmed,
+            '',
+            config.GITIGNORE_START_MARKER,
+            rulesContent,
+            config.GITIGNORE_END_MARKER
+        ].join('\n');
     } else {
-        rules.push('# No exceptions needed - all files are hosted on Modrinth');
+        // No markers exist, append to end
+        if (existingContent.trim() === '') {
+            // File is empty or only whitespace
+            newContent = [
+                config.GITIGNORE_START_MARKER,
+                rulesContent,
+                config.GITIGNORE_END_MARKER
+            ].join('\n');
+        } else {
+            // File has content, append with newline
+            const trimmed = existingContent.replace(/\n+$/, '');
+            newContent = [
+                trimmed,
+                '',
+                config.GITIGNORE_START_MARKER,
+                rulesContent,
+                config.GITIGNORE_END_MARKER
+            ].join('\n');
+        }
     }
 
-    return rules.join('\n');
+    // Write the updated content
+    if (options.dryRun) {
+        console.log(config.dryRunText(config.GITIGNORE_NAME, gitignorePath));
+        console.log();
+    } else {
+        try {
+            await fs.writeFile(gitignorePath, newContent, 'utf-8');
+            console.log(`Updated .gitignore: ${gitignorePath}`);
+        } catch (error) {
+            console.warn(`Warning: Could not write .gitignore file: ${error.message}`);
+        }
+    }
 }
 
 /**
  * Generate the README.md files for each category
  * @param {Lockfile} lockfile - The lockfile object
  * @param {string} workingDir - The working directory
- * @param {Options} options - The options object
+ * @param {Options | InitOptions} options - The options object
  */
 export async function generateReadmeFiles(lockfile, workingDir, options = {}) {
     // Collect unique project IDs and author IDs from version data
@@ -221,10 +308,10 @@ export async function generateReadmeFiles(lockfile, workingDir, options = {}) {
         const categoryDir = getScanDirectories(workingDir).find(d => d.name === category);
 
         if (categoryDir) {
-            const readmePath = path.join(categoryDir.path, 'README.md');
+            const readmePath = path.join(categoryDir.path, config.README_NAME);
 
             if (options.dryRun) {
-                console.log(`[DRY RUN] Would write README to: ${readmePath}`);
+                console.log(config.dryRunText(config.README_NAME, readmePath));
             } else {
                 try {
                     await fs.writeFile(readmePath, readmeContent, 'utf-8');
@@ -246,10 +333,6 @@ export async function generateReadmeFiles(lockfile, workingDir, options = {}) {
  * @returns {Lockfile} The lockfile object
  */
 export async function generateLockfile(workingDir, options = {}) {
-    if (options.dryRun) {
-        console.log('[DRY RUN] Preview mode - no files will be written');
-    }
-
     console.log('Scanning directories for modpack files...');
 
     // Scan all directories
@@ -273,7 +356,7 @@ export async function generateLockfile(workingDir, options = {}) {
         console.log('No files found. Creating empty lockfile.');
         const outputPath = path.join(workingDir, config.MODPACK_LOCKFILE_NAME);
         if (options.dryRun) {
-            console.log(`[DRY RUN] Would write lockfile to: ${outputPath}`);
+            console.log(config.dryRunText(config.MODPACK_LOCKFILE_NAME, outputPath));
         } else {
             await writeLockfile(createEmptyLockfile(), outputPath);
         }
@@ -297,7 +380,7 @@ export async function generateLockfile(workingDir, options = {}) {
     // Write lockfile
     const outputPath = path.join(workingDir, config.MODPACK_LOCKFILE_NAME);
     if (options.dryRun) {
-        console.log(`[DRY RUN] Would write lockfile to: ${outputPath}`);
+        console.log(config.dryRunText(config.MODPACK_LOCKFILE_NAME, outputPath));
     } else {
         await writeLockfile(lockfile, outputPath);
     }
@@ -312,15 +395,13 @@ export async function generateLockfile(workingDir, options = {}) {
 
     // Generate .gitignore rules
     if (options.gitignore) {
-        console.log('\n=== .gitignore Rules ===\n');
-        console.log(generateGitignoreRules(lockfile));
-        console.log();
+        await generateGitignoreRules(lockfile, workingDir, options);
     }
 
     // Generate README files
     if (options.readme) {
         console.log('\nGenerating README files...');
-        await generateReadmeFiles(lockfile, workingDir, options = {});
+        await generateReadmeFiles(lockfile, workingDir, options);
     }
 
     return lockfile;

package/src/github_interactions.js

@@ -0,0 +1,73 @@
+import * as config from './config/index.js';
+
+
+/**
+ * Fetch a list of the most popular licenses from GitHub
+ * @param {boolean} featured - If the fetch should be limited to featured licenses
+ * @returns {Promise<Array<Object>>} The list of licenses for use in a prompt
+ */
+export async function getLicenseList(featured = false) {
+    try {
+        const url = featured ? config.GITHUB_FEATURED_LICENSES_ENDPOINT : config.GITHUB_LICENSES_ENDPOINT;
+        const response = await fetch(url);
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`GitHub API error (${response.status}): ${errorText}`);
+        }
+        let licenseList = await response.json();
+
+        let licenseSpdxIds = licenseList.map(license => ({ title: license.spdx_id, value: license.key }));
+
+
+        if (!featured) {
+            // get featured licenses and place them at the beginning of the list, removing them from the original list
+            licenseSpdxIds.unshift(config.ALL_RIGHTS_RESERVED_LICENSE);
+            licenseSpdxIds.push(config.OTHER_OPTION);
+            const featuredLicenseList = await getLicenseList(true);
+            for (const license of featuredLicenseList) {
+                licenseSpdxIds= licenseSpdxIds.filter( id => id !== license );
+                licenseSpdxIds.unshift(license);
+            };
+        }
+
+        return licenseSpdxIds;
+    } catch (error) {
+        console.warn(`Warning: could not fetch license list. Using fallbacks.`);
+        const licenses = config.FALLBACK_LICENSES.push(config.ALL_RIGHTS_RESERVED_LICENSE)
+        licenses.push(config.OTHER_OPTION);
+        return licenses;
+    }
+}
+
+/**
+ * Fetch specific license information from GitHub
+ * @param {string} spdxId - The SPDX ID of the license
+ * @returns {Promise<string> | null} The license text
+ */
+export async function getLicenseText(spdxId) {
+    if (spdxId === 'all-rights-reserved') {
+        return config.ARR_LICENSE_TEXT;
+    }
+    try {
+        const url = config.GITHUB_LICENSE_ENDPOINT(spdxId.toLowerCase());
+        const response = await fetch(url);
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`GitHub API error (${response.status}): ${errorText}`);
+        }
+
+        const json = await response.json();
+        if (json.body) {
+            return json.body;
+        } else {
+            throw new Error();
+        }
+        return null;
+    } catch (error) {
+        console.warn(`Warning: could not find license text for: ${spdxId}`);
+        return null;
+    }
+}
+
+
+

package/src/modpack-lock.js

@@ -1,11 +1,13 @@
 import { generateLockfile, generateReadmeFiles, generateGitignoreRules } from './generate_lockfile.js';
 import generateJson from './generate_json.js';
-import promptUserForInfo from './modpack_info.js';
+import generateLicense from './generate_license.js';
+import { promptUserForInfo } from './modpack_info.js';
 import { getModpackInfo, getLockfile } from './directory_scanning.js';
 
 /**
  * @typedef {import('./config/types.js').ModpackInfo} ModpackInfo
  * @typedef {import('./config/types.js').Options} Options
+ * @typedef {import('./config/types.js').InitOptions} InitOptions
  * @typedef {import('./config/types.js').Lockfile} Lockfile
  */
 
@@ -19,7 +21,7 @@ import { getModpackInfo, getLockfile } from './directory_scanning.js';
  * Generate the modpack files (lockfile and JSON)
  * @param {ModpackInfo} modpackInfo - The modpack information
  * @param {string} directory - The directory to generate the files in
- * @param {Options} options - The options object
+ * @param {Options | InitOptions } options - The options object
  * @returns {Promise<Lockfile>} The lockfile object
  */
 async function generateModpackFiles(modpackInfo, directory, options = {}) {
@@ -28,4 +30,4 @@ async function generateModpackFiles(modpackInfo, directory, options = {}) {
     return lockfile;
 }
 
-export { generateModpackFiles, generateJson, generateLockfile, generateGitignoreRules, generateReadmeFiles, getModpackInfo, getLockfile, promptUserForInfo };
+export { generateModpackFiles, generateJson, generateLockfile, generateGitignoreRules, generateReadmeFiles, generateLicense, getModpackInfo, getLockfile, promptUserForInfo };