git-ripper 1.4.5 → 1.4.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "git-ripper",
-  "version": "1.4.5",
+  "version": "1.4.7",
   "description": "CLI tool that lets you download specific folders from GitHub repositories without cloning the entire repo.",
   "main": "src/index.js",
   "type": "module",

package/src/archiver.js

@@ -88,7 +88,7 @@ export const createArchive = (sourceDir, outputPath) => {
         const size = archive.pointer();
         console.log(
           chalk.green(
-            `✓ Archive created: ${outputPath} (${(size / 1024 / 1024).toFixed(
+            `Archive created: ${outputPath} (${(size / 1024 / 1024).toFixed(
               2
             )} MB)`
           )
@@ -144,10 +144,32 @@ export const downloadAndArchive = async (
   // 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);
+    const downloadResult = await downloadFolder(repoInfo, tempDir);
+
+    // 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;

package/src/downloader.js

@@ -45,22 +45,22 @@ const getSpinnerFrame = () => {
  * @param {string} branch - Branch name
  * @param {string} folderPath - Path to the folder
  * @returns {Promise<Array>} - Promise resolving to an array of file objects
+ * @throws {Error} - Throws error on API failures instead of returning empty array
  */
 const fetchFolderContents = async (owner, repo, branch, folderPath) => {
   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 repoInfoUrl = `https://api.github.com/repos/${encodeURIComponent(
+        owner
+      )}/${encodeURIComponent(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.`
-          )
+        throw new Error(
+          `Could not determine default branch for ${owner}/${repo}. Please specify a branch in the URL.`
         );
-        return [];
       }
       console.log(
         chalk.blue(
@@ -68,16 +68,20 @@ const fetchFolderContents = async (owner, repo, branch, folderPath) => {
         )
       );
     } catch (error) {
-      console.error(
-        chalk.red(
-          `Failed to fetch default branch for ${owner}/${repo}: ${error.message}`
-        )
+      if (error.message.includes("Could not determine default branch")) {
+        throw error;
+      }
+      throw new Error(
+        `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`;
+  const apiUrl = `https://api.github.com/repos/${encodeURIComponent(
+    owner
+  )}/${encodeURIComponent(repo)}/git/trees/${encodeURIComponent(
+    effectiveBranch
+  )}?recursive=1`;
 
   try {
     const response = await axios.get(apiUrl);
@@ -109,54 +113,44 @@ const fetchFolderContents = async (owner, repo, branch, folderPath) => {
       return response.data.tree.filter((item) => item.path.startsWith(prefix));
     }
   } catch (error) {
+    let errorMessage = "";
+    let isRateLimit = false;
+
     if (error.response) {
       // Handle specific HTTP error codes
       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).`
-              )
-            );
+            isRateLimit = true;
+            errorMessage = `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"
-                }`
-              )
-            );
+            errorMessage = `Access forbidden: ${
+              error.response.data.message ||
+              "Repository may be private or you may not have access"
+            }`;
           }
           break;
         case 404:
-          console.error(
-            chalk.red(
-              `Repository, branch, or folder not found: ${owner}/${repo}/${branch}/${folderPath}`
-            )
-          );
+          errorMessage = `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
-              }`
-            )
-          );
+          errorMessage = `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.`
-        )
-      );
+      errorMessage = `Network error: No response received from GitHub. Please check your internet connection.`;
     } else {
-      console.error(chalk.red(`Error preparing request: ${error.message}`));
+      errorMessage = `Error preparing request: ${error.message}`;
     }
-    return [];
+
+    // Always throw the error instead of returning empty array
+    const enrichedError = new Error(errorMessage);
+    enrichedError.isRateLimit = isRateLimit;
+    enrichedError.statusCode = error.response?.status;
+    throw enrichedError;
   }
 };
 
@@ -176,7 +170,9 @@ const downloadFile = async (owner, repo, branch, filePath, outputPath) => {
     // 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 repoInfoUrl = `https://api.github.com/repos/${encodeURIComponent(
+        owner
+      )}/${encodeURIComponent(repo)}`;
       const repoInfoResponse = await axios.get(repoInfoUrl);
       effectiveBranch = repoInfoResponse.data.default_branch;
       if (!effectiveBranch) {
@@ -203,10 +199,16 @@ const downloadFile = async (owner, repo, branch, filePath, outputPath) => {
     }
   }
 
-  const baseUrl = `https://raw.githubusercontent.com/${owner}/${repo}`;
+  const baseUrl = `https://raw.githubusercontent.com/${encodeURIComponent(
+    owner
+  )}/${encodeURIComponent(repo)}`;
+  const encodedFilePath = filePath
+    .split("/")
+    .map((part) => encodeURIComponent(part))
+    .join("/");
   const fileUrlPath = effectiveBranch
