modpack-lock 0.2.0 → 0.3.0

package/src/generate_json.js

@@ -0,0 +1,105 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { getProjects } from './modrinth_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').Lockfile} Lockfile
+ */
+
+/**
+ * Create a JSON object from the modpack information and dependencies
+ */
+function createModpackJson(modpackInfo, dependencies) {
+    return {
+        ...modpackInfo,
+        dependencies: dependencies,
+    };
+}
+
+/**
+ * Write modpack.json to disk
+ */
+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)}`);
+}
+
+/**
+ * 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 {Options} options - The options object
+ * @returns {Promise<Lockfile>} The JSON file's object
+ */
+export default async function generateJson(modpackInfo, lockfile, outputDir, options = {}) {
+    // Validate modpack info
+    for (const field of config.MODPACK_INFO_REQUIRED_FIELDS) {
+        if (!modpackInfo[field]) {
+            throw new Error(`Modpack info is missing required field: ${field}`);
+        }
+    }
+
+    const projectIds = {};
+    const packDependencies = {};
+    for (const category of config.DEPENDENCY_CATEGORIES) {
+        projectIds[category] = new Set();
+        packDependencies[category] = [];
+    }
+
+    // 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);
+                }
+            }
+        }
+        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;
+        }
+
+        // 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);
+                }
+            }
+            //packDependencies[category].push(...packDependencies[category].map(item => item.path));
+        }
+    }
+
+    // Create modpack JSON object
+    const jsonObject = createModpackJson(modpackInfo, packDependencies);
+
+    // 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)}`);
+    } else {
+        await writeJson(jsonObject, outputDir);
+    }
+
+    return jsonObject;
+}
+
+
+

package/src/generate_lockfile.js

