git-ripper 1.5.0 → 1.5.2

package/bin/git-ripper.js

@@ -1,4 +1,4 @@
 #!/usr/bin/env node
-import { initializeCLI } from '../src/index.js';
-
-initializeCLI();
+import { initializeCLI } from '../src/index.js';
+
+initializeCLI();

package/package.json

@@ -1,62 +1,62 @@
-{
-  "name": "git-ripper",
-  "version": "1.5.0",
-  "description": "CLI tool that lets you download specific folders from GitHub repositories without cloning the entire repo.",
-  "main": "src/index.js",
-  "type": "module",
-  "bin": {
-    "git-ripper": "bin/git-ripper.js"
-  },
-  "scripts": {
-    "test": "node --experimental-vm-modules ./node_modules/jest/bin/jest.js",
-    "dev": "node bin/git-ripper.js"
-  },
-  "keywords": [
-    "git",
-    "clone",
-    "github",
-    "subfolder",
-    "repository",
-    "download",
-    "partial-clone",
-    "directory-download",
-    "folder-download",
-    "git-utilities",
-    "github-api",
-    "monorepo-tools",
-    "sparse-checkout"
-  ],
-  "author": "sairajb",
-  "license": "MIT",
-  "dependencies": {
-    "archiver": "^7.0.1",
-    "axios": "^1.6.7",
-    "chalk": "^5.3.0",
-    "cli-progress": "^3.12.0",
-    "commander": "^12.0.0",
-    "p-limit": "^6.2.0",
-    "pretty-bytes": "^6.1.1"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/sairajB/git-ripper.git"
-  },
-  "bugs": {
-    "url": "https://github.com/sairajB/git-ripper/issues"
-  },
-  "homepage": "https://git-ripper.sairajb.tech/",
-  "engines": {
-    "node": ">=16.0.0"
-  },
-  "files": [
-    "bin/",
-    "src/",
-    "LICENSE"
-  ],
-  "publishConfig": {
-    "access": "public"
-  },
-  "devDependencies": {
-    "jest": "^29.7.0"
-  }
-}
+{
+  "name": "git-ripper",
+  "version": "1.5.2",
+  "description": "CLI tool that lets you download specific folders from GitHub repositories without cloning the entire repo.",
+  "main": "src/index.js",
+  "type": "module",
+  "bin": {
+    "git-ripper": "bin/git-ripper.js"
+  },
+  "scripts": {
+    "test": "node --experimental-vm-modules ./node_modules/jest/bin/jest.js",
+    "dev": "node bin/git-ripper.js"
+  },
+  "keywords": [
+    "git",
+    "clone",
+    "github",
+    "subfolder",
+    "repository",
+    "download",
+    "partial-clone",
+    "directory-download",
+    "folder-download",
+    "git-utilities",
+    "github-api",
+    "monorepo-tools",
+    "sparse-checkout"
+  ],
+  "author": "sairajb",
+  "license": "MIT",
+  "dependencies": {
+    "archiver": "^7.0.1",
+    "axios": "^1.6.7",
+    "chalk": "^5.3.0",
+    "cli-progress": "^3.12.0",
+    "commander": "^12.0.0",
+    "p-limit": "^6.2.0",
+    "pretty-bytes": "^6.1.1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sairajB/git-ripper.git"
+  },
+  "bugs": {
+    "url": "https://github.com/sairajB/git-ripper/issues"
+  },
+  "homepage": "https://git-ripper.sairajb.tech/",
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "jest": "^29.7.0"
+  }
+}

package/src/archiver.js

