modpack-lock 0.5.1 → 0.6.0

package/src/generate_readme.js

@@ -0,0 +1,224 @@
+import fs from "fs/promises";
+import path from "path";
+import {getProjects, getUsers} from "./modrinth_interactions.js";
+import {getScanDirectories} from "./directory_scanning.js";
+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 README.md content for a category
+ */
+function generateCategoryReadme(category, entries, projectsMap, usersMap) {
+    const categoryTitle = category.charAt(0).toUpperCase() + category.slice(1);
+    const lines = [`# ${categoryTitle}`, "", "| Name | Author | Version | Dependencies | Dependants |", "|-|-|-|-|-|"];
+
+    // Map category to Modrinth URL path segment
+    const categoryPathMap = {};
+    for (const cat of config.DEPENDENCY_CATEGORIES) {
+        categoryPathMap[cat] = cat === "shaderpacks" ? "shader" : cat.toLowerCase().slice(0, -1);
+    }
+    const categoryPath = categoryPathMap[category] || "project";
+
+    // Build a set of project_ids present in this category for filtering dependencies
+    const categoryProjectIds = new Set();
+    for (const entry of entries) {
+        if (entry.version && entry.version.project_id) {
+            categoryProjectIds.add(entry.version.project_id);
+        }
+    }
+
+    for (const entry of entries) {
+        const version = entry.version;
+        let nameCell = "";
+        let authorCell = "";
+        let versionCell = "";
+        let dependenciesCell = "";
+        let dependantsCell = "";
+
+        if (version && version.project_id) {
+            const project = projectsMap[version.project_id];
+            const author = version.author_id ? usersMap[version.author_id] : null;
+
+            // Name column with icon and link
+            if (project) {
+                const projectName = project.title || project.slug || "Unknown";
+                const projectSlug = project.slug || project.id;
+                const projectUrl = `https://modrinth.com/${categoryPath}/${projectSlug}`;
+
+                if (project.icon_url) {
+                    nameCell = `<img alt="Icon" src="${project.icon_url}" height="20px"> [${projectName}](${projectUrl})`;
+                } else {
+                    nameCell = `[${projectName}](${projectUrl})`;
+                }
+            } else {
+                // Project not found, use filename
+                const fileName = path.basename(entry.path);
+                nameCell = fileName;
+            }
+
+            // Author column with avatar and link
+            if (author) {
+                const authorName = author.username || "Unknown";
+                const authorUrl = `https://modrinth.com/user/${authorName}`;
+
+                if (author.avatar_url) {
+                    authorCell = `<img alt="Avatar" src="${author.avatar_url}" height="20px"> [${authorName}](${authorUrl})`;
+                } else {
+                    authorCell = `[${authorName}](${authorUrl})`;
+                }
+            } else {
+                authorCell = "Unknown";
+            }
+
+            // Version column
+            versionCell = version.version_number || "Unknown";
+
+            // Dependencies column - only show dependencies that are present in this category
+            if (version.dependencies && Array.isArray(version.dependencies) && version.dependencies.length > 0) {
+                const dependencyLinks = [];
+                for (const dep of version.dependencies) {
+                    if (dep.project_id && categoryProjectIds.has(dep.project_id)) {
+                        const depProject = projectsMap[dep.project_id];
+                        if (depProject) {
+                            const depProjectName = depProject.title || depProject.slug || "Unknown";
+                            const depProjectSlug = depProject.slug || depProject.id;
+                            const depUrl = `https://modrinth.com/${categoryPath}/${depProjectSlug}`;
+                            if (depProject.icon_url) {
+                                dependencyLinks.push(
+                                    `<a href="${depUrl}"><img alt="${depProjectName}" src="${depProject.icon_url}" height="20px"></a>`,
+                                );
+                            } else {
+                                dependencyLinks.push(`[${depProjectName}](${depUrl})`);
+                            }
+                        }
+                    }
+                }
+                dependenciesCell = dependencyLinks.length > 0 ? dependencyLinks.join(" ") : "-";
+            } else {
+                dependenciesCell = "-";
+            }
+
+            // Dependants column - find all entries in the same category that depend on this project
+            const dependants = [];
+            for (const catEntry of entries) {
+                // Skip if this is the same entry (same project_id)
+                if (catEntry.version && catEntry.version.project_id === version.project_id) {
+                    continue;
+                }
+                if (catEntry.version && catEntry.version.dependencies && Array.isArray(catEntry.version.dependencies)) {
+                    const hasDependency = catEntry.version.dependencies.some(
+                        (dep) => dep.project_id === version.project_id,
+                    );
+                    if (hasDependency) {
+                        const depProject = projectsMap[catEntry.version.project_id];
+                        if (depProject) {
+                            const depProjectName = depProject.title || depProject.slug || "Unknown";
+                            const depProjectSlug = depProject.slug || depProject.id;
+                            const depUrl = `https://modrinth.com/${categoryPath}/${depProjectSlug}`;
+                            if (depProject.icon_url) {
+                                dependants.push(
+                                    `<a href="${depUrl}"><img alt="${depProjectName}" src="${depProject.icon_url}" height="20px"></a>`,
+                                );
+                            } else {
+                                dependants.push(`[${depProjectName}](${depUrl})`);
+                            }
+                        }
+                    }
+                }
+            }
+            dependantsCell = dependants.length > 0 ? dependants.join(" ") : "-";
+        } else {
+            // File not found on Modrinth
+            const fileName = path.basename(entry.path);
+            nameCell = fileName;
+            authorCell = "Unknown";
+            versionCell = "-";
+            dependenciesCell = "-";
+            dependantsCell = "-";
+        }
+
+        lines.push(`| ${nameCell} | ${authorCell} | ${versionCell} | ${dependenciesCell} | ${dependantsCell} |`);
+    }
+
+    return lines.join("\n") + "\n";
+}
+
+/**
+ * Generate the README.md files for each category
+ * @param {Lockfile} lockfile - The lockfile object
+ * @param {string} workingDir - The working directory
+ * @param {Options | InitOptions} options - The options object
+ */
+export async function generateReadmeFiles(lockfile, workingDir, options = {}) {
+    logm.quietFromOptions(options);
+
+    // Collect unique project IDs and author IDs from version data
+    const projectIds = new Set();
+    const authorIds = new Set();
+
+    for (const [category, entries] of Object.entries(lockfile.dependencies)) {
+        for (const entry of entries) {
+            if (entry.version && entry.version.project_id) {
+                projectIds.add(entry.version.project_id);
+            }
+            if (entry.version && entry.version.author_id) {
+                authorIds.add(entry.version.author_id);
+            }
+        }
+    }
+
+    // Fetch projects and users in parallel
+    logm.newline();
+    logm.info(styleText(["dim"], "Fetching metadata for:"));
+    logm.info(
+        styleText(["dim"], " └─"),
+        styleText(["yellow"], `${projectIds.size} project(s)`),
+        styleText(["dim"], "and"),
+        styleText(["yellow"], `${authorIds.size} user(s)`),
+    );
+    logm.newline();
+
+    const [projects, users] = await Promise.all([getProjects(Array.from(projectIds)), getUsers(Array.from(authorIds))]);
+
+    // Map projects and users to their IDs
+    const projectsMap = {};
+    for (const project of projects) {
+        projectsMap[project.id] = project;
+    }
+
+    const usersMap = {};
+    for (const user of users) {
+        usersMap[user.id] = user;
+    }
+
+    // Generate README for each category
+    for (const [category, entries] of Object.entries(lockfile.dependencies)) {
+        if (entries.length === 0) {
+            continue;
+        }
+
+        const readmeContent = generateCategoryReadme(category, entries, projectsMap, usersMap);
+        const categoryDir = getScanDirectories(workingDir).find((d) => d.name === category);
+
+        if (categoryDir) {
+            const readmePath = path.join(categoryDir.path, config.README_NAME);
+
+            if (options.dryRun) {
+                logm.debug(config.dryRunText(config.README_NAME, readmePath));
+            } else {
+                try {
+                    await fs.writeFile(readmePath, readmeContent, "utf-8");
+                    logm.generated(config.README_NAME, readmePath);
+                } catch (error) {
+                    logm.warn(`Could not write ${config.README_NAME} file to ${readmePath}: ${error.message}`);
+                }
+            }
+        }
+    }
+}