@@ -0,0 +1,327 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { getVersionsFromHashes, getProjects, getUsers } from './modrinth_interactions.js';
+import { getScanDirectories, scanDirectory } from './directory_scanning.js';
+import * as config from './config/index.js';
+
+/**
+ * @typedef {import('./config/types.js').Options} Options
+ * @typedef {import('./config/types.js').Lockfile} Lockfile
+ */
+
+/**
+ * Create empty lockfile structure
+ */
+function createEmptyLockfile() {
+    return {
+        version: config.LOCKFILE_VERSION,
+        generated: new Date().toISOString(),
+        total: 0,
+        counts: {},
+        dependencies: {},
+    };
+}
+
+/**
+ * Create lockfile structure from file info and version data
+ */
+function createLockfile(fileEntries, versionData) {
+    const lockfile = createEmptyLockfile();
+
+    // Organize by category
+    for (const fileInfo of fileEntries) {
+        const version = versionData[fileInfo.hash];
+
+        lockfile.dependencies[fileInfo.category] ||= [];
+
+        const entry = {
+            path: fileInfo.path,
+            version: version || null,
+        };
+
+        if (!version) {
+            console.warn(`Warning: File ${fileInfo.path} not found on Modrinth`);
+        }
+
+        lockfile.dependencies[fileInfo.category].push(entry);
+    }
+
+    // Calculate counts for each category
+    for (const [category, entries] of Object.entries(lockfile.dependencies)) {
+        lockfile.counts[category] = entries.length;
+    }
+
+    lockfile.total = fileEntries.length;
+
+    return lockfile;
+}
+
+/**
+ * Write lockfile to disk
+ */
+async function writeLockfile(lockfile, outputPath) {
+    const content = JSON.stringify(lockfile, null, 2);
+    await fs.writeFile(outputPath, content, 'utf-8');
+    console.log(`Lockfile written to: ${outputPath}`);
+}
+
+/**
+ * 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 |', '|-|-|-|'];
+
+    // Map category to Modrinth URL path segment
+    const categoryPathMap = {};
+    for (const category of config.DEPENDENCY_CATEGORIES) {
+        categoryPathMap[category] = category === 'shaderpacks' ? 'shader' : category.toLowerCase().slice(0, -1);
+    }
+    const categoryPath = categoryPathMap[category] || 'project';
+
+    for (const entry of entries) {
+        const version = entry.version;
+        let nameCell = '';
+        let authorCell = '';
+        let versionCell = '';
+
+        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';
+        } else {
+            // File not found on Modrinth
+            const fileName = path.basename(entry.path);
+            nameCell = fileName;
+            authorCell = 'Unknown';
+            versionCell = '-';
+        }
+
+        lines.push(`| ${nameCell} | ${authorCell} | ${versionCell} |`);
+    }
+
+    return lines.join('\n') + '\n';
+}
+
+/**
+ * Generate .gitignore rules for files not hosted on Modrinth
+ * @param {Lockfile} lockfile - The lockfile object
+ * @returns {string} The .gitignore rules
+ */
+export function generateGitignoreRules(lockfile) {
+    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('\n## Exceptions');
+
+    // 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(...exceptions);
+    } else {
+        rules.push('# No exceptions needed - all files are hosted on Modrinth');
+    }
+
+    return rules.join('\n');
+}
+
+/**
+ * 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
+ */
+export async function generateReadmeFiles(lockfile, workingDir, 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
+    console.log(`Fetching data for ${projectIds.size} project(s) and ${authorIds.size} user(s)...`);
+
+    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, 'README.md');
+
+            if (options.dryRun) {
+                console.log(`[DRY RUN] Would write README to: ${readmePath}`);
+            } else {
+                try {
+                    await fs.writeFile(readmePath, readmeContent, 'utf-8');
+                    console.log(`Generated README: ${readmePath}`);
+                } catch (error) {
+                    console.warn(`Warning: Could not write README to ${readmePath}: ${error.message}`);
+                }
+            }
+        }
+    }
+
+    console.log('README generation complete.');
+}
+
+/**
+ * Generate the lockfile
+ * @param {string} workingDir - The working directory
+ * @param {Options} options - The options object
+ * @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
+    const allFileEntries = [];
+    for (const dirInfo of getScanDirectories(workingDir)) {
+        console.log(`Scanning ${dirInfo.name}...`);
+        const fileEntries = await scanDirectory(dirInfo, workingDir);
+        console.log(`  Found ${fileEntries.length} file(s)`);
+        allFileEntries.push(...fileEntries);
+    }
+
+    // Sort file entries
+    allFileEntries.sort((a, b) => {
+        if (a.category !== b.category) {
+            return a.category.localeCompare(b.category, 'en', { sensitivity: 'base' });
+        }
+        return a.path.localeCompare(b.path, 'en', { numeric: true, sensitivity: 'base' });
+    });
+
+    if (allFileEntries.length === 0) {
+        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}`);
+        } else {
+            await writeLockfile(createEmptyLockfile(), outputPath);
+        }
+        return;
+    }
+
+    console.log(`\nTotal files found: ${allFileEntries.length}`);
+    console.log('\nQuerying Modrinth API...');
+
+    // Extract all hashes
+    const hashes = allFileEntries.map(info => info.hash);
+
+    // Query Modrinth API
+    const versionData = await getVersionsFromHashes(hashes);
+
+    console.log(`\nFound version information for ${Object.keys(versionData).length} out of ${hashes.length} files`);
+
+    // Create lockfile
+    const lockfile = createLockfile(allFileEntries, versionData);
+
+    // Write lockfile
+    const outputPath = path.join(workingDir, config.MODPACK_LOCKFILE_NAME);
+    if (options.dryRun) {
+        console.log(`[DRY RUN] Would write lockfile to: ${outputPath}`);
+    } else {
+        await writeLockfile(lockfile, outputPath);
+    }
+
+    // Summary
+    console.log('\n=== Summary ===');
+    for (const [category, entries] of Object.entries(lockfile.dependencies)) {
+        const withVersion = entries.filter(e => e.version !== null).length;
+        const withoutVersion = entries.length - withVersion;
+        console.log(`${category}: ${entries.length} file(s) (${withVersion} found on Modrinth, ${withoutVersion} unknown)`);
+    }
+
+    // Generate .gitignore rules
+    if (options.gitignore) {
+        console.log('\n=== .gitignore Rules ===\n');
+        console.log(generateGitignoreRules(lockfile));
+        console.log();
+    }
+
+    // Generate README files
+    if (options.readme) {
+        console.log('\nGenerating README files...');
+        await generateReadmeFiles(lockfile, workingDir, options = {});
+    }
+
+    return lockfile;
+}

package/src/modpack-lock.js

@@ -1,32 +1,31 @@
-#!/usr/bin/env NODE_OPTIONS=--no-warnings node
+import { generateLockfile, generateReadmeFiles, generateGitignoreRules } from './generate_lockfile.js';
+import generateJson from './generate_json.js';
+import promptUserForInfo from './modpack_info.js';
+import { getModpackInfo, getLockfile } from './directory_scanning.js';
 
-import { Command } from 'commander';
-import generateLockfile from './generate-lockfile.js';
+/**
+ * @typedef {import('./config/types.js').ModpackInfo} ModpackInfo
+ * @typedef {import('./config/types.js').Options} Options
+ * @typedef {import('./config/types.js').Lockfile} Lockfile
+ */
 
-import pkg from '../package.json' with { type: 'json' };
-const modpackLock = new Command('modpack-lock');
+/**
+ * @license MIT
+ * @author nickesc
+ * @module modpack-lock
+ */
 
