git-ripper 1.4.0 → 1.4.2

package/README.md

@@ -5,8 +5,12 @@
 [![NPM version](https://img.shields.io/npm/v/git-ripper.svg)](https://www.npmjs.com/package/git-ripper)
 [![License](https://img.shields.io/npm/l/git-ripper.svg)](https://github.com/sairajB/git-ripper/blob/main/LICENSE)
 [![Downloads](https://img.shields.io/npm/dt/git-ripper.svg?style=flat&label=total%20downloads)](https://www.npmjs.com/package/git-ripper)
+[![Weekly Downloads](https://img.shields.io/npm/dw/git-ripper.svg)](https://www.npmjs.com/package/git-ripper)
+[![Bundle Size](https://img.shields.io/bundlephobia/min/git-ripper.svg)](https://bundlephobia.com/package/git-ripper)
 [![GitHub issues](https://img.shields.io/github/issues/sairajB/git-ripper.svg)](https://github.com/sairajB/git-ripper/issues)
 [![GitHub stars](https://img.shields.io/github/stars/sairajB/git-ripper.svg)](https://github.com/sairajB/git-ripper/stargazers)
+[![GitHub forks](https://img.shields.io/github/forks/sairajB/git-ripper.svg)](https://github.com/sairajB/git-ripper/network)
+[![Maintenance](https://img.shields.io/maintenance/yes/2025.svg)](https://github.com/sairajB/git-ripper/commits/master)
 
 **Download specific folders from GitHub repositories without cloning the entire codebase**
 
@@ -25,19 +29,34 @@
 
 Have you ever needed just a single component from a massive repository? Or wanted to reference a specific configuration directory without downloading gigabytes of code? Git-ripper solves this problem by letting you extract and download only the folders you need, saving bandwidth, time, and disk space.
 
+## Project Stats
+
+Git-ripper has grown to become a trusted tool in the developer ecosystem:
+
+- **Total Downloads**: Thousands of developers worldwide have downloaded Git-ripper to optimize their workflow and save time when working with large repositories.
+- **Weekly Active Users**: Our weekly download statistics show consistent adoption and usage among developers, indicating the tool's reliability and usefulness.
+- **Minimal Bundle Size**: Git-ripper is designed to be lightweight and efficient, with a minimal bundle size that ensures quick installation and minimal impact on your system resources.
+- **Active Maintenance**: The project is actively maintained with regular updates and improvements, ensuring compatibility with the latest GitHub API changes and addressing user feedback.
+- **Community Support**: With growing stars and forks on GitHub, Git-ripper has built a supportive community of users who contribute to its ongoing development and share their success stories.
+- **Enterprise Adoption**: Used by teams in various organizations, from startups to large enterprises, Git-ripper helps development teams streamline their workflows when working with modular components from large codebases.
+
 ## Features
 
 - **Selective Downloads**: Fetch specific folders instead of entire repositories
 - **Directory Structure**: Preserves complete folder structure
 - **Custom Output**: Specify your preferred output directory
 - **Branch Support**: Works with any branch, not just the default one
-- **Archive Export**: Create ZIP or TAR archives of downloaded content
+- **Archive Export**: Create ZIP archives of downloaded content
 - **Simple Interface**: Clean, intuitive command-line experience
 - **Lightweight**: Minimal dependencies and fast execution
 - **No Authentication**: Works with public repositories without requiring credentials
 
 ## Installation
 
+### Requirements
+
+Git-ripper requires Node.js >=16.0.0 due to its use of modern JavaScript features and built-in Node.js modules.
+
 ### Global Installation (Recommended)
 
 ```bash
@@ -74,22 +93,20 @@ git-ripper https://github.com/username/repository/tree/branch/folder -o ./my-out
 git-ripper https://github.com/username/repository/tree/branch/folder --zip
 ```
 
-### Creating TAR Archive with Custom Name
+### Creating ZIP Archive with Custom Name
 
 ```bash
-git-ripper https://github.com/username/repository/tree/branch/folder --tar="my-archive.tar"
+git-ripper https://github.com/username/repository/tree/branch/folder --zip="my-archive.zip"
 ```
 
 ### Command Line Options
 
-| Option | Description | Default |
-|--------|-------------|---------|
-| `-o, --output <directory>` | Specify output directory | Current directory |
-| `--zip [filename]` | Create ZIP archive of downloaded content | - |
-| `--tar [filename]` | Create TAR archive of downloaded content | - |
-| `--compression-level <level>` | Set compression level (1-9) | 6 |
-| `-V, --version` | Show version number | - |
-| `-h, --help` | Show help | - |
+| Option                     | Description                              | Default           |
+| -------------------------- | ---------------------------------------- | ----------------- |
+| `-o, --output <directory>` | Specify output directory                 | Current directory |
+| `--zip [filename]`         | Create ZIP archive of downloaded content | -                 |
+| `-V, --version`            | Show version number                      | -                 |
+| `-h, --help`               | Show help                                | -                 |
 
 ## Examples
 
@@ -127,8 +144,8 @@ git-ripper https://github.com/tailwindlabs/tailwindcss/tree/master/src/component
 # Download React DOM package and create a ZIP archive
 git-ripper https://github.com/facebook/react/tree/main/packages/react-dom --zip
 
-# Extract VS Code build configuration with maximum compression
-git-ripper https://github.com/microsoft/vscode/tree/main/build --tar --compression-level=9
+# Extract VS Code build configuration with custom archive name
+git-ripper https://github.com/microsoft/vscode/tree/main/build --zip="vscode-build.zip"
 ```
 
 ## How It Works
@@ -184,16 +201,6 @@ Contributions make the open-source community an amazing place to learn, inspire,
 
 See the [open issues](https://github.com/sairajB/git-ripper/issues) for a list of proposed features and known issues.
 
-## Roadmap
-
-- [x] Add archive export options (ZIP/TAR)
-- [ ] Add GitHub token authentication
-- [ ] Support for GitLab and Bitbucket repositories
-- [ ] Download from specific commits or tags
-- [ ] Dry run mode
-- [ ] File filtering options
-- [ ] CLI interactive mode
-
 ## License
 
 This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

package/package.json

@@ -1,60 +1,62 @@
 {
-    "name": "git-ripper",
-    "version": "1.4.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": "echo \"Error: no test specified\" && exit 1",
-        "dev": "node bin/git-ripper.js",
-        "lint": "eslint ."
-    },
-    "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": "^6.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://github.com/sairajB/git-ripper",
-    "engines": {
-        "node": ">=14.0.0"
-    },
-    "files": [
-        "bin/",
-        "src/",
-        "LICENSE"
-    ],
-    "publishConfig": {
-        "access": "public"
-    }
+  "name": "git-ripper",
+  "version": "1.4.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": "echo \"Error: no test specified\" && exit 1",
+    "dev": "node bin/git-ripper.js",
+    "lint": "eslint ."
+  },
+  "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": {
+    "ansi-styles": "^6.2.1",
+    "archiver": "^6.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",
+    "supports-color": "^9.3.1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sairajB/git-ripper.git"
+  },
+  "bugs": {
+    "url": "https://github.com/sairajB/git-ripper/issues"
+  },
+  "homepage": "https://github.com/sairajB/git-ripper",
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
 }

package/src/archiver.js

@@ -1,7 +1,7 @@
-import fs from 'fs';
-import path from 'path';
-import archiver from 'archiver';
-import chalk from 'chalk';
+import fs from "fs";
+import path from "path";
+import archiver from "archiver";
+import chalk from "chalk";
 
 /**
  * Validates the output path for an archive file
@@ -12,29 +12,33 @@ import chalk from 'chalk';
 const validateArchivePath = (outputPath) => {
   // Check if path is provided
   if (!outputPath) {
-    throw new Error('Output path is required');
+    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`));
+      console.warn(
+        chalk.yellow(
+          `Warning: File ${outputPath} already exists and will be overwritten`
+        )
+      );
     }
-    
+
     return true;
   } catch (error) {
-    if (error.code === 'EACCES') {
+    if (error.code === "EACCES") {
       throw new Error(`Permission denied: Cannot write to ${outputPath}`);
     }
     throw new Error(`Invalid output path: ${error.message}`);
@@ -42,86 +46,74 @@ const validateArchivePath = (outputPath) => {
 };
 
 /**
- * Creates an archive (zip or tar) from a directory
- * 
+ * 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
- * @param {object} options - Archive options
- * @param {string} options.format - Archive format ('zip' or 'tar')
- * @param {number} options.compressionLevel - Compression level (0-9, default: 6)
  * @returns {Promise<string>} - Path to the created archive
  */
-export const createArchive = (sourceDir, outputPath, options = {}) => {
+export const createArchive = (sourceDir, outputPath) => {
   return new Promise((resolve, reject) => {
     try {
-      const { format = 'zip', compressionLevel = 6 } = options;
-      
+      // 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}`));
+        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}`));
+        return reject(
+          new Error(`Source path is not a directory: ${sourceDir}`)
+        );
       }
-      
+
       // Validate output path
       validateArchivePath(outputPath);
-      
-      // Ensure the output directory exists
-      const outputDir = path.dirname(outputPath);
-      if (!fs.existsSync(outputDir)) {
-        fs.mkdirSync(outputDir, { recursive: true });
-      }
-      
+
       // Create output stream
       const output = fs.createWriteStream(outputPath);
-      let archive;
-      
-      // Create the appropriate archive type
-      if (format === 'zip') {
-        archive = archiver('zip', {
-          zlib: { level: compressionLevel }
-        });
-      } else if (format === 'tar') {
-        archive = archiver('tar');
-        // Use gzip compression for tar if compressionLevel > 0
-        if (compressionLevel > 0) {
-          archive = archiver('tar', {
-            gzip: true,
-            gzipOptions: { level: compressionLevel }
-          });
-        }
-      } else {
-        return reject(new Error(`Unsupported archive format: ${format}`));
-      }
-      
+
+      // Create ZIP archive with standard compression
+      const archive = archiver("zip", {
+        zlib: { level: compressionLevel },
+      });
+
       // Listen for archive events
-      output.on('close', () => {
+      output.on("close", () => {
         const size = archive.pointer();
-        console.log(chalk.green(`✓ Archive created: ${outputPath} (${(size / 1024 / 1024).toFixed(2)} MB)`));
+        console.log(
+          chalk.green(
+            `✓ Archive created: ${outputPath} (${(size / 1024 / 1024).toFixed(
+              2
+            )} MB)`
+          )
+        );
         resolve(outputPath);
       });
-      
-      archive.on('error', (err) => {
+
+      archive.on("error", (err) => {
         reject(err);
       });
-      
-      archive.on('warning', (err) => {
-        if (err.code === 'ENOENT') {
+
+      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) {
@@ -131,47 +123,51 @@ export const createArchive = (sourceDir, outputPath, options = {}) => {
 };
 
 /**
- * Downloads folder contents and creates an archive
- * 
+ * 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} archiveFormat - Archive format ('zip' or 'tar')
- * @param {string} archiveName - Custom name for the archive file
- * @param {number} compressionLevel - Compression level (0-9)
+ * @param {string} archiveName - Custom name for the archive file (optional)
  * @returns {Promise<string>} - Path to the created archive
  */
-export const downloadAndArchive = async (repoInfo, outputDir, archiveFormat = 'zip', archiveName = null, compressionLevel = 6) => {
-  const { downloadFolder } = await import('./downloader.js');
-  
-  console.log(chalk.cyan(`Downloading folder and preparing to create ${archiveFormat.toUpperCase()} archive...`));
-  
+export const downloadAndArchive = async (
+  repoInfo,
+  outputDir,
+  archiveName = null
+) => {
+  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
     await downloadFolder(repoInfo, tempDir);
-    
+
     // Determine archive filename
     let archiveFileName = archiveName;
     if (!archiveFileName) {
       const { owner, repo, folderPath } = repoInfo;
-      const folderName = folderPath ? folderPath.split('/').pop() : repo;
+      const folderName = folderPath ? folderPath.split("/").pop() : repo;
       archiveFileName = `${folderName || repo}-${owner}`;
     }
-    
+
     // Add extension if not present
-    if (!archiveFileName.endsWith(`.${archiveFormat}`)) {
-      archiveFileName += `.${archiveFormat}`;
+    if (!archiveFileName.endsWith(`.zip`)) {
+      archiveFileName += `.zip`;
     }
-    
+
     const archivePath = path.join(outputDir, archiveFileName);
-    
+
     // Create the archive
-    console.log(chalk.cyan(`Creating ${archiveFormat.toUpperCase()} archive...`));
-    await createArchive(tempDir, archivePath, { format: archiveFormat, compressionLevel });
-    
+    console.log(chalk.cyan(`Creating ZIP archive...`));
+    await createArchive(tempDir, archivePath);
+
     return archivePath;
   } catch (error) {
     throw new Error(`Failed to create archive: ${error.message}`);
@@ -180,7 +176,11 @@ export const downloadAndArchive = async (repoInfo, outputDir, archiveFormat = 'z
     try {
       fs.rmSync(tempDir, { recursive: true, force: true });
     } catch (err) {
-      console.warn(chalk.yellow(`Warning: Failed to clean up temporary directory: ${err.message}`));
+      console.warn(
+        chalk.yellow(
+          `Warning: Failed to clean up temporary directory: ${err.message}`
+        )
+      );
     }
   }
-};
+};

package/src/downloader.js

@@ -17,11 +17,11 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
 // Define spinner animation frames
-const spinnerFrames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+const spinnerFrames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
 // Alternative progress bar characters for more visual appeal
 const progressChars = {
-  complete: '▰', // Alternative: '■', '●', '◆', '▣'
-  incomplete: '▱', // Alternative: '□', '○', '◇', '▢'
+  complete: "▰", // Alternative: '■', '●', '◆', '▣'
+  incomplete: "▱", // Alternative: '□', '○', '◇', '▢'
 };
 
 // Track frame index for spinner animation
@@ -46,43 +46,112 @@ const getSpinnerFrame = () => {
  * @returns {Promise<Array>} - Promise resolving to an array of file objects
  */
 const fetchFolderContents = async (owner, repo, branch, folderPath) => {
-  const apiUrl = `https://api.github.com/repos/${owner}/${repo}/git/trees/${branch}?recursive=1`;
+  let effectiveBranch = branch;
+  if (!effectiveBranch) {
+    // If no branch is specified, fetch the default branch for the repository
+    try {
+      const repoInfoUrl = `https://api.github.com/repos/${owner}/${repo}`;
+      const repoInfoResponse = await axios.get(repoInfoUrl);
+      effectiveBranch = repoInfoResponse.data.default_branch;
+      if (!effectiveBranch) {
+        console.error(
+          chalk.red(
+            `Could not determine default branch for ${owner}/${repo}. Please specify a branch in the URL.`
+          )
+        );
+        return [];
+      }
+      console.log(
+        chalk.blue(
+          `No branch specified, using default branch: ${effectiveBranch}`
+        )
+      );
+    } catch (error) {
+      console.error(
+        chalk.red(
+          `Failed to fetch default branch for ${owner}/${repo}: ${error.message}`
+        )
+      );
+      return [];
+    }
+  }
+
+  const apiUrl = `https://api.github.com/repos/${owner}/${repo}/git/trees/${effectiveBranch}?recursive=1`;
 
   try {
     const response = await axios.get(apiUrl);
-    
+
     // Check if GitHub API returned truncated results
     if (response.data.truncated) {
-      console.warn(chalk.yellow(
-        `Warning: The repository is too large and some files may be missing. ` +
-        `Consider using git clone for complete repositories.`
-      ));
+      console.warn(
+        chalk.yellow(
+          `Warning: The repository is too large and some files may be missing. ` +
+            `Consider using git clone for complete repositories.`
+        )
+      );
+    }
+
+    // Original filter:
+    // return response.data.tree.filter((item) =>
+    //   item.path.startsWith(folderPath)
+    // );
+
+    // New filter logic:
+    if (folderPath === "") {
+      // For the root directory, all items from the recursive tree are relevant.
+      // item.path.startsWith("") would also achieve this.
+      return response.data.tree;
+    } else {
+      // For a specific folder, items must be *inside* that folder.
+      // Ensure folderPath is treated as a directory prefix by adding a trailing slash if not present.
+      const prefix = folderPath.endsWith("/") ? folderPath : folderPath + "/";
+      return response.data.tree.filter((item) => item.path.startsWith(prefix));
     }
-    
-    return response.data.tree.filter((item) => item.path.startsWith(folderPath));
   } catch (error) {
     if (error.response) {
       // Handle specific HTTP error codes
-      switch(error.response.status) {
+      switch (error.response.status) {
         case 403:
-          if (error.response.headers['x-ratelimit-remaining'] === '0') {
-            console.error(chalk.red(
-              `GitHub API rate limit exceeded. Please wait until ${
-                new Date(parseInt(error.response.headers['x-ratelimit-reset']) * 1000).toLocaleTimeString()
-              } or add a GitHub token (feature coming soon).`
-            ));
+          if (error.response.headers["x-ratelimit-remaining"] === "0") {
+            console.error(
+              chalk.red(
+                `GitHub API rate limit exceeded. Please wait until ${new Date(
+                  parseInt(error.response.headers["x-ratelimit-reset"]) * 1000
+                ).toLocaleTimeString()} or add a GitHub token (feature coming soon).`
+              )
+            );
           } else {
-            console.error(chalk.red(`Access forbidden: ${error.response.data.message || 'Unknown reason'}`));
+            console.error(
+              chalk.red(
+                `Access forbidden: ${
+                  error.response.data.message || "Unknown reason"
+                }`
+              )
+            );
           }
           break;
         case 404:
-          console.error(chalk.red(`Repository, branch, or folder not found: ${owner}/${repo}/${branch}/${folderPath}`));
+          console.error(
+            chalk.red(
+              `Repository, branch, or folder not found: ${owner}/${repo}/${branch}/${folderPath}`
+            )
+          );
           break;
         default:
-          console.error(chalk.red(`API error (${error.response.status}): ${error.response.data.message || error.message}`));
+          console.error(
+            chalk.red(
+              `API error (${error.response.status}): ${
+                error.response.data.message || error.message
+              }`
+            )
+          );
       }
     } else if (error.request) {
-      console.error(chalk.red(`Network error: No response received from GitHub. Please check your internet connection.`));
+      console.error(
+        chalk.red(
+          `Network error: No response received from GitHub. Please check your internet connection.`
+        )
+      );
     } else {
       console.error(chalk.red(`Error preparing request: ${error.message}`));
     }
@@ -100,44 +169,81 @@ const fetchFolderContents = async (owner, repo, branch, folderPath) => {
  * @returns {Promise<Object>} - Object containing download status
  */
 const downloadFile = async (owner, repo, branch, filePath, outputPath) => {
-  const url = `https://raw.githubusercontent.com/${owner}/${repo}/${branch}/${filePath}`;
+  let effectiveBranch = branch;
+  if (!effectiveBranch) {
+    // If no branch is specified, fetch the default branch for the repository
+    // This check might be redundant if fetchFolderContents already resolved it,
+    // but it's a good fallback for direct downloadFile calls if any.
+    try {
+      const repoInfoUrl = `https://api.github.com/repos/${owner}/${repo}`;
+      const repoInfoResponse = await axios.get(repoInfoUrl);
+      effectiveBranch = repoInfoResponse.data.default_branch;
+      if (!effectiveBranch) {
+        // console.error(chalk.red(`Could not determine default branch for ${owner}/${repo} for file ${filePath}.`));
+        // Do not log error here as it might be a root file download where branch is not in URL
+      }
+    } catch (error) {
+      // console.error(chalk.red(`Failed to fetch default branch for ${owner}/${repo} for file ${filePath}: ${error.message}`));
+      // Do not log error here
+    }
+    // If still no branch, the raw URL might work for default branch, or fail.
+    // The original code didn't explicitly handle this for downloadFile, relying on raw.githubusercontent default behavior.
+    // For robustness, we should ensure effectiveBranch is set. If not, the URL will be malformed or use GitHub's default.
+    if (!effectiveBranch) {
+      // Fallback to a common default, or let the API call fail if truly ambiguous
+      // For raw content, GitHub often defaults to the main branch if not specified,
+      // but it's better to be explicit if we can.
+      // However, altering the URL structure for raw.githubusercontent.com without a branch
+      // might be tricky if the original URL didn't have it.
+      // The existing raw URL construction assumes branch is present or GitHub handles its absence.
+      // Let's stick to the original logic for raw URL construction if branch is not found,
+      // as `https://raw.githubusercontent.com/${owner}/${repo}/${filePath}` might work for root files on default branch.
+      // The critical part is `fetchFolderContents` determining the branch for listing.
+    }
+  }
+
+  const baseUrl = `https://raw.githubusercontent.com/${owner}/${repo}`;
+  const fileUrlPath = effectiveBranch
+    ? `/${effectiveBranch}/${filePath}`
+    : `/${filePath}`; // filePath might be at root
+  const url = `${baseUrl}${fileUrlPath}`;
 
   try {
     const response = await axios.get(url, { responseType: "arraybuffer" });
-    
+
     // Ensure the directory exists
     try {
       fs.mkdirSync(path.dirname(outputPath), { recursive: true });
     } catch (dirError) {
-      return { 
-        filePath, 
-        success: false, 
+      return {
+        filePath,
+        success: false,
         error: `Failed to create directory: ${dirError.message}`,
-        size: 0
+        size: 0,
       };
     }
-    
+
     // Write the file
     try {
       fs.writeFileSync(outputPath, Buffer.from(response.data));
     } catch (fileError) {
-      return { 
-        filePath, 
-        success: false, 
+      return {
+        filePath,
+        success: false,
         error: `Failed to write file: ${fileError.message}`,
-        size: 0
+        size: 0,
       };
     }
-    
-    return { 
-      filePath, 
+
+    return {
+      filePath,
       success: true,
-      size: response.data.length
+      size: response.data.length,
     };
   } catch (error) {
     // More detailed error handling for network requests
     let errorMessage = error.message;
-    
+
     if (error.response) {
       // The request was made and the server responded with an error status
       switch (error.response.status) {
@@ -154,12 +260,12 @@ const downloadFile = async (owner, repo, branch, filePath, outputPath) => {
       // The request was made but no response was received
       errorMessage = "No response from server";
     }
-    
-    return { 
-      filePath, 
-      success: false, 
+
+    return {
+      filePath,
+      success: false,
       error: errorMessage,
-      size: 0
+      size: 0,
     };
   }
 };
@@ -179,31 +285,40 @@ const createProgressRenderer = (owner, repo, folderPath) => {
     try {
       const { value, total, startTime } = params;
       const { downloadedSize = 0 } = payload || { downloadedSize: 0 };
-      
+
       // Calculate progress percentage
       const progress = Math.min(1, Math.max(0, value / Math.max(1, total)));
       const percentage = Math.floor(progress * 100);
-      
+
       // Calculate elapsed time
       const elapsedSecs = Math.max(0.1, (Date.now() - startTime) / 1000);
-      
+
       // Create the progress bar
-      const barLength = Math.max(20, Math.min(40, Math.floor(terminalWidth / 2)));
+      const barLength = Math.max(
+        20,
+        Math.min(40, Math.floor(terminalWidth / 2))
+      );
       const completedLength = Math.round(barLength * progress);
       const remainingLength = barLength - completedLength;
-      
+
       // Build the bar with custom progress characters
-      const completedBar = chalk.greenBright(progressChars.complete.repeat(completedLength));
-      const remainingBar = chalk.gray(progressChars.incomplete.repeat(remainingLength));
-      
+      const completedBar = chalk.greenBright(
+        progressChars.complete.repeat(completedLength)
+      );
+      const remainingBar = chalk.gray(
+        progressChars.incomplete.repeat(remainingLength)
+      );
+
       // Add spinner for animation
       const spinner = chalk.cyanBright(getSpinnerFrame());
-      
+
       // Format the output
       const progressInfo = `${chalk.cyan(`${value}/${total}`)} files`;
       const sizeInfo = prettyBytes(downloadedSize || 0);
-      
-      return `${spinner} ${completedBar}${remainingBar} ${chalk.yellow(percentage + '%')} | ${progressInfo} | ${chalk.magenta(sizeInfo)}`;
+
+      return `${spinner} ${completedBar}${remainingBar} ${chalk.yellow(
+        percentage + "%"
+      )} | ${progressInfo} | ${chalk.magenta(sizeInfo)}`;
     } catch (error) {
       // Fallback to a very simple progress indicator
       return `${Math.floor((params.value / params.total) * 100)}% complete`;
@@ -221,88 +336,120 @@ const createProgressRenderer = (owner, repo, folderPath) => {
  * @param {string} outputDir - Directory where files should be saved
  * @returns {Promise<void>} - Promise that resolves when all files are downloaded
  */
-const downloadFolder = async ({ owner, repo, branch, folderPath }, outputDir) => {
-  console.log(chalk.cyan(`Analyzing repository structure for ${owner}/${repo}...`));
+const downloadFolder = async (
+  { owner, repo, branch, folderPath },
+  outputDir
+) => {
+  console.log(
+    chalk.cyan(`Analyzing repository structure for ${owner}/${repo}...`)
+  );
 
   try {
     const contents = await fetchFolderContents(owner, repo, branch, folderPath);
-    
+
     if (!contents || contents.length === 0) {
-      console.log(chalk.yellow(`No files found in ${folderPath || 'repository root'}`));
+      console.log(
+        chalk.yellow(`No files found in ${folderPath || "repository root"}`)
+      );
       console.log(chalk.green(`Folder cloned successfully!`));
       return;
     }
 
     // Filter for blob type (files)
-    const files = contents.filter(item => item.type === "blob");
+    const files = contents.filter((item) => item.type === "blob");
     const totalFiles = files.length;
-    
+
     if (totalFiles === 0) {
-      console.log(chalk.yellow(`No files found in ${folderPath || 'repository root'} (only directories)`));
+      console.log(
+        chalk.yellow(
+          `No files found in ${
+            folderPath || "repository root"
+          } (only directories)`
+        )
+      );
       console.log(chalk.green(`Folder cloned successfully!`));
       return;
     }
-    
-    console.log(chalk.cyan(`Downloading ${totalFiles} files from ${chalk.white(owner + '/' + repo)}...`));
-    
+
+    console.log(
+      chalk.cyan(
+        `Downloading ${totalFiles} files from ${chalk.white(
+          owner + "/" + repo
+        )}...`
+      )
+    );
+
     // Simplified progress bar setup
     const progressBar = new cliProgress.SingleBar({
       format: createProgressRenderer(owner, repo, folderPath),
       hideCursor: true,
       clearOnComplete: false,
       stopOnComplete: true,
-      forceRedraw: true
+      forceRedraw: true,
     });
-    
+
     // Track download metrics
     let downloadedSize = 0;
     const startTime = Date.now();
     let failedFiles = [];
-    
+
     // Start progress bar
     progressBar.start(totalFiles, 0, {
       downloadedSize: 0,
-      startTime
+      startTime,
     });
-    
+
     // Create download promises with concurrency control
     const fileDownloadPromises = files.map((item) => {
       // Keep the original structure by preserving the folder name
       let relativePath = item.path;
-      if (folderPath && folderPath.trim() !== '') {
-        relativePath = item.path.substring(folderPath.length).replace(/^\//, "");
+      if (folderPath && folderPath.trim() !== "") {
+        relativePath = item.path
+          .substring(folderPath.length)
+          .replace(/^\//, "");
       }
       const outputFilePath = path.join(outputDir, relativePath);
-      
+
       return limit(async () => {
         try {
-          const result = await downloadFile(owner, repo, branch, item.path, outputFilePath);
-          
+          const result = await downloadFile(
+            owner,
+            repo,
+            branch,
+            item.path,
+            outputFilePath
+          );
+
           // Update progress metrics
           if (result.success) {
-            downloadedSize += (result.size || 0);
+            downloadedSize += result.size || 0;
           } else {
             // Track failed files for reporting
             failedFiles.push({
               path: item.path,
-              error: result.error
+              error: result.error,
             });
           }
-          
+
           // Update progress bar with current metrics
           progressBar.increment(1, {
-            downloadedSize
+            downloadedSize,
           });
-          
+
           return result;
         } catch (error) {
           failedFiles.push({
             path: item.path,
-            error: error.message
+            error: error.message,
           });
-          
+
           progressBar.increment(1, { downloadedSize });
-          return { filePath: item.path, success: false, error: error.message, size: 0 };
+          return {
+            filePath: item.path,
+            success: false,
+            error: error.message,
+            size: 0,
+          };
         }
       });
     });
@@ -310,7 +457,7 @@ const downloadFolder = async ({ owner, repo, branch, folderPath }, outputDir) =>
     // Execute downloads in parallel with controlled concurrency
     const results = await Promise.all(fileDownloadPromises);
     progressBar.stop();
-    
+
     console.log(); // Add an empty line after progress bar
 
     // Count successful and failed downloads
@@ -318,21 +465,31 @@ const downloadFolder = async ({ owner, repo, branch, folderPath }, outputDir) =>
     const failed = failedFiles.length;
 
     if (failed > 0) {
-      console.log(chalk.yellow(`Downloaded ${succeeded} files successfully, ${failed} files failed`));
-      
+      console.log(
+        chalk.yellow(
+          `Downloaded ${succeeded} files successfully, ${failed} files failed`
+        )
+      );
+
       // Show detailed errors if there aren't too many
       if (failed <= 5) {
-        console.log(chalk.yellow('Failed files:'));
-        failedFiles.forEach(file => {
+        console.log(chalk.yellow("Failed files:"));
+        failedFiles.forEach((file) => {
           console.log(chalk.yellow(`  - ${file.path}: ${file.error}`));
         });
       } else {
-        console.log(chalk.yellow(`${failed} files failed to download. Check your connection or repository access.`));
+        console.log(
+          chalk.yellow(
+            `${failed} files failed to download. Check your connection or repository access.`
+          )
+        );
       }
     } else {
-      console.log(chalk.green(` All ${succeeded} files downloaded successfully!`));
+      console.log(
+        chalk.green(` All ${succeeded} files downloaded successfully!`)
+      );
     }
-    
+
     console.log(chalk.green(`Folder cloned successfully!`));
   } catch (error) {
     console.error(chalk.red(`Error downloading folder: ${error.message}`));

package/src/index.js

@@ -1,16 +1,16 @@
-import { program } from 'commander';
-import { parseGitHubUrl } from './parser.js';
-import { downloadFolder } from './downloader.js';
-import { downloadAndArchive } from './archiver.js';
-import { fileURLToPath } from 'url';
-import { dirname, join, resolve } from 'path';
-import fs from 'fs';
+import { program } from "commander";
+import { parseGitHubUrl } from "./parser.js";
+import { downloadFolder } from "./downloader.js";
+import { downloadAndArchive } from "./archiver.js";
+import { fileURLToPath } from "url";
+import { dirname, join, resolve } from "path";
+import fs from "fs";
 
 // Get package.json for version
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
-const packagePath = join(__dirname, '..', 'package.json');
-const packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+const packagePath = join(__dirname, "..", "package.json");
+const packageJson = JSON.parse(fs.readFileSync(packagePath, "utf8"));
 
 /**
  * Validates and ensures the output directory exists
@@ -20,12 +20,12 @@ const packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
  */
 const validateOutputDirectory = (outputDir) => {
   if (!outputDir) {
-    throw new Error('Output directory is required');
+    throw new Error("Output directory is required");
   }
 
   // Resolve to absolute path
   const resolvedDir = resolve(outputDir);
-  
+
   try {
     // Check if directory exists, if not try to create it
     if (!fs.existsSync(resolvedDir)) {
@@ -34,16 +34,18 @@ const validateOutputDirectory = (outputDir) => {
       // Check if it's actually a directory
       const stats = fs.statSync(resolvedDir);
       if (!stats.isDirectory()) {
-        throw new Error(`Output path exists but is not a directory: ${outputDir}`);
+        throw new Error(
+          `Output path exists but is not a directory: ${outputDir}`
+        );
       }
     }
-    
+
     // Check if the directory is writable
     fs.accessSync(resolvedDir, fs.constants.W_OK);
-    
+
     return resolvedDir;
   } catch (error) {
-    if (error.code === 'EACCES') {
+    if (error.code === "EACCES") {
       throw new Error(`Permission denied: Cannot write to ${outputDir}`);
     }
     throw new Error(`Invalid output directory: ${error.message}`);
@@ -53,53 +55,38 @@ const validateOutputDirectory = (outputDir) => {
 const initializeCLI = () => {
   program
     .version(packageJson.version)
-    .description('Clone specific folders from GitHub repositories')
-    .argument('<url>', 'GitHub URL of the folder to clone')
-    .option('-o, --output <directory>', 'Output directory', process.cwd())
-    .option('--zip [filename]', 'Create ZIP archive of downloaded files')
-    .option('--tar [filename]', 'Create TAR archive of downloaded files')
-    .option('--compression-level <level>', 'Compression level (1-9)', '6')
+    .description("Clone specific folders from GitHub repositories")
+    .argument("<url>", "GitHub URL of the folder to clone")
+    .option("-o, --output <directory>", "Output directory", process.cwd())
+    .option("--zip [filename]", "Create ZIP archive of downloaded files")
     .action(async (url, options) => {
       try {
         console.log(`Parsing URL: ${url}`);
         const parsedUrl = parseGitHubUrl(url);
-        
-        // Validate options
-        if (options.compressionLevel) {
-          const level = parseInt(options.compressionLevel, 10);
-          if (isNaN(level) || level < 1 || level > 9) {
-            throw new Error('Compression level must be a number between 1 and 9');
-          }
-        }
 
-        if (options.zip && options.tar) {
-          throw new Error('Cannot specify both --zip and --tar options at the same time');
-        }
-        
         // Validate output directory
         try {
           options.output = validateOutputDirectory(options.output);
         } catch (dirError) {
           throw new Error(`Output directory error: ${dirError.message}`);
         }
-        
-        // Handle archive options
-        const archiveFormat = options.zip ? 'zip' : options.tar ? 'tar' : null;
-        const archiveName = typeof options.zip === 'string' ? options.zip : 
-                           typeof options.tar === 'string' ? options.tar : null;
-        const compressionLevel = parseInt(options.compressionLevel, 10) || 6;
-        
-        if (archiveFormat) {
-          console.log(`Creating ${archiveFormat.toUpperCase()} archive...`);
-          await downloadAndArchive(parsedUrl, options.output, archiveFormat, archiveName, compressionLevel);
+
+        // Handle archive option
+        const createArchive = options.zip !== undefined;
+        const archiveName =
+          typeof options.zip === "string" ? options.zip : null;
+
+        if (createArchive) {
+          console.log(`Creating ZIP archive...`);
+          await downloadAndArchive(parsedUrl, options.output, archiveName);
         } else {
           console.log(`Downloading folder to: ${options.output}`);
           await downloadFolder(parsedUrl, options.output);
         }
-        
-        console.log('Operation completed successfully!');
+
+        console.log("Operation completed successfully!");
       } catch (error) {
-        console.error('Error:', error.message);
+        console.error("Error:", error.message);
         process.exit(1);
       }
     });

package/src/parser.js

@@ -1,27 +1,30 @@
 export function parseGitHubUrl(url) {
-    // Validate the URL format
-    if (!url || typeof url !== 'string') {
-        throw new Error('Invalid URL: URL must be a non-empty string');
-    }
+  // Validate the URL format
+  if (!url || typeof url !== "string") {
+    throw new Error("Invalid URL: URL must be a non-empty string");
+  }
 
-    // Validate if it's a GitHub URL
-    const githubUrlPattern = /^https?:\/\/(?:www\.)?github\.com\/([^\/]+)\/([^\/]+)(?:\/tree\/([^\/]+)(?:\/(.+))?)?$/;
-    const match = url.match(githubUrlPattern);
+  // Validate if it's a GitHub URL
+  const githubUrlPattern =
+    /^https?:\/\/(?:www\.)?github\.com\/([^\/]+)\/([^\/]+)(?:\/(?:tree|blob)\/([^\/]+)(?:\/(.+))?)?$/;
+  const match = url.match(githubUrlPattern);
 
-    if (!match) {
-        throw new Error('Invalid GitHub URL format. Expected: https://github.com/owner/repo/tree/branch/folder');
-    }
+  if (!match) {
+    throw new Error(
+      "Invalid GitHub URL format. Expected: https://github.com/owner/repo[/tree|/blob]/branch/folder_or_file"
+    );
+  }
 
-    // Extract components from the matched pattern
-    const owner = match[1];
-    const repo = match[2];
-    const branch = match[3] || 'main'; // Default to 'main' if branch is not specified
-    const folderPath = match[4] || ''; // Empty string if no folder path
+  // Extract components from the matched pattern
+  const owner = match[1];
+  const repo = match[2];
+  const branch = match[3]; // Branch might not be in the URL for root downloads
+  const folderPath = match[4] || ""; // Empty string if no folder path
 
-    // Additional validation
-    if (!owner || !repo) {
-        throw new Error('Invalid GitHub URL: Missing repository owner or name');
-    }
+  // Additional validation
+  if (!owner || !repo) {
+    throw new Error("Invalid GitHub URL: Missing repository owner or name");
+  }
 
-    return { owner, repo, branch, folderPath };
+  return { owner, repo, branch, folderPath };
 }