package/src/github_interactions.js

@@ -1,5 +1,5 @@
-import * as config from './config/index.js';
-
+import * as config from "./config/index.js";
+import {logm} from "./logger.js";
 
 /**
  * Fetch a list of the most popular licenses from GitHub
@@ -9,22 +9,19 @@ import * as config from './config/index.js';
 export async function getLicenseList(featured = false) {
     try {
         const url = featured ? config.GITHUB_FEATURED_LICENSES_ENDPOINT : config.GITHUB_LICENSES_ENDPOINT;
-        const response = await fetch(url,
-            {
-                headers: {
-                    'Accept': config.GITHUB_ACCEPT_HEADER,
-                    'User-Agent': config.PACKAGE_USER_AGENT
-                }
-            }
-        );
+        const response = await fetch(url, {
+            headers: {
+                Accept: config.GITHUB_ACCEPT_HEADER,
+                "User-Agent": config.PACKAGE_USER_AGENT,
+            },
+        });
         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 }));
-
+        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
@@ -32,15 +29,15 @@ export async function getLicenseList(featured = false) {
             licenseSpdxIds.push(config.OTHER_OPTION);
             const featuredLicenseList = await getLicenseList(true);
             for (const license of featuredLicenseList) {
-                licenseSpdxIds= licenseSpdxIds.filter( id => id !== license );
+                licenseSpdxIds = licenseSpdxIds.filter((id) => id.value !== license.value);
                 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)
+        logm.warn(`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;
     }
@@ -52,15 +49,15 @@ export async function getLicenseList(featured = false) {
  * @returns {Promise<string> | null} The license text
  */
 export async function getLicenseText(spdxId) {
-    if (spdxId === 'all-rights-reserved') {
+    if (spdxId === "all-rights-reserved") {
         return config.ARR_LICENSE_TEXT;
     }
     try {
         const url = config.GITHUB_LICENSE_ENDPOINT(spdxId.toLowerCase());
         const response = await fetch(url, {
             headers: {
-                'Accept': config.GITHUB_ACCEPT_HEADER,
-                'User-Agent': config.PACKAGE_USER_AGENT
+                Accept: config.GITHUB_ACCEPT_HEADER,
+                "User-Agent": config.PACKAGE_USER_AGENT,
             },
         });
         if (!response.ok) {
@@ -76,10 +73,7 @@ export async function getLicenseText(spdxId) {
         }
         return null;
     } catch (error) {
-        console.warn(`Warning: could not find license text for: ${spdxId}`);
+        logm.warn(`Could not find license text for: ${spdxId}`);
         return null;
     }
 }
-
-
-

package/src/logger.js

@@ -0,0 +1,178 @@
+import {styleText} from "node:util";
+
+class Logger {
+    /**
+     * The styles to apply to the console output.
+     * @type {Object}
+     */
+    styles = {
+        log: null,
+        info: null,
+        debug: ["magenta"],
+        warn: ["yellow"],
+        error: ["red"],
+        generated: ["green"],
+        label: ["inverse", "bold"],
+        labelDebug: ["magenta", "inverse", "bold"],
+        labelWarn: ["yellow", "inverse", "bold"],
+        labelError: ["red", "inverse", "bold"],
+        labelGenerated: ["green", "inverse", "bold"],
+    };
+
+    quietConsole = false;
+    silentConsole = false;
+    lastLogWasNewline = false;
+
+    quiet(silent = false) {
+        this.quietConsole = true;
+        this.silentConsole = silent;
+    }
+
+    quietFromOptions(options) {
+        if (options.silent) {
+            this.quietConsole = true;
+            this.silentConsole = true;
+        } else if (options.quiet) {
+            this.quietConsole = true;
+        }
+    }
+
+    styleArgs(style, args) {
+        if (!style) {
+            return args;
+        }
+        if (args.length === 0) {
+            return "";
+        }
+        return args.map((arg) => (typeof arg === "string" ? styleText(style, arg) : arg));
+    }
+
+    /**
+     * Style the text as a label.
+     * @param {string} text - The text to style.
+     * @param {string[]} style - The style to apply to the text.
+     * @returns {string} The styled text.
+     */
+    label(text, style = this.styles.label) {
+        return styleText(style, String(text).toUpperCase());
+    }
+
+    /**
+     * Log a header.
+     * @param {string} text - The text to log.
+     */
+    header(text) {
+        if (this.quietConsole) {
+            return;
+        }
+        if (!this.lastLogWasNewline) {
+            console.info();
+        }
+        console.info(this.label(text));
+        console.info();
+        this.lastLogWasNewline = true;
+    }
+
+    generated(desc, outputPath) {
+        if (this.quietConsole) {
+            return;
+        }
+        console.log(
+            this.label("Generated", this.styles.labelGenerated),
+            styleText(this.styles.generated, "Wrote"),
+            styleText(this.styles.generated, desc),
+            styleText(this.styles.generated, "to:"),
+            styleText(["dim"], `${outputPath}`),
+        );
+        this.lastLogWasNewline = false;
+    }
+
+    newline() {
+        if (this.quietConsole) {
+            return;
+        }
+        if (this.lastLogWasNewline) {
+            return;
+        }
+        console.info();
+        this.lastLogWasNewline = true;
+    }
+
+    /**
+     * Log a message.
+     * @param {string} message - The message to log.
+     * @param {...any} otherMessages - The other messages to log.
+     */
+    log(message, ...otherMessages) {
+        if (this.quietConsole) {
+            return;
+        }
+        console.log(...this.styleArgs(this.styles.log, [message, ...otherMessages]));
+        this.lastLogWasNewline = false;
+    }
+
+    /**
+     * Log an info message.
+     * @param {string} message - The message to log.
+     * @param {...any} otherMessages - The other messages to log.
+     */
+    info(message, ...otherMessages) {
+        if (this.quietConsole) {
+            return;
+        }
+        console.info(...this.styleArgs(this.styles.info, [message, ...otherMessages]));
+        this.lastLogWasNewline = false;
+    }
+
+    /**
+     * Log a debug message.
+     * @param {string} message - The message to log.
+     * @param {...any} otherMessages - The other messages to log.
+     */
+    debug(message, ...otherMessages) {
+        if (this.silentConsole) {
+            return;
+        }
+        console.debug(
+            this.label("//", this.styles.labelDebug),
+            ...this.styleArgs(this.styles.debug, [message, ...otherMessages]),
+        );
+        this.lastLogWasNewline = false;
+    }
+
+    /**
+     * Log a warning message.
+     * @param {string} message - The message to log.
+     * @param {...any} otherMessages - The other messages to log.
+     */
+    warn(message, ...otherMessages) {
+        if (this.silentConsole) {
+            return;
+        }
+        console.warn(
+            this.label("WARNING", this.styles.labelWarn),
+            ...this.styleArgs(this.styles.warn, [message, ...otherMessages]),
+        );
+        this.lastLogWasNewline = false;
+    }
+
+    /**
+     * Log an error message.
+     * @param {string} message - The message to log.
+     * @param {...any} otherMessages - The other messages to log.
+     */
+    error(message, ...otherMessages) {
+        if (this.silentConsole) {
+            return;
+        }
+        console.error(
+            this.label("ERROR", this.styles.labelError),
+            ...this.styleArgs(this.styles.error, [message, ...otherMessages]),
+        );
+        this.lastLogWasNewline = false;
+    }
+}
+
+const logm = new Logger();
+
+export {logm, styleText};

package/src/modpack-lock.js

@@ -1,8 +1,11 @@
-import { generateLockfile, generateReadmeFiles, generateGitignoreRules } from './generate_lockfile.js';
-import generateJson from './generate_json.js';
-import generateLicense from './generate_license.js';
-import { promptUserForInfo } from './modpack_info.js';
-import { getModpackInfo, getLockfile } from './directory_scanning.js';
+import {generateLockfile} from "./generate_lockfile.js";
+import {generateReadmeFiles} from "./generate_readme.js";
+import {generateGitignoreRules} from "./generate_gitignore.js";
+import generateJson from "./generate_json.js";
+import generateLicense from "./generate_license.js";
+import {logm} from "./logger.js";
+import {promptUserForInfo} from "./modpack_info.js";
+import {getModpackInfo, getLockfile} from "./directory_scanning.js";
 
 /**
  * @typedef {import('./config/types.js').ModpackInfo} ModpackInfo
@@ -18,16 +21,49 @@ import { getModpackInfo, getLockfile } from './directory_scanning.js';
  */
 
 /**
- * Generate the modpack files (lockfile and JSON)
+ * Generate the modpack files (lockfile, JSON, and optionally license, gitignore, and readme)
  * @param {ModpackInfo} modpackInfo - The modpack information
- * @param {string} directory - The directory to generate the files in
+ * @param {string} workingDir - The directory to generate the files in
  * @param {Options | InitOptions } options - The options object
  * @returns {Promise<Lockfile>} The lockfile object
  */
-async function generateModpackFiles(modpackInfo, directory, options = {}) {
-    const lockfile = await generateLockfile(directory, options);
-    await generateJson(modpackInfo, lockfile, directory, options);
+async function generateModpackFiles(modpackInfo, workingDir, options = {}) {
+    logm.quietFromOptions(options);
+
+    const lockfile = await generateLockfile(workingDir, options);
+
+    await generateJson(modpackInfo, lockfile, workingDir, options);
+
+    if (options.licenseFile || options.gitignore || options.readme) {
+        logm.header("Generating Optional Files");
+    }
+
+    // Generate license if requested
+    if (options.licenseFile) {
+        await generateLicense(modpackInfo, workingDir, options);
+    }
+
+    // Generate gitignore if requested
+    if (options.gitignore) {
+        await generateGitignoreRules(lockfile, workingDir, options);
+    }
+
+    // Generate README files if requested
+    if (options.readme) {
+        await generateReadmeFiles(lockfile, workingDir, options);
+    }
+
     return lockfile;
 }
 
-export { generateModpackFiles, generateJson, generateLockfile, generateGitignoreRules, generateReadmeFiles, generateLicense, getModpackInfo, getLockfile, promptUserForInfo };
+export {
+    generateModpackFiles,
+    generateJson,
+    generateLockfile,
+    generateGitignoreRules,
+    generateReadmeFiles,
+    generateLicense,
+    getModpackInfo,
+    getLockfile,
+    promptUserForInfo,
+};