-    ? `/${effectiveBranch}/${filePath}`
-    : `/${filePath}`; // filePath might be at root
+    ? `/${encodeURIComponent(effectiveBranch)}/${encodedFilePath}`
+    : `/${encodedFilePath}`; // filePath might be at root
   const url = `${baseUrl}${fileUrlPath}`;
 
   try {
@@ -349,11 +351,15 @@ const downloadFolder = async (
     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.green(`Folder cloned successfully!`));
-      return;
+      const message = `No files found in ${folderPath || "repository root"}`;
+      console.log(chalk.yellow(message));
+      // Don't print success message when no files are found - this might indicate an error
+      return {
+        success: true,
+        filesDownloaded: 0,
+        failedFiles: 0,
+        isEmpty: true,
+      };
     }
 
     // Filter for blob type (files)
@@ -361,15 +367,18 @@ const downloadFolder = async (
     const totalFiles = files.length;
 
     if (totalFiles === 0) {
-      console.log(
-        chalk.yellow(
-          `No files found in ${
-            folderPath || "repository root"
-          } (only directories)`
-        )
-      );
-      console.log(chalk.green(`Folder cloned successfully!`));
-      return;
+      const message = `No files found in ${
+        folderPath || "repository root"
+      } (only directories)`;
+      console.log(chalk.yellow(message));
+      // This is a legitimate case - directory exists but contains only subdirectories
+      console.log(chalk.green(`Directory structure downloaded successfully!`));
+      return {
+        success: true,
+        filesDownloaded: 0,
+        failedFiles: 0,
+        isEmpty: true,
+      };
     }
 
     console.log(
@@ -464,7 +473,6 @@ const downloadFolder = async (
     // Count successful and failed downloads
     const succeeded = results.filter((r) => r.success).length;
     const failed = failedFiles.length;
-
     if (failed > 0) {
       console.log(
         chalk.yellow(
@@ -485,15 +493,45 @@ const downloadFolder = async (
           )
         );
       }
+
+      // Don't claim success if files failed to download
+      if (succeeded === 0) {
+        console.log(
+          chalk.red(`Download failed: No files were downloaded successfully`)
+        );
+        return {
+          success: false,
+          filesDownloaded: succeeded,
+          failedFiles: failed,
+          isEmpty: false,
+        };
+      } else {
+        console.log(chalk.yellow(`Download completed with errors`));
+        return {
+          success: false,
+          filesDownloaded: succeeded,
+          failedFiles: failed,
+          isEmpty: false,
+        };
+      }
     } else {
       console.log(
-        chalk.green(` All ${succeeded} files downloaded successfully!`)
+        chalk.green(`All ${succeeded} files downloaded successfully!`)
       );
+      console.log(chalk.green(`Folder cloned successfully!`));
+      return {
+        success: true,
+        filesDownloaded: succeeded,
+        failedFiles: failed,
+        isEmpty: false,
+      };
     }
-
-    console.log(chalk.green(`Folder cloned successfully!`));
   } catch (error) {
+    // Log the specific error details
     console.error(chalk.red(`Error downloading folder: ${error.message}`));
+
+    // Re-throw the error so the main CLI can exit with proper error code
+    throw error;
   }
 };
 
@@ -515,9 +553,17 @@ const downloadFolderWithResume = async (
   }
 
   const resumeManager = new ResumeManager();
-  const url = `https://github.com/${owner}/${repo}/tree/${branch || "main"}/${
-    folderPath || ""
-  }`;
+  const encodedFolderPath = folderPath
+    ? folderPath
+        .split("/")
+        .map((part) => encodeURIComponent(part))
+        .join("/")
+    : "";
+  const url = `https://github.com/${encodeURIComponent(
+    owner
+  )}/${encodeURIComponent(repo)}/tree/${encodeURIComponent(
+    branch || "main"
+  )}/${encodedFolderPath}`;
 
   // Clear checkpoint if force restart is requested
   if (forceRestart) {
@@ -530,14 +576,14 @@ const downloadFolderWithResume = async (
   if (checkpoint) {
     console.log(
       chalk.blue(
-        `🔄 Found previous download from ${new Date(
+        `Found previous download from ${new Date(
           checkpoint.timestamp
         ).toLocaleString()}`
       )
     );
     console.log(
       chalk.blue(
-        `📊 Progress: ${checkpoint.downloadedFiles.length}/${checkpoint.totalFiles} files completed`
+        `Progress: ${checkpoint.downloadedFiles.length}/${checkpoint.totalFiles} files completed`
       )
     );
 
@@ -563,11 +609,11 @@ const downloadFolderWithResume = async (
     if (corruptedCount > 0) {
       console.log(
         chalk.yellow(
-          `🔧 Detected ${corruptedCount} corrupted files, will re-download`
+          `Detected ${corruptedCount} corrupted files, will re-download`
         )
       );
     }
-    console.log(chalk.green(`✅ Verified ${validFiles.length} existing files`));
+    console.log(chalk.green(`Verified ${validFiles.length} existing files`));
   }
 
   console.log(
@@ -576,13 +622,16 @@ const downloadFolderWithResume = async (
 
   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.green(`Folder cloned successfully!`));
-      return;
+      const message = `No files found in ${folderPath || "repository root"}`;
+      console.log(chalk.yellow(message));
+      // Don't print success message when no files are found - this might indicate an error
+      return {
+        success: true,
+        filesDownloaded: 0,
+        failedFiles: 0,
+        isEmpty: true,
+      };
     }
 
     // Filter for blob type (files)
@@ -590,15 +639,18 @@ const downloadFolderWithResume = async (
     const totalFiles = files.length;
 
     if (totalFiles === 0) {
-      console.log(
-        chalk.yellow(
-          `No files found in ${
-            folderPath || "repository root"
-          } (only directories)`
-        )
-      );
-      console.log(chalk.green(`Folder cloned successfully!`));
-      return;
+      const message = `No files found in ${
+        folderPath || "repository root"
+      } (only directories)`;
+      console.log(chalk.yellow(message));
+      // This is a legitimate case - directory exists but contains only subdirectories
+      console.log(chalk.green(`Directory structure downloaded successfully!`));
+      return {
+        success: true,
+        filesDownloaded: 0,
+        failedFiles: 0,
+        isEmpty: true,
+      };
     }
 
     // Create new checkpoint if none exists
@@ -610,7 +662,7 @@ const downloadFolderWithResume = async (
       );
       console.log(
         chalk.cyan(
-          `📥 Starting download of ${totalFiles} files from ${chalk.white(
+          `Starting download of ${totalFiles} files from ${chalk.white(
             owner + "/" + repo
           )}...`
         )
@@ -618,7 +670,7 @@ const downloadFolderWithResume = async (
     } else {
       // Update total files in case repository changed
       checkpoint.totalFiles = totalFiles;
-      console.log(chalk.cyan(`📥 Resuming download...`));
+      console.log(chalk.cyan(`Resuming download...`));
     }
 
     // Get remaining files to download
@@ -633,13 +685,13 @@ const downloadFolderWithResume = async (
     });
 
     if (remainingFiles.length === 0) {
-      console.log(chalk.green(`🎉 All files already downloaded!`));
+      console.log(chalk.green(`All files already downloaded!`));
       resumeManager.cleanupCheckpoint(url, outputDir);
       return;
     }
 
     console.log(
-      chalk.cyan(`📥 Downloading ${remainingFiles.length} remaining files...`)
+      chalk.cyan(`Downloading ${remainingFiles.length} remaining files...`)
     );
 
     // Setup progress bar
@@ -723,10 +775,8 @@ const downloadFolderWithResume = async (
         if (error.name === "SIGINT") {
           resumeManager.saveCheckpoint(checkpoint);
           progressBar.stop();
-          console.log(
-            chalk.blue(`\n⏸️  Download interrupted. Progress saved.`)
-          );
-          console.log(chalk.blue(`💡 Run the same command again to resume.`));
+          console.log(chalk.blue(`\nDownload interrupted. Progress saved.`));
+          console.log(chalk.blue(`Run the same command again to resume.`));
           return;
         }
 
@@ -748,7 +798,6 @@ const downloadFolderWithResume = async (
     // Count results
     const succeeded = checkpoint.downloadedFiles.length;
     const failed = failedFiles.length;
-
     if (failed > 0) {
       console.log(
         chalk.yellow(
@@ -764,16 +813,42 @@ const downloadFolderWithResume = async (
       }
 
       console.log(
-        chalk.blue(`💡 Run the same command again to retry failed downloads`)
+        chalk.blue(`Run the same command again to retry failed downloads`)
       );
+
+      // Don't claim success if files failed to download
+      if (succeeded === 0) {
+        console.log(
+          chalk.red(`Download failed: No files were downloaded successfully`)
+        );
+        return {
+          success: false,
+          filesDownloaded: succeeded,
+          failedFiles: failed,
+          isEmpty: false,
+        };
+      } else {
+        console.log(chalk.yellow(`Download completed with errors`));
+        return {
+          success: false,
+          filesDownloaded: succeeded,
+          failedFiles: failed,
+          isEmpty: false,
+        };
+      }
     } else {
       console.log(
-        chalk.green(`🎉 All ${succeeded} files downloaded successfully!`)
+        chalk.green(`All ${succeeded} files downloaded successfully!`)
       );
       resumeManager.cleanupCheckpoint(url, outputDir);
+      console.log(chalk.green(`Folder cloned successfully!`));
+      return {
+        success: true,
+        filesDownloaded: succeeded,
+        failedFiles: failed,
+        isEmpty: false,
+      };
     }
-
-    console.log(chalk.green(`Folder cloned successfully!`));
   } catch (error) {
     // Save checkpoint on any error
     if (checkpoint) {

package/src/index.js

@@ -76,7 +76,7 @@ const initializeCLI = () => {
             return;
           }
 
-          console.log(chalk.cyan("\n📋 Download Checkpoints:"));
+          console.log(chalk.cyan("\nDownload Checkpoints:"));
           checkpoints.forEach((cp, index) => {
             console.log(chalk.blue(`\n${index + 1}. ID: ${cp.id}`));
             console.log(`   URL: ${cp.url}`);
@@ -123,24 +123,46 @@ const initializeCLI = () => {
           forceRestart: options.forceRestart || false,
         };
 
-        if (createArchive) {
-          console.log(`Creating ZIP archive...`);
-          await downloadAndArchive(parsedUrl, options.output, archiveName);
-        } else {
-          console.log(`Downloading folder to: ${options.output}`);
+        let operationType = createArchive ? "archive" : "download";
+        let result = null;
+        let error = null;
 
-          if (downloadOptions.resume) {
-            await downloadFolderWithResume(
-              parsedUrl,
-              options.output,
-              downloadOptions
-            );
+        try {
+          if (createArchive) {
+            console.log(`Creating ZIP archive...`);
+            await downloadAndArchive(parsedUrl, options.output, archiveName);
           } else {
-            await downloadFolder(parsedUrl, options.output);
+            console.log(`Downloading folder to: ${options.output}`);
+            if (downloadOptions.resume) {
+              result = await downloadFolderWithResume(
+                parsedUrl,
+                options.output,
+                downloadOptions
+              );
+            } else {
+              result = await downloadFolder(parsedUrl, options.output);
+            }
           }
+        } catch (opError) {
+          error = opError;
         }
 
-        console.log("Operation completed successfully!");
+        // Consolidated result and error handling
+        if (error) {
+          const failMsg =
+            operationType === "archive"
+              ? `Archive creation failed: ${error.message}`
+              : `Download failed: ${error.message}`;
+          console.error(chalk.red(failMsg));
+          process.exit(1);
+        } else if (!createArchive && result && !result.success) {
+          console.error(chalk.red(`Download failed`));
+          process.exit(1);
+        } else if (!createArchive && result && result.isEmpty) {
+          console.log("Operation completed - no files to download!");
+        } else {
+          console.log("Operation completed successfully!");
+        }
       } catch (error) {
         console.error("Error:", error.message);
         process.exit(1);

package/src/parser.js

@@ -16,10 +16,10 @@ export function parseGitHubUrl(url) {
   }
 
   // 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
+  const owner = decodeURIComponent(match[1]);
+  const repo = decodeURIComponent(match[2]);
+  const branch = match[3] ? decodeURIComponent(match[3]) : ""; // Branch is an empty string if not present
+  const folderPath = match[4] ? decodeURIComponent(match[4]) : ""; // Empty string if no folder path
 
   // Additional validation
   if (!owner || !repo) {