-modpackLock
-  .name(pkg.name)
-  .description(pkg.description)
-  .summary("Create a modpack lockfile")
-  .optionsGroup("Options:")
-  .option('-d, --dry-run', 'Dry-run mode - no files will be written')
-  .option('-g, --gitignore', 'Print .gitignore rules for files not hosted on Modrinth')
-  .option('-r, --readme', 'Generate README.md files for each category')
-  .option('-p, --path <path>', 'Path to the modpack directory')
-  .optionsGroup("LOGGING")
-  .option('-q, --quiet', 'Quiet mode - only show errors and warnings')
-  .option('-s, --silent', 'Silent mode - no output')
-  .optionsGroup("INFORMATION")
-  .helpOption("--help", `display help for ${pkg.name}`)
-  .version(pkg.version)
-  .action((options) => {
-    generateLockfile({ ...options, path: options.path || process.cwd() }).catch(error => {
-      console.error('Error:', error);
-      process.exit(1);
-    });
-  });
-
-modpackLock.parse()
+/**
+ * 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
+ * @returns {Promise<Lockfile>} The lockfile object
+ */
+async function generateModpackFiles(modpackInfo, directory, options = {}) {
+    const lockfile = await generateLockfile(directory, options);
+    await generateJson(modpackInfo, lockfile, directory, options);
+    return lockfile;
+}
 
+export { generateModpackFiles, generateJson, generateLockfile, generateGitignoreRules, generateReadmeFiles, getModpackInfo, getLockfile, promptUserForInfo };

package/src/modpack_info.js

@@ -0,0 +1,134 @@
+import prompts from 'prompts';
+import slugify from 'slugify';
+import * as config from './config/index.js';
+
+/**
+ * Validate that a value is not empty
+ */
+function validateNotEmpty(value, field) {
+    if (value.trim().length === 0) {
+        return `${field} cannot be empty`;
+    }
+    return true;
+}
+
+/**
+ * @typedef {import('./config/types.js').ModpackInfo} ModpackInfo
+ * @typedef {import('./config/types.js').Options} Options
+ * @typedef {import('./config/types.js').Lockfile} Lockfile
+ */
+
+/**
+ * Get user input for modpack information
+ * @param {ModpackInfo} defaults - The initial/default modpack information
+ * @returns {Promise<ModpackInfo>} The modpack information from the user
+ */
+export default async function promptUserForInfo(defaults = {}) {
+    let answers = await prompts([
+        {
+            type: 'text',
+            name: 'name',
+            message: 'Modpack name',
+            initial: defaults.name,
+            validate: (value) => {
+                return validateNotEmpty(value, 'Name');
+            },
+        },
+        {
+            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 || defaults.name, config.SLUGIFY_OPTIONS),
+            validate: (value) => {
+                return validateNotEmpty(value, 'ID');
+            },
+        },
+        {
+            type: 'text',
+            name: 'description',
+            message: 'Modpack description',
+            initial: defaults.description || undefined,
+        },
+        {
+            type: 'text',
+            name: 'author',
+            message: 'Modpack author',
+            initial: defaults.author || undefined,
+            validate: (value) => {
+                return validateNotEmpty(value, 'Author');
+            },
+        },
+        {
+            type: 'text',
+            name: 'projectUrl',
+            message: 'Modpack URL',
+            initial: defaults.projectUrl || undefined,
+        },
+        {
+            type: 'text',
+            name: 'sourceUrl',
+            message: 'Modpack source code URL',
+            initial: defaults.sourceUrl || undefined,
+        },
+        {
+            type: 'text',
+            name: 'license',
+            message: 'Modpack license',
+            initial: defaults.license || undefined,
+        },
+        {
+            type: 'autocomplete',
+            name: 'modloader',
+            message: 'Modpack modloader',
+            initial: defaults.modloader || undefined,
+            choices: [
+                { title: 'fabric' },
+                { title: 'forge' },
+                { title: 'quilt' },
+                { title: 'neoforge' },
+                { title: 'sponge' },
+                { title: 'paper' },
+                { title: 'velocity' },
+                { title: 'bungeecord' },
+                { title: 'waterfall' },
+                { title: 'travertia' },
+                { title: 'nukkit' },
+                { title: 'pufferfish' },
+                { title: 'purpur' },
+            ],
+            validate: (value) => {
+                return validateNotEmpty(value, 'Modloader');
+            },
+        },
+        {
+            type: 'text',
+            name: 'targetModloaderVersion',
+            message: 'Target modloader version',
+            initial: defaults.targetModloaderVersion || undefined,
+        },
+        {
+            type: 'text',
+            name: 'targetMinecraftVersion',
+            message: 'Target Minecraft version',
+            initial: defaults.targetMinecraftVersion || undefined,
+            validate: (value) => {
+                return validateNotEmpty(value, 'Minecraft Version');
+            },
+        }
+    ]);
+    if (Object.keys(answers).length < 11) {
+        console.warn('Modpack initialization was interrupted');
+        process.exit(1);
+    }
+    return answers;
+}