modpack-lock 0.1.1 → 0.1.3

package/README.md

@@ -47,6 +47,7 @@ Flags:
 - `--quiet` or `-q`: Print only errors and warnings
 - `--silent` or `-s`: Print nothing
 - `--gitignore` or `-g`: Print the rules to add to your `.gitignore` file
+- `--readme` or `-r`: Generate README.md files with lists of all content for each category inside their directories
 
 The script will:
 
@@ -79,8 +80,15 @@ The `modpack.lock` file has the following structure:
 
 ```json
 {
-  "version": "1.0.0",
+  "version": "1.0.1",
   "generated": "2026-01-06T03:00:00.000Z",
+  "total": 7,
+  "counts": {
+    "mods": 1,
+    "resourcepacks": 3,
+    "datapacks": 1,
+    "shaderpacks": 2
+  },
   "dependencies": {
     "mods": [
       {

package/index.js

@@ -4,10 +4,13 @@ import fs from 'fs/promises';
 import crypto from 'crypto';
 import path from 'path';
 
-const LOCKFILE_VERSION = '1.0.0';
+const LOCKFILE_VERSION = '1.0.1';
 const MODPACK_LOCKFILE_NAME = 'modpack.lock';
 const MODRINTH_API_BASE = 'https://api.modrinth.com/v2';
 const MODRINTH_VERSION_FILES_ENDPOINT = `${MODRINTH_API_BASE}/version_files`;
+const MODRINTH_PROJECTS_ENDPOINT = `${MODRINTH_API_BASE}/projects`;
+const MODRINTH_USERS_ENDPOINT = `${MODRINTH_API_BASE}/users`;
+const BATCH_SIZE = 100; // Safe limit for URL length
 
 // Get the workspace root from the current working directory
 const WORKSPACE_ROOT = process.cwd();
@@ -22,6 +25,7 @@ function parseArgs() {
     quiet: args.includes('--quiet') || args.includes('-q'),
     silent: args.includes('--silent') || args.includes('-s'),
     gitignore: args.includes('--gitignore') || args.includes('-g'),
+    readme: args.includes('--readme') || args.includes('-r'),
   };
 }
 
@@ -143,6 +147,81 @@ async function getVersionsFromHashes(hashes) {
   }
 }
 
+/**
+ * Split an array into chunks of specified size
+ */
+function chunkArray(array, size) {
+  const chunks = [];
+  for (let i = 0; i < array.length; i += size) {
+    chunks.push(array.slice(i, i + size));
+  }
+  return chunks;
+}
+
+/**
+ * Fetch multiple projects by their IDs (batched to avoid URL length limits)
+ */
+async function getProjects(projectIds) {
+  if (projectIds.length === 0) {
+    return [];
+  }
+
+  const chunks = chunkArray(projectIds, BATCH_SIZE);
+  const results = [];
+
+  for (const chunk of chunks) {
+    try {
+      const url = `${MODRINTH_PROJECTS_ENDPOINT}?ids=${encodeURIComponent(JSON.stringify(chunk))}`;
+      const response = await fetch(url);
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Modrinth API error (${response.status}): ${errorText}`);
+      }
+
+      const data = await response.json();
+      results.push(...data);
+    } catch (error) {
+      console.error(`Error fetching projects: ${error.message}`);
+      throw error;
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Fetch multiple users by their IDs (batched to avoid URL length limits)
+ */
+async function getUsers(userIds) {
+  if (userIds.length === 0) {
+    return [];
+  }
+
+  const chunks = chunkArray(userIds, BATCH_SIZE);
+  const results = [];
+
+  for (const chunk of chunks) {
+    try {
+      const url = `${MODRINTH_USERS_ENDPOINT}?ids=${encodeURIComponent(JSON.stringify(chunk))}`;
+      const response = await fetch(url);
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Modrinth API error (${response.status}): ${errorText}`);
+      }
+
+      const data = await response.json();
+      results.push(...data);
+    } catch (error) {
+      console.error(`Error fetching users: ${error.message}`);
+      throw error;
+    }
+  }
+
+  return results;
+}
+
 
 /**
  * Create empty lockfile structure
@@ -151,6 +230,8 @@ function createEmptyLockfile() {
   return {
     version: LOCKFILE_VERSION,
     generated: new Date().toISOString(),
+    total: 0,
+    counts: {},
     dependencies: {},
   };
 }
@@ -179,6 +260,14 @@ function createLockfile(fileEntries, versionData) {
     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;
+  }
+
+  // Calculate total count
+  lockfile.total = fileEntries.length;
+
   return lockfile;
 }
 
@@ -191,6 +280,79 @@ async function writeLockfile(lockfile, outputPath, log) {
   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 = {
+    mods: 'mod',
+    resourcepacks: 'resourcepack',
+    shaderpacks: 'shader',
+    datapacks: 'datapack',
+  };
+  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
  */
@@ -297,6 +459,72 @@ async function main() {
     log('\n=== .gitignore Rules ===');
     log(generateGitignoreRules(lockfile));
   }
+
+  // Generate README files if requested
+  if (config.readme) {
+    log('\nGenerating README files...');
+
+    // 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
+    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)),
+    ]);
+
+    // Create maps for easy lookup
+    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; // Skip empty categories
+      }
+
+      const readmeContent = generateCategoryReadme(category, entries, projectsMap, usersMap);
+      const categoryDir = DIRECTORIES_TO_SCAN.find(d => d.name === category);
+
+      if (categoryDir) {
+        const readmePath = path.join(categoryDir.path, 'README.md');
+
+        if (config.dryRun) {
+          log(`[DRY RUN] Would write README to: ${readmePath}`);
+        } else {
+          try {
+            await fs.writeFile(readmePath, readmeContent, 'utf-8');
+            log(`Generated README: ${readmePath}`);
+          } catch (error) {
+            console.warn(`Warning: Could not write README to ${readmePath}: ${error.message}`);
+          }
+        }
+      }
+    }
+
+    log('README generation complete.');
+  }
 }
 
 main().catch(error => {

package/package.json

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