@@ -1,210 +1,210 @@
-import fs from "node:fs";
-import path from "node:path";
-import archiver from "archiver";
-import chalk from "chalk";
-
-/**
- * Validates the output path for an archive file
- * @param {string} outputPath - Path where the archive should be saved
- * @returns {boolean} - True if the path is valid, throws an error otherwise
- * @throws {Error} - If the output path is invalid
- */
-const validateArchivePath = (outputPath) => {
-  // Check if path is provided
-  if (!outputPath) {
-    throw new Error("Output path is required");
-  }
-
-  // Check if the output directory exists or can be created
-  const outputDir = path.dirname(outputPath);
-  try {
-    if (!fs.existsSync(outputDir)) {
-      fs.mkdirSync(outputDir, { recursive: true });
-    }
-
-    // Check if the directory is writable
-    fs.accessSync(outputDir, fs.constants.W_OK);
-
-    // Check if file already exists and is writable
-    if (fs.existsSync(outputPath)) {
-      fs.accessSync(outputPath, fs.constants.W_OK);
-      // File exists and is writable, so we'll overwrite it
-      console.warn(
-        chalk.yellow(
-          `Warning: File ${outputPath} already exists and will be overwritten`
-        )
-      );
-    }
-
-    return true;
-  } catch (error) {
-    if (error.code === "EACCES") {
-      throw new Error(`Permission denied: Cannot write to ${outputPath}`);
-    }
-    throw new Error(`Invalid output path: ${error.message}`);
-  }
-};
-
-/**
- * Creates a ZIP archive from a directory with standard compression
- *
- * @param {string} sourceDir - Source directory to archive
- * @param {string} outputPath - Path where the archive should be saved
- * @returns {Promise<string>} - Path to the created archive
- */
-export const createArchive = (sourceDir, outputPath) => {
-  return new Promise((resolve, reject) => {
-    try {
-      // Fixed compression level of 5 (balanced between speed and size)
-      const compressionLevel = 5;
-
-      // Validate source directory
-      if (!fs.existsSync(sourceDir)) {
-        return reject(
-          new Error(`Source directory does not exist: ${sourceDir}`)
-        );
-      }
-
-      const stats = fs.statSync(sourceDir);
-      if (!stats.isDirectory()) {
-        return reject(
-          new Error(`Source path is not a directory: ${sourceDir}`)
-        );
-      }
-
-      // Validate output path
-      validateArchivePath(outputPath);
-
-      // Create output stream
-      const output = fs.createWriteStream(outputPath);
-
-      // Create ZIP archive with standard compression
-      const archive = archiver("zip", {
-        zlib: { level: compressionLevel },
-      });
-
-      // Listen for archive events
-      output.on("close", () => {
-        const size = archive.pointer();
-        console.log(
-          chalk.green(
-            `Archive created: ${outputPath} (${(size / 1024 / 1024).toFixed(
-              2
-            )} MB)`
-          )
-        );
-        resolve(outputPath);
-      });
-
-      archive.on("error", (err) => {
-        reject(err);
-      });
-
-      archive.on("warning", (err) => {
-        if (err.code === "ENOENT") {
-          console.warn(chalk.yellow(`Warning: ${err.message}`));
-        } else {
-          reject(err);
-        }
-      });
-
-      // Pipe archive data to the output file
-      archive.pipe(output);
-
-      // Add the directory contents to the archive
-      archive.directory(sourceDir, false);
-
-      // Finalize the archive
-      archive.finalize();
-    } catch (error) {
-      reject(error);
-    }
-  });
-};
-
-/**
- * Downloads folder contents and creates a ZIP archive
- *
- * @param {object} repoInfo - Repository information object
- * @param {string} outputDir - Directory where files should be downloaded
- * @param {string} archiveName - Custom name for the archive file (optional)
- * @param {object} [options] - Download options including token
- * @returns {Promise<string>} - Path to the created archive
- */
-export const downloadAndArchive = async (
-  repoInfo,
-  outputDir,
-  archiveName = null,
-  options = {}
-) => {
-  const { downloadFolder } = await import("./downloader.js");
-
-  console.log(
-    chalk.cyan(`Downloading folder and preparing to create ZIP archive...`)
-  );
-
-  // Create a temporary directory for the download
-  const tempDir = path.join(outputDir, `.temp-${Date.now()}`);
-  fs.mkdirSync(tempDir, { recursive: true });
-  try {
-    // Download the folder contents
-    const downloadResult = await downloadFolder(repoInfo, tempDir, options);
-
-    // Check if download failed
-    if (downloadResult && !downloadResult.success) {
-      throw new Error(
-        `Download failed: ${
-          downloadResult.failedFiles || 0
-        } files could not be downloaded`
-      );
-    }
-
-    // Check if there's anything to archive
-    const files = fs
-      .readdirSync(tempDir, { recursive: true })
-      .filter((file) => {
-        const fullPath = path.join(tempDir, file);
-        return fs.statSync(fullPath).isFile();
-      });
-
-    if (files.length === 0) {
-      throw new Error(
-        `No files to archive - download may have failed or repository is empty`
-      );
-    }
-
-    // Determine archive filename
-    let archiveFileName = archiveName;
-    if (!archiveFileName) {
-      const { owner, repo, folderPath } = repoInfo;
-      const folderName = folderPath ? folderPath.split("/").pop() : repo;
-      archiveFileName = `${folderName || repo}-${owner}`;
-    }
-
-    // Add extension if not present
-    if (!archiveFileName.endsWith(`.zip`)) {
-      archiveFileName += `.zip`;
-    }
-
-    const archivePath = path.join(outputDir, archiveFileName);
-
-    // Create the archive
-    console.log(chalk.cyan(`Creating ZIP archive...`));
-    await createArchive(tempDir, archivePath);
-
-    return archivePath;
-  } catch (error) {
-    throw new Error(`Failed to create archive: ${error.message}`);
-  } finally {
-    // Clean up temporary directory
-    try {
-      fs.rmSync(tempDir, { recursive: true, force: true });
-    } catch (err) {
-      console.warn(
-        chalk.yellow(
-          `Warning: Failed to clean up temporary directory: ${err.message}`
-        )
-      );
-    }
-  }
-};
+import fs from "node:fs";
+import path from "node:path";
+import archiver from "archiver";
+import chalk from "chalk";
+
+/**
+ * Validates the output path for an archive file
+ * @param {string} outputPath - Path where the archive should be saved
+ * @returns {boolean} - True if the path is valid, throws an error otherwise
+ * @throws {Error} - If the output path is invalid
+ */
+const validateArchivePath = (outputPath) => {
+  // Check if path is provided
+  if (!outputPath) {
+    throw new Error("Output path is required");
+  }
+
+  // Check if the output directory exists or can be created
+  const outputDir = path.dirname(outputPath);
+  try {
+    if (!fs.existsSync(outputDir)) {
+      fs.mkdirSync(outputDir, { recursive: true });
+    }
+
+    // Check if the directory is writable
+    fs.accessSync(outputDir, fs.constants.W_OK);
+
+    // Check if file already exists and is writable
+    if (fs.existsSync(outputPath)) {
+      fs.accessSync(outputPath, fs.constants.W_OK);
+      // File exists and is writable, so we'll overwrite it
+      console.warn(
+        chalk.yellow(
+          `Warning: File ${outputPath} already exists and will be overwritten`
+        )
+      );
+    }
+
+    return true;
+  } catch (error) {
+    if (error.code === "EACCES") {
+      throw new Error(`Permission denied: Cannot write to ${outputPath}`);
+    }
+    throw new Error(`Invalid output path: ${error.message}`);
+  }
+};
+
+/**
+ * Creates a ZIP archive from a directory with standard compression
+ *
+ * @param {string} sourceDir - Source directory to archive
+ * @param {string} outputPath - Path where the archive should be saved
+ * @returns {Promise<string>} - Path to the created archive
+ */
+export const createArchive = (sourceDir, outputPath) => {
+  return new Promise((resolve, reject) => {
+    try {
+      // Fixed compression level of 5 (balanced between speed and size)
+      const compressionLevel = 5;
+
+      // Validate source directory
+      if (!fs.existsSync(sourceDir)) {
+        return reject(
+          new Error(`Source directory does not exist: ${sourceDir}`)
+        );
+      }
+
+      const stats = fs.statSync(sourceDir);
+      if (!stats.isDirectory()) {
+        return reject(
+          new Error(`Source path is not a directory: ${sourceDir}`)
+        );
+      }
+
+      // Validate output path
+      validateArchivePath(outputPath);
+
+      // Create output stream
+      const output = fs.createWriteStream(outputPath);
+
+      // Create ZIP archive with standard compression
+      const archive = archiver("zip", {
+        zlib: { level: compressionLevel },
+      });
+
+      // Listen for archive events
+      output.on("close", () => {
+        const size = archive.pointer();
+        console.log(
+          chalk.green(
+            `Archive created: ${outputPath} (${(size / 1024 / 1024).toFixed(
+              2
+            )} MB)`
+          )
+        );
+        resolve(outputPath);
+      });
+
+      archive.on("error", (err) => {
+        reject(err);
+      });
+
+      archive.on("warning", (err) => {
+        if (err.code === "ENOENT") {
+          console.warn(chalk.yellow(`Warning: ${err.message}`));
+        } else {
+          reject(err);
+        }
+      });
+
+      // Pipe archive data to the output file
+      archive.pipe(output);
+
+      // Add the directory contents to the archive
+      archive.directory(sourceDir, false);
+
+      // Finalize the archive
+      archive.finalize();
+    } catch (error) {
+      reject(error);
+    }
+  });
+};
+
+/**
+ * Downloads folder contents and creates a ZIP archive
+ *
+ * @param {object} repoInfo - Repository information object
+ * @param {string} outputDir - Directory where files should be downloaded
+ * @param {string} archiveName - Custom name for the archive file (optional)
+ * @param {object} [options] - Download options including token
+ * @returns {Promise<string>} - Path to the created archive
+ */
+export const downloadAndArchive = async (
+  repoInfo,
+  outputDir,
+  archiveName = null,
+  options = {}
+) => {
+  const { downloadFolder } = await import("./downloader.js");
+
+  console.log(
+    chalk.cyan(`Downloading folder and preparing to create ZIP archive...`)
+  );
+
+  // Create a temporary directory for the download
+  const tempDir = path.join(outputDir, `.temp-${Date.now()}`);
+  fs.mkdirSync(tempDir, { recursive: true });
+  try {
+    // Download the folder contents
+    const downloadResult = await downloadFolder(repoInfo, tempDir, options);
+
+    // Check if download failed
+    if (downloadResult && !downloadResult.success) {
+      throw new Error(
+        `Download failed: ${
+          downloadResult.failedFiles || 0
+        } files could not be downloaded`
+      );
+    }
+
+    // Check if there's anything to archive
+    const files = fs
+      .readdirSync(tempDir, { recursive: true })
+      .filter((file) => {
+        const fullPath = path.join(tempDir, file);
+        return fs.statSync(fullPath).isFile();
+      });
+
+    if (files.length === 0) {
+      throw new Error(
+        `No files to archive - download may have failed or repository is empty`
+      );
+    }
+
+    // Determine archive filename
+    let archiveFileName = archiveName;
+    if (!archiveFileName) {
+      const { owner, repo, folderPath } = repoInfo;
+      const folderName = folderPath ? folderPath.split("/").pop() : repo;
+      archiveFileName = `${folderName || repo}-${owner}`;
+    }
+
+    // Add extension if not present
+    if (!archiveFileName.endsWith(`.zip`)) {
+      archiveFileName += `.zip`;
+    }
+
+    const archivePath = path.join(outputDir, archiveFileName);
+
+    // Create the archive
+    console.log(chalk.cyan(`Creating ZIP archive...`));
+    await createArchive(tempDir, archivePath);
+
+    return archivePath;
+  } catch (error) {
+    throw new Error(`Failed to create archive: ${error.message}`);
+  } finally {
+    // Clean up temporary directory
+    try {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    } catch (err) {
+      console.warn(
+        chalk.yellow(
+          `Warning: Failed to clean up temporary directory: ${err.message}`
+        )
+      );
+    }
+  }
+};