git0 0.1.4 → 0.1.6

package/gg.js

@@ -9,12 +9,297 @@ import { pipeline } from 'stream/promises';
 import fs from 'fs';
 import path from 'path';
 import gitUrlParse from 'git-url-parse';
-
+import os from 'os';
 
 const GITHUB_API = 'https://api.github.com/search/repositories';
 const RESULTS_PER_PAGE = 10;
 const TOKEN = process.env.GITHUB_TOKEN;
 
+// Detect current operating system and architecture
+function getCurrentPlatform() {
+    const platform = os.platform();
+    const arch = os.arch();
+    
+    const platformMap = {
+        'win32': 'windows',
+        'darwin': 'macos',
+        'linux': 'linux'
+    };
+    
+    const archMap = {
+        'x64': 'x86_64',
+        'arm64': 'arm64',
+        'arm': 'arm',
+        'ia32': 'i386'
+    };
+    
+    return {
+        os: platformMap[platform] || platform,
+        arch: archMap[arch] || arch,
+        platform,
+        architecture: arch
+    };
+}
+
+// Get releases for a repository
+async function getRepositoryReleases(owner, repo) {
+    try {
+        const response = await axios.get(`https://api.github.com/repos/${owner}/${repo}/releases`, {
+            headers: TOKEN ? { Authorization: `token ${TOKEN}` } : {},
+            params: { per_page: 5 } // Get latest 5 releases
+        });
+        return response.data;
+    } catch (error) {
+        return [];
+    }
+}
+
+// Categorize releases by platform
+function categorizeReleasesByPlatform(releases) {
+    const platformKeywords = {
+        windows: ['win', 'windows', 'win32', 'win64', '.exe', '.msi'],
+        macos: ['mac', 'macos', 'darwin', 'osx', '.dmg', '.pkg'],
+        linux: ['linux', 'ubuntu', 'debian', '.deb', '.rpm', '.tar.gz', '.AppImage']
+    };
+    
+    const archKeywords = {
+        x86_64: ['x86_64', 'x64', 'amd64', '64'],
+        arm64: ['arm64', 'aarch64'],
+        arm: ['arm', 'armv7'],
+        i386: ['i386', 'x86', '32']
+    };
+    
+    const categorizedReleases = [];
+    
+    releases.forEach(release => {
+        const platformAssets = {
+            windows: [],
+            macos: [],
+            linux: [],
+            universal: []
+        };
+        
+        release.assets.forEach(asset => {
+            const name = asset.name.toLowerCase();
+            let categorized = false;
+            
+            // Check each platform
+            Object.entries(platformKeywords).forEach(([platform, keywords]) => {
+                if (keywords.some(keyword => name.includes(keyword.toLowerCase()))) {
+                    // Determine architecture
+                    let detectedArch = 'unknown';
+                    Object.entries(archKeywords).forEach(([arch, archKeys]) => {
+                        if (archKeys.some(archKey => name.includes(archKey.toLowerCase()))) {
+                            detectedArch = arch;
+                        }
+                    });
+                    
+                    platformAssets[platform].push({
+                        ...asset,
+                        detectedArch,
+                        platform
+                    });
+                    categorized = true;
+                }
+            });
+            
+            // If not categorized, check for universal binaries
+            if (!categorized && (name.includes('universal') || name.includes('all') || 
+                              (!name.includes('win') && !name.includes('mac') && !name.includes('linux')))) {
+                platformAssets.universal.push({
+                    ...asset,
+                    detectedArch: 'universal',
+                    platform: 'universal'
+                });
+            }
+        });
+        
+        // Only include releases that have assets
+        const hasAssets = Object.values(platformAssets).some(assets => assets.length > 0);
+        if (hasAssets) {
+            categorizedReleases.push({
+                ...release,
+                platformAssets
+            });
+        }
+    });
+    
+    return categorizedReleases;
+}
+
+// Filter releases for current platform (for compatibility indicator)
+function filterReleasesByPlatform(releases, currentPlatform) {
+    const categorized = categorizeReleasesByPlatform(releases);
+    return categorized.filter(release => 
+        release.platformAssets[currentPlatform.os].length > 0 ||
+        release.platformAssets.universal.length > 0
+    );
+}
+
+// Download and install package
+async function downloadPackage(asset, targetDir) {
+    const fileName = asset.name;
+    const downloadPath = path.join(targetDir, fileName);
+    
+    console.log(chalk.blue(`📦 Downloading ${fileName}...`));
+    
+    try {
+        const response = await axios({
+            url: asset.browser_download_url,
+            method: 'GET',
+            responseType: 'stream',
+            headers: TOKEN ? { Authorization: `token ${TOKEN}` } : {}
+        });
+        
+        const writer = fs.createWriteStream(downloadPath);
+        await pipeline(response.data, writer);
+        
+        console.log(chalk.green(`✅ Downloaded ${fileName} to ${downloadPath}`));
+        
+        // Try to make executable if it's a binary
+        if (process.platform !== 'win32' && !fileName.includes('.')) {
+            try {
+                fs.chmodSync(downloadPath, '755');
+                console.log(chalk.green(`✅ Made ${fileName} executable`));
+            } catch (error) {
+                console.log(chalk.yellow(`⚠️  Could not make ${fileName} executable`));
+            }
+        }
+        
+        // Provide installation instructions
+        provideInstallationInstructions(downloadPath, asset);
+        
+    } catch (error) {
+        console.error(chalk.red(`❌ Failed to download ${fileName}:`), error.message);
+    }
+}
+
+// Provide platform-specific installation instructions
+function provideInstallationInstructions(filePath, asset) {
+    const fileName = asset.name;
+    const platform = getCurrentPlatform();
+    
+    console.log(chalk.cyan('\n📋 Installation Instructions:'));
+    
+    if (platform.platform === 'win32') {
+        if (fileName.endsWith('.exe')) {
+            console.log(chalk.white('  Run the executable:'));
+            console.log(chalk.gray(`  ${filePath}`));
+        } else if (fileName.endsWith('.msi')) {
+            console.log(chalk.white('  Install the MSI package:'));
+            console.log(chalk.gray(`  msiexec /i "${filePath}"`));
+        }
+    } else if (platform.platform === 'darwin') {
+        if (fileName.endsWith('.dmg')) {
+            console.log(chalk.white('  Mount and install the DMG:'));
+            console.log(chalk.gray(`  open "${filePath}"`));
+        } else if (fileName.endsWith('.pkg')) {
+            console.log(chalk.white('  Install the package:'));
+            console.log(chalk.gray(`  sudo installer -pkg "${filePath}" -target /`));
+        }
+    } else {
+        if (fileName.endsWith('.deb')) {
+            console.log(chalk.white('  Install the DEB package:'));
+            console.log(chalk.gray(`  sudo dpkg -i "${filePath}"`));
+        } else if (fileName.endsWith('.rpm')) {
+            console.log(chalk.white('  Install the RPM package:'));
+            console.log(chalk.gray(`  sudo rpm -i "${filePath}"`));
+        } else if (fileName.endsWith('.AppImage')) {
+            console.log(chalk.white('  Run the AppImage:'));
+            console.log(chalk.gray(`  chmod +x "${filePath}" && "${filePath}"`));
+        } else if (!fileName.includes('.')) {
+            console.log(chalk.white('  Binary is ready to use:'));
+            console.log(chalk.gray(`  "${filePath}"`));
+            console.log(chalk.white('  Consider moving to PATH:'));
+            console.log(chalk.gray(`  sudo mv "${filePath}" /usr/local/bin/`));
+        }
+    }
+}
+
+// Show package selection menu organized by platform
+async function showPackageMenu(selectedRepo) {
+    const currentPlatform = getCurrentPlatform();
+    const releaseChoices = [];
+    
+    // Add section headers and organize by platform
+    selectedRepo.allReleases.forEach(release => {
+        const platforms = ['windows', 'macos', 'linux', 'universal'];
+        
+        platforms.forEach(platform => {
+            const assets = release.platformAssets[platform];
+            if (assets.length > 0) {
+                // Add platform header
+                const platformEmoji = {
+                    windows: '🪟',
+                    macos: '🍎', 
+                    linux: '🐧',
+                    universal: '🌐'
+                };
+                
+                const platformName = {
+                    windows: 'Windows',
+                    macos: 'macOS',
+                    linux: 'Linux',
+                    universal: 'Universal'
+                };
+                
+                const isCurrentPlatform = platform === currentPlatform.os || platform === 'universal';
+                const platformHeader = isCurrentPlatform 
+                    ? chalk.green(`${platformEmoji[platform]} ${platformName[platform]} (Your Platform)`)
+                    : chalk.gray(`${platformEmoji[platform]} ${platformName[platform]}`);
+                
+                // Add separator if not first platform in this release
+                const needsSeparator = releaseChoices.length > 0 && 
+                    !releaseChoices[releaseChoices.length - 1].name.includes('────');
+                
+                if (needsSeparator) {
+                    releaseChoices.push({
+                        name: chalk.gray('────────────────────────────────'),
+                        disabled: true
+                    });
+                }
+                
+                releaseChoices.push({
+                    name: `${chalk.bold(release.tag_name)} - ${platformHeader}`,
+                    disabled: true
+                });
+                
+                // Add assets for this platform
+                assets.forEach(asset => {
+                    const sizeStr = (asset.size / 1024 / 1024).toFixed(2);
+                    const archInfo = asset.detectedArch !== 'unknown' && asset.detectedArch !== 'universal' 
+                        ? chalk.cyan(`[${asset.detectedArch}]`) 
+                        : '';
+                    
+                    const highlight = isCurrentPlatform ? chalk.white : chalk.gray;
+                    
+                    releaseChoices.push({
+                        name: `  ${highlight(`${asset.name} ${archInfo} (${sizeStr} MB)`)}`,
+                        value: { release, asset }
+                    });
+                });
+            }
+        });
+    });
+
+    if (releaseChoices.filter(choice => !choice.disabled).length === 0) {
+        console.log(chalk.yellow('No packages found for download.'));
+        return;
+    }
+
+    const { selectedPackage } = await inquirer.prompt({
+        type: 'list',
+        name: 'selectedPackage',
+        message: 'Select a package to download:',
+        choices: releaseChoices,
+        pageSize: 15
+    });
+
+    const downloadDir = path.resolve(process.cwd(), 'downloads');
+    fs.mkdirSync(downloadDir, { recursive: true });
+    await downloadPackage(selectedPackage.asset, downloadDir);
+}
+
 function getIdeCommand() {
     const ides = [
         { name: 'Cursor', cmd: 'cursor' },
@@ -58,7 +343,6 @@ export function openInIDE(targetDir) {
             shell: process.platform === 'win32'
         }).unref();
 
-
         const args2 = ide.cmd === 'code-server'
         ? ['./readme.md', '--open']
         : ['./README.md'];
@@ -89,7 +373,6 @@ export async function installDependencies(targetDir) {
 
     // Install commands for each project type
     const installers = {
-
         nodejs: () => {
             try {
                 execSync(
@@ -144,6 +427,7 @@ function runCommand(cmd) {
         console.error(chalk.red(`❌ Failed: ${cmd}`));
     }
 }
+
 export async function searchRepositories(query) {
     try {
         const response = await axios.get(GITHUB_API, {
@@ -155,12 +439,32 @@ export async function searchRepositories(query) {
             },
             headers: TOKEN ? { Authorization: `token ${TOKEN}` } : {}
         });
-        return response.data.items;
+        
+        // Check for releases for each repository
+        const reposWithReleases = await Promise.all(
+            response.data.items.map(async (repo) => {
+                const releases = await getRepositoryReleases(repo.owner.login, repo.name);
+                const currentPlatform = getCurrentPlatform();
+                const compatibleReleases = filterReleasesByPlatform(releases, currentPlatform);
+                const categorizedReleases = categorizeReleasesByPlatform(releases);
+                
+                return {
+                    ...repo,
+                    hasReleases: releases.length > 0,
+                    hasCompatibleReleases: compatibleReleases.length > 0,
+                    releases: compatibleReleases,
+                    allReleases: categorizedReleases
+                };
+            })
+        );
+        
+        return reposWithReleases;
     } catch (error) {
         console.error(chalk.red('Search failed:'), error.response?.data?.message || error.message);
         process.exit(1);
     }
 }
+
 export async function downloadRepo(repo) {
     const parsed = gitUrlParse(`https://github.com/${repo}`);
     const defaultDir = path.resolve(process.cwd(), parsed.name);
@@ -168,24 +472,20 @@ export async function downloadRepo(repo) {
 
     fs.mkdirSync(extractPath, { recursive: true });
     console.log(chalk.blue(`📦 Downloading ${parsed.full_name} into ${path.basename(extractPath)}...`));
-    let url = `${parsed.owner}/${parsed.name}/tarball/${parsed.default_branch || 'main'}`;
-
-    fs.mkdirSync(extractPath, { recursive: true });
-    console.log(chalk.blue(`📦 Downloading ${parsed.full_name} into ${repo.name}...`));
+    let url = `https://api.github.com/repos/${parsed.owner}/${parsed.name}/tarball/${parsed.default_branch || 'main'}`;
 
-    console.log(url);
     try {
         let response;
-        try{ 
-            response= await axios({
-            url,
-            method: 'GET',
-            responseType: 'stream',
-            headers: TOKEN ? { Authorization: `token ${TOKEN}` } : {}
-        });
+        try { 
+            response = await axios({
+                url,
+                method: 'GET',
+                responseType: 'stream',
+                headers: TOKEN ? { Authorization: `token ${TOKEN}` } : {}
+            });
         } catch (error) {
-            url = url.replace("/main", "/master")
-            response= await axios({
+            url = url.replace("/main", "/master");
+            response = await axios({
                 url,
                 method: 'GET',
                 responseType: 'stream',
@@ -204,7 +504,7 @@ export async function downloadRepo(repo) {
         setTimeout(() => {
             openInIDE(extractPath);
         }, 1000);
-        installDependencies(extractPath); // Add this line
+        installDependencies(extractPath);
     } catch (error) {
         console.error(chalk.red('Download failed:'), error.message);
         process.exit(1);
@@ -230,6 +530,9 @@ async function main() {
     }
 
     const query = args.join(' ');
+    const currentPlatform = getCurrentPlatform();
+    
+    console.log(chalk.gray(`🖥️  Detected platform: ${currentPlatform.os} ${currentPlatform.arch}`));
 
     let repoUrl = null;
 
@@ -243,11 +546,7 @@ async function main() {
         parsed = gitUrlParse(`https://github.com/${query}`);
     }
 
-
     if (parsed && parsed.owner && parsed.name) {
-        // Reconstruct the canonical HTTPS URL for download
-        // repoUrl = `https://github.com/${parsed.owner}/${parsed.name}`;
-        // console.log(chalk.green(`Detected GitHub repo: ${repoUrl}`));
         await downloadRepo(parsed.href);
         return;
     }
@@ -263,14 +562,45 @@ async function main() {
         type: 'list',
         name: 'selectedRepo',
         message: 'Select a repository to download:',
-        choices: results.map(repo => ({
-            name: `${chalk.bold(repo.full_name)} - ${chalk.gray(repo.description || 'No description')}
-      ${chalk.yellow(`★ ${repo.stargazers_count}`)} | ${chalk.blue(repo.language || 'Unknown')}`,
-            value: repo
-        }))
+        choices: results.map(repo => {
+            const packageInfo = repo.hasCompatibleReleases 
+                ? chalk.green(' 📦 Packages available') 
+                : repo.hasReleases 
+                    ? chalk.yellow(' 📦 Packages (other platforms)') 
+                    : '';
+            
+            return {
+                name: `${chalk.bold(repo.full_name)} - ${chalk.gray(repo.description || 'No description')}
+      ${chalk.yellow(`★ ${repo.stargazers_count}`)} | ${chalk.blue(repo.language || 'Unknown')}${packageInfo}`,
+                value: repo
+            };
+        })
     });
 
-    await downloadRepo(selectedRepo.url);
+    // If the selected repo has any releases, show download options
+    if (selectedRepo.hasReleases) {
+        const { downloadChoice } = await inquirer.prompt({
+            type: 'list',
+            name: 'downloadChoice',
+            message: 'This repository has downloadable packages. What would you like to do?',
+            choices: [
+                { name: '📦 Download package/binary', value: 'package' },
+                { name: '📂 Download source code', value: 'source' },
+                { name: '📦📂 Download both package and source', value: 'both' }
+            ]
+        });
+
+        if (downloadChoice === 'package' || downloadChoice === 'both') {
+            await showPackageMenu(selectedRepo);
+        }
+
+        if (downloadChoice === 'source' || downloadChoice === 'both') {
+            await downloadRepo(selectedRepo.html_url);
+        }
+    } else {
+        // No packages, just download source
+        await downloadRepo(selectedRepo.html_url);
+    }
 }
 
-main();
+main();

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "git0",
-    "version": "0.1.4",
+    "version": "0.1.6",
     "description": "A CLI manager for downloading GitHub repos.",
     "author": "vtempest",
     "license": "MIT",
@@ -22,6 +22,7 @@
     },
     "type": "module",
     "bin": {
-        "gg": "./gg.js"
+        "gg": "./gg.js",
+        "git0": "./gg.js"
     }
 }

package/readme.md

@@ -1,5 +1,5 @@
 <p align="center">
-    <img  src="https://i.imgur.com/zG1QI1q.png" />
+    <img  src="https://i.imgur.com/poOtI3N.png" />
 </p>
 <p align="center">
     <a href="https://discord.gg/SJdBqBz3tV">
@@ -26,7 +26,7 @@
 </p>  
 
 
-# GG - GitHub Repo Downloader
+# Git0: GitHub Zero-Step Repo Downloader
 
 A fast and smart CLI tool to search, download, and instantly set up GitHub repositories with automatic dependency installation and IDE integration.
 
@@ -34,11 +34,11 @@ A fast and smart CLI tool to search, download, and instantly set up GitHub repos
 ## 🚀 Installation
 
 ```bash
-npm install -g git-gg
+npm install -g git0
 ```
 
 ```bash
-bun install -g git-gg
+bun install -g git0
 ```
 
 ![preview](https://i.imgur.com/K22NiBq.png)
@@ -65,10 +65,11 @@ gg react starter
 gg https://github.com/facebook/react
 
 # Download using owner/repo shorthand
-gg facebook/react
+## gg and git0 both work
+git0 facebook/react
 
 ## Use without installing
-npx git-gg react starter
+npx git0 react starter
 ```
 
 ### Supported Project Types