modpack-lock 0.5.0 → 0.6.0

package/src/config/strings.js

@@ -1,85 +1,82 @@
-import * as defaults from './defaults.js';
-import pkg from '../../package.json' with { type: 'json' };
+import * as defaults from "./defaults.js";
+import * as files from "./files.js";
+import pkg from "../../package.json" with {type: "json"};
 
 export const infoFields = {
     name: {
-        prompt: 'modpack name',
-        option: 'Modpack name; defaults to the directory 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}`
+        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'
+        prompt: "modpack slug/ID",
+        option: "Modpack slug/ID; defaults to the directory name slugified",
     },
     description: {
-        prompt: 'modpack description',
-        option: 'Modpack description'
+        prompt: "modpack description",
+        option: "Modpack description",
     },
     author: {
-        prompt: 'modpack author',
-        option: 'Modpack author; required'
+        prompt: "modpack author",
+        option: "Modpack author; required",
     },
     projectUrl: {
-        prompt: 'modpack URL',
-        option: 'Modpack URL; defaults to a guessed Modrinth project URL'
+        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'
+        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`
+        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'
+        prompt: "modpack modloader",
+        option: "Modpack modloader, list of loaders fetched from Modrinth; required",
     },
     targetModloaderVersion: {
-        prompt: 'target modloader version',
-        option: 'Target modloader version'
+        prompt: "target modloader version",
+        option: "Target modloader version",
     },
     targetMinecraftVersion: {
-        prompt: 'target Minecraft version',
-        option: 'Target Minecraft version, list of versions fetched from Modrinth; required'
-    }
-}
+        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'
+        prompt: `Add the ${files.MODPACK_LICENSE_NAME} file`,
+        option: `Add the ${files.MODPACK_LICENSE_NAME} file to the modpack`,
     },
     addGitignore: {
-        prompt: 'Update the .gitignore file',
-        option: 'Update the .gitignore file to ignore content hosted on Modrinth'
+        prompt: `Update the ${files.GITIGNORE_NAME} file`,
+        option: `Update the ${files.GITIGNORE_NAME} file to ignore content hosted on Modrinth`,
     },
     addReadme: {
-        prompt: 'Generate README.md files',
-        option: 'Generate README.md files for each category'
-    }
-}
+        prompt: `Generate ${files.README_NAME} files`,
+        option: `Generate ${files.README_NAME} files for each category`,
+    },
+};
 
 export const headings = {
     options: "Options:",
     generation: "GENERATION",
     logging: "LOGGING",
     packInfo: "MODPACK INFORMATION",
-    information: "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 const ARR_LICENSE_TEXT = "Copyright (c) [year] [fullname]\n" + "\n" + "All rights reserved.\n";
 
 export {pkg};

package/src/config/types.js

@@ -40,6 +40,7 @@
  * @property {boolean} silent - Whether to silent the console output
  * @property {boolean} gitignore - Whether to generate a .gitignore file
  * @property {boolean} readme - Whether to generate README.md files
+ * @property {boolean} licenseFile - Whether to generate a license file
  */
 
 /**
@@ -48,8 +49,8 @@
  * @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 {boolean} addGitignore - Whether to generate .gitignore rules
+ * @property {boolean} addReadme - 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

package/src/directory_scanning.js

@@ -1,7 +1,8 @@
-import fs from 'fs/promises';
-import crypto from 'crypto';
-import path from 'path';
-import * as config from './config/index.js';
+import fs from "fs/promises";
+import crypto from "crypto";
+import path from "path";
+import * as config from "./config/index.js";
+import {logm} from "./logger.js";
 
 /**
  * @typedef {import('./config/types.js').ModpackInfo} ModpackInfo
@@ -16,7 +17,7 @@ import * as config from './config/index.js';
 export function getScanDirectories(directoryPath) {
     const scanDirectories = [];
     for (const category of config.DEPENDENCY_CATEGORIES) {
-        scanDirectories.push({ name: category, path: path.join(directoryPath, category) });
+        scanDirectories.push({name: category, path: path.join(directoryPath, category)});
     }
     return scanDirectories;
 }
@@ -26,7 +27,7 @@ export function getScanDirectories(directoryPath) {
  */
 async function calculateSHA1(filePath) {
     const fileBuffer = await fs.readFile(filePath);
-    return crypto.createHash('sha1').update(fileBuffer).digest('hex');
+    return crypto.createHash("sha1").update(fileBuffer).digest("hex");
 }
 
 /**
@@ -36,21 +37,21 @@ async function findFiles(dirPath) {
     const files = [];
 
     try {
-        const entries = await fs.readdir(dirPath, { withFileTypes: true });
+        const entries = await fs.readdir(dirPath, {withFileTypes: true});
 
         for (const entry of entries) {
-            if (entry.isFile() && (entry.name.endsWith('.jar') || entry.name.endsWith('.zip'))) {
+            if (entry.isFile() && (entry.name.endsWith(".jar") || entry.name.endsWith(".zip"))) {
                 const fullPath = path.join(dirPath, entry.name);
                 files.push(fullPath);
             }
         }
     } catch (error) {
-        if (error.code !== 'ENOENT') {
-            console.warn(`Warning: Could not read directory ${dirPath}: ${error.message}`);
+        if (error.code !== "ENOENT") {
+            logm.warn(`Could not read directory ${dirPath}: ${error.message}`);
         }
     }
 
-    files.sort((a, b) => a.localeCompare(b, 'en', { numeric: true, sensitivity: 'base' }));
+    files.sort((a, b) => a.localeCompare(b, "en", {numeric: true, sensitivity: "base"}));
     return files;
 }
 
@@ -73,7 +74,7 @@ export async function scanDirectory(dirInfo, workspaceRoot) {
                 category: dirInfo.name,
             });
         } catch (error) {
-            console.warn(`Warning: Could not hash file ${filePath}: ${error.message}`);
+            logm.warn(`Could not hash file ${filePath}: ${error.message}`);
         }
     }
 
@@ -87,10 +88,10 @@ async function getJsonFile(directoryPath, filename) {
     const jsonPath = path.join(directoryPath, filename);
     // try to read the file
     try {
-        const fileContent = await fs.readFile(jsonPath, 'utf-8');
+        const fileContent = await fs.readFile(jsonPath, "utf-8");
         return JSON.parse(fileContent);
     } catch (error) {
-        if (error.code !== 'ENOENT') {
+        if (error.code !== "ENOENT") {
             throw new Error(`Error: Could not read file ${jsonPath}: ${error.message}`);
         } else {
             return null;

package/src/generate_gitignore.js

@@ -0,0 +1,113 @@
+import fs from "fs/promises";
+import path from "path";
+import * as config from "./config/index.js";
+import {logm, styleText} from "./logger.js";
+
+/**
+ * @typedef {import('./config/types.js').Options} Options
+ * @typedef {import('./config/types.js').InitOptions} InitOptions
+ * @typedef {import('./config/types.js').Lockfile} Lockfile
+ */
+
+/**
+ * Generate .gitignore rules for files not hosted on Modrinth and write them to .gitignore file
+ * @param {Lockfile} lockfile - The lockfile object
+ * @param {string} workingDir - The working directory
+ * @param {Options | InitOptions} options - The options object
+ */
+export async function generateGitignoreRules(lockfile, workingDir, options = {}) {
+    logm.quietFromOptions(options);
+
+    const rules = [];
+    const exceptions = [];
+
+    // Base ignore patterns for each category
+    for (const category of config.DEPENDENCY_CATEGORIES) {
+        rules.push(`${category}/*.${category === "mods" ? "jar" : "zip"}`);
+    }
+    rules.push(`*/**/*.disabled`);
+
+    // Find files not hosted on Modrinth
+    for (const [category, entries] of Object.entries(lockfile.dependencies)) {
+        for (const entry of entries) {
+            if (entry.version === null) {
+                exceptions.push(`!${entry.path}`);
+            }
+        }
+    }
+
+    // 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") {
+            logm.warn(`Could not read ${config.GITIGNORE_NAME} 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 {
+        // 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",
+            );
+        }
+    }
+
+    // Write the updated content
+    if (options.dryRun) {
+        logm.debug(config.dryRunText(config.GITIGNORE_NAME, gitignorePath));
+    } else {
+        try {
+            await fs.writeFile(gitignorePath, newContent, "utf-8");
+            logm.generated(config.GITIGNORE_NAME, gitignorePath);
+        } catch (error) {
+            logm.warn(`Could not write ${config.GITIGNORE_NAME} file: ${error.message}`);
+        }
+    }
+}

package/src/generate_json.js

@@ -1,7 +1,8 @@
-import fs from 'fs/promises';
-import path from 'path';
-import { getProjects } from './modrinth_interactions.js';
-import * as config from './config/index.js';
+import fs from "fs/promises";
+import path from "path";
+import {getProjects} from "./modrinth_interactions.js";
+import * as config from "./config/index.js";
+import {logm} from "./logger.js";
 
 /**
  * @typedef {import('./config/types.js').ModpackInfo} ModpackInfo
@@ -25,19 +26,21 @@ function createModpackJson(modpackInfo, dependencies) {
  */
 async function writeJson(jsonObject, outputPath) {
     const content = JSON.stringify(jsonObject, null, 2);
-    await fs.writeFile(path.join(outputPath, config.MODPACK_JSON_NAME), content, 'utf-8');
-    console.log(`${config.MODPACK_JSON_NAME} written to: ${path.join(outputPath, config.MODPACK_JSON_NAME)}`);
+    await fs.writeFile(path.join(outputPath, config.MODPACK_JSON_NAME), content, "utf-8");
+    logm.generated(config.MODPACK_JSON_NAME, path.join(outputPath, config.MODPACK_JSON_NAME));
 }
 
 /**
  * Generate a modpack.json file
  * @param {ModpackInfo} modpackInfo - The modpack information
  * @param {Lockfile} lockfile - The lockfile
- * @param {string} outputDir - The path to write the JSON object to
+ * @param {string} workingDir - The path to write the JSON object to
  * @param {Options | InitOptions} options - The options object
  * @returns {Promise<Lockfile>} The JSON file's object
  */
-export default async function generateJson(modpackInfo, lockfile, outputDir, options = {}) {
+export default async function generateJson(modpackInfo, lockfile, workingDir, options = {}) {
+    logm.quietFromOptions(options);
+
     // Validate modpack info
     for (const field of config.MODPACK_INFO_REQUIRED_FIELDS) {
         if (!modpackInfo[field]) {
@@ -53,53 +56,51 @@ export default async function generateJson(modpackInfo, lockfile, outputDir, opt
     }
 
     // Collect project IDs from lockfile
-    if (lockfile) if (lockfile.dependencies) {
-        for (const [category, entries] of Object.entries(lockfile.dependencies)) {
-            for (const entry of entries) {
-                if (entry.version && entry.version.project_id) {
-                    projectIds[category].add(entry.version.project_id);
-                } else {
-                    packDependencies[category].push(entry.path);
+    if (lockfile)
+        if (lockfile.dependencies) {
+            for (const [category, entries] of Object.entries(lockfile.dependencies)) {
+                for (const entry of entries) {
+                    if (entry.version && entry.version.project_id) {
+                        projectIds[category].add(entry.version.project_id);
+                    } else {
+                        packDependencies[category].push(entry.path);
+                    }
                 }
             }
-        }
-        const allProjectIds = new Set();
-        for (const category of config.DEPENDENCY_CATEGORIES) {
-            for (const projectId of projectIds[category]) {
-                allProjectIds.add(projectId);
+            const allProjectIds = new Set();
+            for (const category of config.DEPENDENCY_CATEGORIES) {
+                for (const projectId of projectIds[category]) {
+                    allProjectIds.add(projectId);
+                }
             }
-        }
 
-        // Fetch projects from Modrinth
-        const projects = await getProjects(Array.from(allProjectIds));
-        const projectsMap = {};
-        for (const project of projects) {
-            projectsMap[project.id] = project.slug;
-        }
+            // Fetch projects from Modrinth
+            const projects = await getProjects(Array.from(allProjectIds));
+            const projectsMap = {};
+            for (const project of projects) {
+                projectsMap[project.id] = project.slug;
+            }
 
-        // Add projects to dependencies by category
-        for (const category of config.DEPENDENCY_CATEGORIES) {
-            for (const projectId of projectIds[category]) {
-                const projectSlug = projectsMap[projectId];
-                if (projectSlug) {
-                    packDependencies[category].push(projectSlug);
+            // Add projects to dependencies by category
+            for (const category of config.DEPENDENCY_CATEGORIES) {
+                for (const projectId of projectIds[category]) {
+                    const projectSlug = projectsMap[projectId];
+                    if (projectSlug) {
+                        packDependencies[category].push(projectSlug);
+                    }
                 }
             }
         }
-    }
 
     // Create modpack JSON object
     const jsonObject = createModpackJson(modpackInfo, packDependencies);
 
     // Write modpack JSON object to disk
     if (options.dryRun) {
-        console.log(config.dryRunText(config.MODPACK_JSON_NAME, path.join(outputDir, config.MODPACK_JSON_NAME)));
+        logm.debug(config.dryRunText(config.MODPACK_JSON_NAME, path.join(workingDir, config.MODPACK_JSON_NAME)));
     } else {
-        await writeJson(jsonObject, outputDir);
+        await writeJson(jsonObject, workingDir);
     }
 
     return jsonObject;
 }
-
-
-

package/src/generate_license.js

@@ -1,7 +1,8 @@
-import fs from 'fs/promises';
-import path from 'path';
-import { getLicenseText } from './github_interactions.js';
-import * as config from './config/index.js';
+import fs from "fs/promises";
+import path from "path";
+import {getLicenseText} from "./github_interactions.js";
+import * as config from "./config/index.js";
+import {logm} from "./logger.js";
 
 /**
  * @typedef {import('./config/types.js').ModpackInfo} ModpackInfo
@@ -10,41 +11,44 @@ import * as config from './config/index.js';
  */
 
 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)}`);
+    await fs.writeFile(path.join(outputPath, config.MODPACK_LICENSE_NAME), licenseText, "utf-8");
+    logm.generated(config.MODPACK_LICENSE_NAME, 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 {string} workingDir - 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) {
+export default async function generateLicense(modpackInfo, workingDir, options = {}, licenseTextOverride = null) {
+    logm.quietFromOptions(options);
+
     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);
+        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)));
+            logm.debug(
+                config.dryRunText(config.MODPACK_LICENSE_NAME, path.join(workingDir, config.MODPACK_LICENSE_NAME)),
+            );
         } else {
-            await writeLicense(licenseText, outputPath);
+            await writeLicense(licenseText, workingDir);
         }
         return licenseText;
     } catch (error) {
-        console.warn(`Warning: unable to generate license for: ${modpackInfo.license}`);
+        logm.warn(`Unable to generate license for: ${modpackInfo.license}`);
         return null;
     }
 }