pluck-cli 0.2.1__tar.gz → 0.3.2__tar.gz

{pluck_cli-0.2.1/src/pluck_cli.egg-info → pluck_cli-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pluck-cli
-Version: 0.2.1
+Version: 0.3.2
 Summary: Pluck any git repo from any forge — auto-detect, auto-install, done!
 Author: pluck contributors
 License: MIT
@@ -175,7 +175,11 @@ Any git hosting platform that follows the standard `host/owner/repo` URL pattern
 | `stats` | Show statistics | `pluck stats` |
 | `doctor` | Check tool availability | `pluck doctor` |
 | `config [key] [val]` | View/set config | `pluck config install_dir ~/Apps` |
-| `search <query> [--forge <name>]` | Search repos (github\|gitlab\|codeberg\|bitbucket) | `pluck search python installer --forge gitlab` |
+| `search <query> [--forge <name>] [--all] [--output <file>]` | Search repos across forges | `pluck search python installer --all --output results.txt` |
+| `pin <name>` | Pin an app to prevent updates | `pluck pin myapp` |
+| `unpin <name>` | Unpin an app | `pluck unpin myapp` |
+| `self-update` | Update pluck itself | `pluck self-update` |
+| `cache prune` | Clear download cache | `pluck cache prune` |
 | `export <file>` | Export registry | `pluck export ~/backup.json` |
 | `import <file>` | Import registry | `pluck import ~/backup.json` |
 | `completion <shell>` | Generate shell completion | `pluck completion bash` |
@@ -197,6 +201,8 @@ Any git hosting platform that follows the standard `host/owner/repo` URL pattern
 | `--no-color` | Disable colored output |
 | `--timeout <secs>` | Timeout for git clone in seconds |
 | `--retries <n>` | Number of retries for failed git clone |
+| `--jobs <n>` | Number of parallel installs (default: 1) |
+| `--release` | Install from pre-built release assets instead of cloning |
 | `--verbose` | Show detailed git clone output |
 
 ## 📥 Installation

{pluck_cli-0.2.1 → pluck_cli-0.3.2}/README.md

@@ -150,7 +150,11 @@ Any git hosting platform that follows the standard `host/owner/repo` URL pattern
 | `stats` | Show statistics | `pluck stats` |
 | `doctor` | Check tool availability | `pluck doctor` |
 | `config [key] [val]` | View/set config | `pluck config install_dir ~/Apps` |
-| `search <query> [--forge <name>]` | Search repos (github\|gitlab\|codeberg\|bitbucket) | `pluck search python installer --forge gitlab` |
+| `search <query> [--forge <name>] [--all] [--output <file>]` | Search repos across forges | `pluck search python installer --all --output results.txt` |
+| `pin <name>` | Pin an app to prevent updates | `pluck pin myapp` |
+| `unpin <name>` | Unpin an app | `pluck unpin myapp` |
+| `self-update` | Update pluck itself | `pluck self-update` |
+| `cache prune` | Clear download cache | `pluck cache prune` |
 | `export <file>` | Export registry | `pluck export ~/backup.json` |
 | `import <file>` | Import registry | `pluck import ~/backup.json` |
 | `completion <shell>` | Generate shell completion | `pluck completion bash` |
@@ -172,6 +176,8 @@ Any git hosting platform that follows the standard `host/owner/repo` URL pattern
 | `--no-color` | Disable colored output |
 | `--timeout <secs>` | Timeout for git clone in seconds |
 | `--retries <n>` | Number of retries for failed git clone |
+| `--jobs <n>` | Number of parallel installs (default: 1) |
+| `--release` | Install from pre-built release assets instead of cloning |
 | `--verbose` | Show detailed git clone output |
 
 ## 📥 Installation

{pluck_cli-0.2.1 → pluck_cli-0.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pluck-cli"
-version = "0.2.1"
+version = "0.3.2"
 description = "Pluck any git repo from any forge — auto-detect, auto-install, done!"
 readme = "README.md"
 license = {text = "MIT"}

{pluck_cli-0.2.1 → pluck_cli-0.3.2}/src/gh_install.py

@@ -5,6 +5,7 @@ GitHub App Installer - Paste URL, Auto-Install, Done!
 
 from __future__ import annotations
 
+import concurrent.futures
 import json
 import os
 import re
@@ -18,7 +19,7 @@ import urllib.request
 from datetime import datetime
 from pathlib import Path
 
-__version__ = "0.2.1"
+__version__ = "0.3.2"
 
 # Configuration
 DEFAULT_INSTALL_DIR_MACOS = Path.home() / "Applications"
@@ -33,13 +34,14 @@ CONFIG_FILE = (
     Path(os.environ.get("XDG_CONFIG_HOME", Path.home() / ".config")) / "pluck" / "config.json"
 )
 _CONFIG_OLD_DIR = Path.home() / ".config" / "gh-install"
+CACHE_DIR = Path.home() / ".cache" / "pluck"
 SHARED_PATHS = {
     Path.home() / "go" / "bin",
     Path.home() / "Applications",
     Path.home() / ".local" / "opt",
     Path.home() / "bin",
 }
-VALID_METHODS = {"script", "binary", "python", "node", "go", "rust", "make", "download"}
+VALID_METHODS = {"script", "binary", "python", "node", "go", "rust", "make", "download", "release"}
 GIST_PATTERN = r"gist\.github\.com[:/]([^/]+)/([a-f0-9]+)"
 # GitLab personal snippet: gitlab.com/-/snippets/12345
 # GitLab project snippet: gitlab.com/owner/repo/-/snippets/12345
@@ -88,10 +90,15 @@ def print_usage():
         ("stats", "Show installation statistics"),
         ("doctor", "Check tool availability"),
         ("config [key] [value]", "View/set config"),
-        ("search <query> [--forge <name>]", "Search repos (github|gitlab|codeberg|bitbucket)"),
+        ("search <query> [--forge <name>] [--all] [--output <file>]",
+         "Search repos (github|gitlab|codeberg|bitbucket)"),
         ("export <file>", "Export registry"),
         ("import <file>", "Import registry"),
         ("completion <shell>", "Generate shell completion"),
+        ("pin <name>", "Pin an app to prevent updates"),
+        ("unpin <name>", "Unpin an app"),
+        ("self-update", "Update pluck itself"),
+        ("cache <prune|path>", "Manage download cache"),
         ("version", "Show version"),
         ("help", "Show this help"),
     ]
@@ -107,6 +114,7 @@ def print_usage():
         ("--no-color", "Disable colored output"),
         ("--timeout <secs>", "Timeout for git clone in seconds"),
         ("--retries <n>", "Number of retries for failed git clone"),
+        ("--jobs <n>", "Number of parallel installs (default: 1)"),
         ("--verbose", "Show detailed git clone output"),
     ]
 
@@ -462,12 +470,15 @@ def install_python(repo_path, install_dir):
 
     try:
         app_dir = install_dir / repo_path.name
+        ignore = shutil.ignore_patterns(".git", "__pycache__", ".venv", "venv")
+        shutil.copytree(repo_path, app_dir, dirs_exist_ok=True, ignore=ignore)
+
         venv_path = app_dir / ".venv"
         venv_path.parent.mkdir(parents=True, exist_ok=True)
         subprocess.run([sys.executable, "-m", "venv", str(venv_path)], check=True)
 
         pip_path = venv_path / "bin" / "pip"
-        subprocess.run([str(pip_path), "install", "-e", str(repo_path)], check=True)
+        subprocess.run([str(pip_path), "install", "-e", str(app_dir)], check=True)
 
         print_success(f"Installed to {app_dir}")
 
@@ -647,6 +658,14 @@ def download_and_install(
         else:
             install_dir = DEFAULT_INSTALL_DIR
 
+    # Check if this is a local path instead of a URL
+    local_candidate = Path(repo_url).expanduser()
+    if local_candidate.exists():
+        return _install_local_path(
+            repo_url, install_dir,
+            dry_run=dry_run, method_override=method_override,
+        )
+
     # Parse repository URL
     repo_info = parse_repo_url(repo_url)
     if not repo_info:
@@ -663,6 +682,25 @@ def download_and_install(
         print_error(f"Invalid repository name: {repo_info['repo']}")
         return None
 
+    # If release method requested, skip cloning and try release assets
+    if method_override == "release":
+        if dry_run:
+            print(f"  [DRY RUN] Would install release assets for: {repo_info['owner']}/{repo_info['repo']}")
+            return install_dir / safe_name
+        install_dir.mkdir(parents=True, exist_ok=True)
+        print("  Attempting release asset install...")
+        installed_path = install_release_asset(repo_info, install_dir)
+        if installed_path:
+            register_app(repo_info["repo"], repo_url, installed_path, "release")
+            print()
+            print(f"  {Colors.CYAN}Summary:{Colors.END}")
+            print(f"    Name:     {repo_info['repo']}")
+            print("    Method:   release")
+            print(f"    Location: {installed_path}")
+            print(f"    Size:     {_get_disk_size(installed_path)}")
+            return installed_path
+        print_warning("Release asset install failed, falling back to clone...")
+
     # Dry-run check before doing any I/O
     if dry_run:
         print(f"  [DRY RUN] Would install to: {install_dir / safe_name}")
@@ -732,10 +770,11 @@ def download_and_install(
     }
 
     install_func = install_funcs.get(install_method, install_binary)
-    installed_path = install_func(repo_path, install_dir)
-
-    # Clean up temp directory
-    shutil.rmtree(temp_dir)
+    try:
+        installed_path = install_func(repo_path, install_dir)
+    finally:
+        # Clean up temp directory
+        shutil.rmtree(temp_dir, ignore_errors=True)
 
     # Register the installation
     if installed_path:
@@ -773,6 +812,12 @@ def update_app(
     url = app_info["url"]
     old_path = Path(app_info["path"])
 
+    # Check if app is pinned
+    if app_info.get("pinned", False):
+        print_warning(f"{repo_name} is pinned — skipping update")
+        print("  Use 'pluck unpin' first, or --force to override")
+        return True
+
     print_header(f"Updating {repo_name}")
     print(f"  Current: {app_info['installed_at']}")
     print(f"  URL: {url}")
@@ -783,7 +828,12 @@ def update_app(
         return True
 
     # Remove old installation
-    if old_path.exists() and old_path.resolve() not in SHARED_PATHS:
+    resolved_shared_paths = {p.resolve() for p in SHARED_PATHS}
+    if (
+        old_path.exists()
+        and old_path.resolve() not in resolved_shared_paths
+        and old_path.resolve() != Path.home().resolve()
+    ):
         if old_path.is_file():
             old_path.unlink()
         else:
@@ -829,11 +879,13 @@ def info_app(repo_name, json_output=False):
     app_info = registry["apps"][repo_name]
     install_path = Path(app_info["path"])
 
+    pinned = app_info.get("pinned", False)
     if json_output:
         data = {
             "name": repo_name,
             "url": app_info["url"],
             "method": app_info["method"],
+            "pinned": pinned,
             "path": app_info["path"],
             "installed_at": app_info["installed_at"],
             "size": _get_disk_size(install_path),
@@ -843,11 +895,12 @@ def info_app(repo_name, json_output=False):
         return True
 
     print_header(f"App Info: {repo_name}")
-    labels = ["URL", "Method", "Path", "Installed", "Size", "Exists"]
+    labels = ["URL", "Method", "Path", "Pinned", "Installed", "Size", "Exists"]
     values = [
         app_info["url"],
         app_info["method"],
         app_info["path"],
+        "Yes" if pinned else "No",
         app_info["installed_at"],
         _get_disk_size(install_path),
         "Yes" if install_path.exists() else "No (files may have been moved)",
@@ -879,7 +932,6 @@ def doctor(json_output=False):
         if not found and exe == "python3":
             found = bool(shutil.which("python"))
         results.append({"tool": tool, "required": req, "found": found, "purpose": purpose})
-        results.append({"tool": tool, "required": req, "found": found, "purpose": purpose})
         if not found and req == "Required":
             all_ok = False
 
@@ -943,8 +995,10 @@ def _search_print_result(index, name, desc, stars, lang, url, star_char="★"):
     print()
 
 
-def search_github(query, limit=10):
-    """Search repositories using the GitHub API."""
+def search_github(query, limit=10, results=None):
+    """Search repositories using the GitHub API.
+    If results (list) is provided, appends result dicts instead of printing.
+    """
     print(f"  Searching GitHub for '{query}'...")
     url = f"https://api.github.com/search/repositories?q={urllib.parse.quote(query)}&sort=stars&order=desc&per_page={limit}"
     try:
@@ -960,19 +1014,29 @@ def search_github(query, limit=10):
         print_warning("No results found")
         return
 
-    print_header(f"GitHub Results — '{query}' ({len(items)} found)")
-    for i, repo in enumerate(items, 1):
-        _search_print_result(
-            i,
-            repo["full_name"],
-            repo.get("description") or "No description",
-            repo["stargazers_count"],
-            repo.get("language") or "Unknown",
-            repo["html_url"],
-        )
+    if results is not None:
+        for i, repo in enumerate(items, 1):
+            results.append({
+                "index": i, "name": repo["full_name"],
+                "description": repo.get("description") or "No description",
+                "stars": repo["stargazers_count"],
+                "language": repo.get("language") or "Unknown",
+                "url": repo["html_url"],
+            })
+    else:
+        print_header(f"GitHub Results — '{query}' ({len(items)} found)")
+        for i, repo in enumerate(items, 1):
+            _search_print_result(
+                i,
+                repo["full_name"],
+                repo.get("description") or "No description",
+                repo["stargazers_count"],
+                repo.get("language") or "Unknown",
+                repo["html_url"],
+            )
 
 
-def search_gitlab(query, limit=10):
+def search_gitlab(query, limit=10, collector=None):
     """Search repositories using the GitLab API."""
     print(f"  Searching GitLab for '{query}'...")
     url = f"https://gitlab.com/api/v4/projects?search={urllib.parse.quote(query)}&per_page={limit}&order_by=stars&sort=desc"
@@ -1003,12 +1067,23 @@ def search_gitlab(query, limit=10):
 
     results.sort(key=lambda r: r["stars"], reverse=True)
 
-    print_header(f"GitLab Results — '{query}' ({len(results)} found)")
-    for i, r in enumerate(results[:limit], 1):
-        _search_print_result(i, r["name"], r["description"], r["stars"], r["language"], r["url"], star_char="\u2605")
+    if collector is not None:
+        for i, r in enumerate(results[:limit], 1):
+            collector.append({
+                "index": i, "name": r["name"],
+                "description": r["description"],
+                "stars": r["stars"],
+                "language": r["language"],
+                "url": r["url"],
+            })
+    else:
+        print_header(f"GitLab Results — '{query}' ({len(results)} found)")
+        for i, r in enumerate(results[:limit], 1):
+            _search_print_result(i, r["name"], r["description"],
+                                 r["stars"], r["language"], r["url"], star_char="\u2605")
 
 
-def search_codeberg(query, limit=10):
+def search_codeberg(query, limit=10, results=None):
     """Search repositories using the Codeberg (Gitea/Forgejo) API."""
     print(f"  Searching Codeberg for '{query}'...")
     url = f"https://codeberg.org/api/v1/repos/search?q={urllib.parse.quote(query)}&limit={limit}&sort=stars"
@@ -1030,19 +1105,29 @@ def search_codeberg(query, limit=10):
         print_warning("No results found")
         return
 
-    print_header(f"Codeberg Results — '{query}' ({len(items)} found)")
-    for i, repo in enumerate(items, 1):
-        _search_print_result(
-            i,
-            repo.get("full_name", "unknown"),
-            repo.get("description") or "No description",
-            repo.get("stars_count", 0),
-            repo.get("language") or "Unknown",
-            repo.get("html_url", ""),
-        )
+    if results is not None:
+        for i, repo in enumerate(items, 1):
+            results.append({
+                "index": i, "name": repo.get("full_name", "unknown"),
+                "description": repo.get("description") or "No description",
+                "stars": repo.get("stars_count", 0),
+                "language": repo.get("language") or "Unknown",
+                "url": repo.get("html_url", ""),
+            })
+    else:
+        print_header(f"Codeberg Results — '{query}' ({len(items)} found)")
+        for i, repo in enumerate(items, 1):
+            _search_print_result(
+                i,
+                repo.get("full_name", "unknown"),
+                repo.get("description") or "No description",
+                repo.get("stars_count", 0),
+                repo.get("language") or "Unknown",
+                repo.get("html_url", ""),
+            )
 
 
-def search_bitbucket(query, limit=10):
+def search_bitbucket(query, limit=10, results=None):
     """Search repositories using the Bitbucket Cloud API."""
     print(f"  Searching Bitbucket for '{query}'...")
     url = f"https://api.bitbucket.org/2.0/repositories?q=name~\"{urllib.parse.quote(query)}\"&sort=-updated_on"
@@ -1059,13 +1144,23 @@ def search_bitbucket(query, limit=10):
         print_warning("No results found")
         return
 
-    print_header(f"Bitbucket Results — '{query}' ({len(items)} found)")
-    for i, repo in enumerate(items, 1):
-        full_name = repo.get("full_name", "unknown")
-        desc = repo.get("description") or "No description"
-        lang = repo.get("language") or "Unknown"
-        url = repo.get("links", {}).get("html", {}).get("href", "")
-        _search_print_result(i, full_name, desc, 0, lang, url, star_char="\u2022")
+    if results is not None:
+        for i, repo in enumerate(items, 1):
+            results.append({
+                "index": i, "name": repo.get("full_name", "unknown"),
+                "description": repo.get("description") or "No description",
+                "stars": 0,
+                "language": repo.get("language") or "Unknown",
+                "url": repo.get("links", {}).get("html", {}).get("href", ""),
+            })
+    else:
+        print_header(f"Bitbucket Results — '{query}' ({len(items)} found)")
+        for i, repo in enumerate(items, 1):
+            full_name = repo.get("full_name", "unknown")
+            desc = repo.get("description") or "No description"
+            lang = repo.get("language") or "Unknown"
+            url = repo.get("links", {}).get("html", {}).get("href", "")
+            _search_print_result(i, full_name, desc, 0, lang, url, star_char="\u2022")
 
 
 def export_registry(filepath):
@@ -1114,6 +1209,7 @@ def register_app(repo_name, repo_url, install_path, install_method, skip_hook=Fa
         "url": repo_url,
         "path": str(install_path),
         "method": install_method,
+        "pinned": False,
         "installed_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
     }
 
@@ -1243,7 +1339,9 @@ def list_installed(json_output=False):
         install_path = Path(info["path"])
         size = _get_disk_size(install_path)
         exists = "✓" if install_path.exists() else "✗"
-        print(f"\n{Colors.GREEN}{name}{Colors.END}  [{exists}]")
+        pinned = info.get("pinned", False)
+        pin_tag = f" {Colors.YELLOW}[PINNED]{Colors.END}" if pinned else ""
+        print(f"\n{Colors.GREEN}{name}{Colors.END}{pin_tag}  [{exists}]")
         print(f"  URL: {info['url']}")
         print(f"  Method: {info['method']}")
         print(f"  Path: {info['path']}")
@@ -1270,7 +1368,8 @@ def uninstall_app(repo_name, force=False):
 
     # Remove installed files — but never delete shared system directories
     install_path = Path(app_info["path"])
-    if install_path.resolve() in SHARED_PATHS or install_path.resolve() == Path.home():
+    resolved_shared_paths = {p.resolve() for p in SHARED_PATHS}
+    if install_path.resolve() in resolved_shared_paths or install_path.resolve() == Path.home().resolve():
         print_error(f"Refusing to uninstall: {install_path} is a shared directory")
         print_warning("Remove files from this directory manually instead")
         return False
@@ -1303,6 +1402,7 @@ def _parse_args(args):
     verbose = False
     timeout = None
     retries = 0
+    jobs = 1
     urls = []
 
     i = 0
@@ -1349,6 +1449,12 @@ def _parse_args(args):
             except ValueError:
                 pass
             i += 2
+        elif args[i] == "--jobs" and i + 1 < len(args):
+            try:
+                jobs = max(1, int(args[i + 1]))
+            except ValueError:
+                pass
+            i += 2
         else:
             urls.append(args[i])
             i += 1
@@ -1358,7 +1464,8 @@ def _parse_args(args):
     if no_color:
         _enable_colors(False)
 
-    return install_dir, dry_run, force, shallow, ref, method, json_output, verbose, no_color, timeout, retries, urls
+    return (install_dir, dry_run, force, shallow, ref, method, json_output,
+            verbose, no_color, timeout, retries, jobs, urls)
 
 
 def verify_apps(json_output=False):
@@ -1511,6 +1618,328 @@ def _migrate_old_registry():
             pass
 
 
+# ── Pin / Unpin ──
+
+
+def pin_app(repo_name):
+    """Pin an app to prevent updates."""
+    registry = load_registry()
+    if repo_name not in registry["apps"]:
+        print_error(f"{repo_name} is not installed")
+        return False
+    registry["apps"][repo_name]["pinned"] = True
+    save_registry(registry)
+    print_success(f"Pinned {repo_name}")
+    return True
+
+
+def unpin_app(repo_name):
+    """Unpin an app."""
+    registry = load_registry()
+    if repo_name not in registry["apps"]:
+        print_error(f"{repo_name} is not installed")
+        return False
+    registry["apps"][repo_name]["pinned"] = False
+    save_registry(registry)
+    print_success(f"Unpinned {repo_name}")
+    return True
+
+
+# ── Cache Management ──
+
+
+def cache_command(action):
+    """Manage the download cache."""
+    if action == "prune":
+        if not CACHE_DIR.exists():
+            print_success("Cache is already empty")
+            return True
+        total = 0
+        for entry in CACHE_DIR.iterdir():
+            if entry.is_file():
+                total += entry.stat().st_size
+                entry.unlink()
+            elif entry.is_dir():
+                total += sum(f.stat().st_size for f in entry.rglob("*") if f.is_file())
+                shutil.rmtree(entry, ignore_errors=True)
+        CACHE_DIR.rmdir() if CACHE_DIR.exists() else None
+        print_success(f"Cleared cache ({_format_bytes(total)})")
+        return True
+    elif action == "path":
+        CACHE_DIR.mkdir(parents=True, exist_ok=True)
+        print(CACHE_DIR)
+        return True
+    else:
+        print_error(f"Unknown cache action: {action} (try: prune, path)")
+        return False
+
+
+# ── Install from Local Path ──
+
+
+def _install_local_path(repo_url, install_dir, dry_run=False, method_override=None):
+    """Install a project from a local directory path."""
+    local_path = Path(repo_url).expanduser().resolve()
+    safe_name = _sanitize_repo_name(local_path.name)
+    if not safe_name:
+        print_error(f"Invalid local path name: {local_path.name}")
+        return None
+
+    if dry_run:
+        print(f"  [DRY RUN] Would install from local path: {local_path}")
+        print(f"  [DRY RUN] Would use method: {method_override or '(auto-detected)'}")
+        return install_dir / safe_name
+
+    install_dir.mkdir(parents=True, exist_ok=True)
+    print(f"  Installing from local path: {local_path}")
+
+    install_method = method_override or detect_install_method(local_path)
+    print(f"  Detected install method: {install_method}")
+
+    install_funcs = {
+        "python": install_python, "node": install_node, "go": install_go,
+        "rust": install_rust, "binary": install_binary, "make": install_make,
+        "script": install_script, "download": install_binary,
+    }
+    install_func = install_funcs.get(install_method, install_binary)
+    installed_path = install_func(local_path, install_dir)
+
+    if installed_path:
+        register_app(safe_name, str(local_path), installed_path, install_method)
+        print()
+        print(f"  {Colors.CYAN}Summary:{Colors.END}")
+        print(f"    Name:     {safe_name}")
+        print(f"    Method:   {install_method}")
+        print(f"    Location: {installed_path}")
+        print(f"    Size:     {_get_disk_size(installed_path)}")
+        return installed_path
+    return None
+
+
+# ── Self-Update ──
+
+
+def self_update():
+    """Update pluck itself via PyPI."""
+    print_header("Updating pluck")
+    try:
+        subprocess.run(
+            [sys.executable, "-m", "pip", "install", "--upgrade", "pluck-cli"],
+            check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+        )
+        print_success("pluck updated to latest version")
+        return True
+    except subprocess.CalledProcessError as e:
+        print_error(f"Update failed: {e}")
+        return False
+
+
+# ── Search All Forges + Export ──
+
+
+def _search_with_results(query, limit, searcher_func):
+    """Run a searcher and return results as a list of dicts."""
+    results = []
+    searcher_func(query, limit=limit, results=results)
+    return results
+
+
+def search_all_forges(query, limit=5, output_file=None):
+    """Search all supported forges and optionally export results."""
+    all_results = []
+    forges = [
+        ("GitHub", search_github),
+        ("GitLab", search_gitlab),
+        ("Codeberg", search_codeberg),
+        ("Bitbucket", search_bitbucket),
+    ]
+
+    for name, searcher in forges:
+        print(f"  Searching {name} for '{query}'...")
+        results = _search_with_results(query, limit, searcher)
+        all_results.append((name, results))
+
+    # Print aggregated results
+    print_header(f"Aggregated Search Results — '{query}'")
+    for forge_name, results in all_results:
+        if results:
+            print(f"\n{Colors.CYAN}── {forge_name} ({len(results)} results) ──{Colors.END}")
+            for r in results:
+                print(f"  {r['index']}. {Colors.GREEN}{r['name']}{Colors.END}")
+                print(f"     {r['description']}")
+                print(f"     \u2605 {r['stars']:,}  |  Language: {r['language']}")
+                print(f"     URL: {r['url']}")
+                print()
+
+    # Export to file if requested
+    if output_file:
+        out_path = Path(output_file).expanduser()
+        lines = [f"Search Results: '{query}' ({datetime.now():%Y-%m-%d %H:%M})", "=" * 60, ""]
+        for forge_name, results in all_results:
+            if results:
+                lines.append(f"── {forge_name} ──")
+                for r in results:
+                    lines.append(f"{r['name']}  |  \u2605 {r['stars']:,}  |  {r['language']}")
+                    lines.append(f"  {r['url']}")
+                    lines.append(f"  {r['description']}")
+                    lines.append("")
+            else:
+                lines.append(f"── {forge_name} ── (no results)")
+                lines.append("")
+
+        out_path.parent.mkdir(parents=True, exist_ok=True)
+        out_path.write_text("\n".join(lines) + "\n")
+        print_success(f"Exported results to {out_path}")
+
+
+# ── Release Asset Install ──
+
+
+def _github_release_url(repo_info, install_dir):
+    """Try to download a pre-built release asset from GitHub."""
+    owner = repo_info["owner"]
+    repo = repo_info["repo"]
+    api_url = f"https://api.github.com/repos/{owner}/{repo}/releases/latest"
+    try:
+        headers = {"Accept": "application/vnd.github.v3+json", "User-Agent": "pluck"}
+        req = urllib.request.Request(api_url, headers=headers)
+        with urllib.request.urlopen(req, timeout=15) as resp:
+            data = json.loads(resp.read().decode())
+    except Exception as e:
+        print_warning(f"Could not fetch GitHub release: {e}")
+        return None
+
+    assets = data.get("assets", [])
+    if not assets:
+        print_warning("No release assets found")
+        return None
+
+    # Pick a matching asset: prefer the one matching the current platform
+    arch_hints = []
+    if sys.platform == "linux":
+        arch_hints = ["linux", "Linux", "x86_64", "amd64"]
+    elif sys.platform == "darwin":
+        arch_hints = ["macos", "darwin", "Darwin", "macOS", "x86_64", "amd64", "arm64"]
+
+    best = None
+    for asset in assets:
+        name = asset["name"]
+        if all(hint in name for hint in arch_hints):
+            best = asset
+            break
+
+    if not best and assets:
+        # Fallback to first asset
+        best = assets[0]
+
+    if not best:
+        print_warning("No suitable asset found")
+        return None
+
+    # Download the asset
+    print(f"  Downloading release asset: {best['name']}")
+    dl_url = best["browser_download_url"]
+    dest = CACHE_DIR / best["name"]
+    CACHE_DIR.mkdir(parents=True, exist_ok=True)
+
+    try:
+        req = urllib.request.Request(dl_url, headers={"User-Agent": "pluck"})
+        with urllib.request.urlopen(req, timeout=60) as resp:
+            dest.write_bytes(resp.read())
+    except Exception as e:
+        print_error(f"Download failed: {e}")
+        return None
+
+    print_success(f"Downloaded to {dest}")
+
+    # If it's an archive, extract it
+    if best["name"].endswith(".tar.gz") or best["name"].endswith(".tgz"):
+        import tarfile
+        extract_dir = install_dir / repo
+        extract_dir.mkdir(parents=True, exist_ok=True)
+        with tarfile.open(dest) as tar:
+            tar.extractall(extract_dir)
+        print_success(f"Extracted to {extract_dir}")
+        return extract_dir
+    elif best["name"].endswith(".zip"):
+        import zipfile
+        extract_dir = install_dir / repo
+        extract_dir.mkdir(parents=True, exist_ok=True)
+        with zipfile.ZipFile(dest) as zf:
+            zf.extractall(extract_dir)
+        print_success(f"Extracted to {extract_dir}")
+        return extract_dir
+    else:
+        # Single binary
+        dest.chmod(0o755)
+        bin_dir = install_dir / repo
+        bin_dir.mkdir(parents=True, exist_ok=True)
+        final = bin_dir / best["name"]
+        shutil.move(str(dest), str(final))
+        print_success(f"Installed binary to {final}")
+        return bin_dir
+
+
+def _gitlab_release_url(repo_info, install_dir):
+    """Try to download a pre-built release asset from GitLab."""
+    owner = repo_info["owner"]
+    repo = repo_info["repo"]
+    # GitLab generic packages API
+    encoded = urllib.parse.quote(owner + "/" + repo, safe="")
+    api_url = f"https://gitlab.com/api/v4/projects/{encoded}/releases/permalink/latest"
+    try:
+        req = urllib.request.Request(api_url, headers={"Accept": "application/json", "User-Agent": "pluck"})
+        with urllib.request.urlopen(req, timeout=15) as resp:
+            data = json.loads(resp.read().decode())
+    except Exception as e:
+        print_warning(f"Could not fetch GitLab release: {e}")
+        return None
+
+    links = data.get("assets", {}).get("links", [])
+    if not links:
+        print_warning("No release assets found")
+        return None
+
+    # Pick first binary link
+    for link in links:
+        url = link.get("direct_asset_url") or link.get("url", "")
+        if url:
+            name = link.get("name", "asset")
+            dest = CACHE_DIR / name
+            CACHE_DIR.mkdir(parents=True, exist_ok=True)
+            print(f"  Downloading release asset: {name}")
+            try:
+                req = urllib.request.Request(url, headers={"User-Agent": "pluck"})
+                with urllib.request.urlopen(req, timeout=60) as resp:
+                    dest.write_bytes(resp.read())
+            except Exception as e:
+                print_warning(f"Download failed: {e}")
+                continue
+
+            bin_dir = install_dir / repo
+            bin_dir.mkdir(parents=True, exist_ok=True)
+            final = bin_dir / name
+            dest.chmod(0o755)
+            shutil.move(str(dest), str(final))
+            print_success(f"Installed release asset to {final}")
+            return bin_dir
+
+    print_warning("Could not download any release asset")
+    return None
+
+
+def install_release_asset(repo_info, install_dir):
+    """Install from pre-built release assets instead of cloning."""
+    host_type = repo_info.get("host_type", "")
+    if host_type == "github":
+        return _github_release_url(repo_info, install_dir)
+    elif host_type == "gitlab":
+        return _gitlab_release_url(repo_info, install_dir)
+    else:
+        print_warning(f"Release asset install not yet supported for {host_type}")
+        return None
+
+
 def main():
     """Main entry point"""
     # Auto-migrate from old gh-install paths
@@ -1533,9 +1962,8 @@ def main():
     command = sys.argv[1]
 
     if command == "install":
-        install_dir, dry_run, force, shallow, ref, method, json_output, verbose, no_color, timeout, retries, urls = (
-            _parse_args(sys.argv[2:])
-        )
+        (install_dir, dry_run, force, shallow, ref, method, json_output,
+         verbose, no_color, timeout, retries, jobs, urls) = _parse_args(sys.argv[2:])
 
         if not urls:
             print_error("Please provide a repository URL")
@@ -1548,24 +1976,42 @@ def main():
         if dry_run:
             print_header("Dry Run — No changes will be made")
 
-        for url in urls:
-            print(f"\nInstalling: {url}")
-            download_and_install(
-                url,
-                install_dir=install_dir,
-                dry_run=dry_run,
-                shallow=shallow,
-                ref=ref,
-                method_override=method,
-                verbose=verbose,
-                timeout=timeout,
-                retries=retries,
-            )
+        if jobs > 1 and len(urls) > 1:
+            # Parallel install
+            print_header(f"Installing {len(urls)} repos with {jobs} workers")
+            with concurrent.futures.ThreadPoolExecutor(max_workers=jobs) as pool:
+                futures = {
+                    pool.submit(
+                        download_and_install, url,
+                        install_dir=install_dir, dry_run=dry_run, shallow=shallow,
+                        ref=ref, method_override=method, verbose=verbose,
+                        timeout=timeout, retries=retries,
+                    ): url for url in urls
+                }
+                for future in concurrent.futures.as_completed(futures):
+                    url = futures[future]
+                    try:
+                        future.result()
+                    except Exception as e:
+                        print_error(f"Failed to install {url}: {e}")
+        else:
+            for url in urls:
+                print(f"\nInstalling: {url}")
+                download_and_install(
+                    url,
+                    install_dir=install_dir,
+                    dry_run=dry_run,
+                    shallow=shallow,
+                    ref=ref,
+                    method_override=method,
+                    verbose=verbose,
+                    timeout=timeout,
+                    retries=retries,
+                )
 
     elif command == "update":
-        install_dir, dry_run, force, shallow, ref, method, json_output, verbose, no_color, timeout, retries, rest = (
-            _parse_args(sys.argv[2:])
-        )
+        (install_dir, dry_run, force, shallow, ref, method, json_output,
+         verbose, no_color, timeout, retries, jobs, rest) = _parse_args(sys.argv[2:])
         if not rest:
             print_error("Please provide an app name")
             sys.exit(1)
@@ -1597,9 +2043,8 @@ def main():
         list_installed(json_output=json_output)
 
     elif command in ("uninstall", "remove"):
-        install_dir, dry_run, force, shallow, ref, method, json_output, verbose, no_color, timeout, retries, rest = (
-            _parse_args(sys.argv[2:])
-        )
+        (install_dir, dry_run, force, shallow, ref, method, json_output,
+         verbose, no_color, timeout, retries, jobs, rest) = _parse_args(sys.argv[2:])
         if not rest:
             print_error("Please provide an app name")
             sys.exit(1)
@@ -1612,9 +2057,8 @@ def main():
         verify_apps(json_output=json_output)
 
     elif command == "clean":
-        install_dir, dry_run, force, shallow, ref, method, json_output, verbose, no_color, timeout, retries, rest = (
-            _parse_args(sys.argv[2:])
-        )
+        (install_dir, dry_run, force, shallow, ref, method, json_output,
+         verbose, no_color, timeout, retries, jobs, rest) = _parse_args(sys.argv[2:])
         clean_registry(dry_run=dry_run, force=force, json_output=json_output)
 
     elif command == "stats":
@@ -1636,30 +2080,48 @@ def main():
             print_error("Please provide a search query")
             sys.exit(1)
 
+        # Extract flags
+        output_file = None
+        search_all = False
         forge = "github"
-        if "--forge" in args:
-            idx = args.index("--forge")
-            if idx + 1 < len(args):
-                forge = args[idx + 1].lower()
-                args = args[:idx] + args[idx + 2:]
+        cleaned = []
+        i = 0
+        while i < len(args):
+            if args[i] == "--forge" and i + 1 < len(args):
+                forge = args[i + 1].lower()
+                i += 2
+            elif args[i] == "--all":
+                search_all = True
+                i += 1
+            elif args[i] == "--output" and i + 1 < len(args):
+                output_file = args[i + 1]
+                i += 2
             else:
-                print_error("Missing forge name after --forge (try: github, gitlab, codeberg)")
-                sys.exit(1)
+                cleaned.append(args[i])
+                i += 1
 
-        query = " ".join(args)
-        forge_searchers = {
-            "github": search_github,
-            "gitlab": search_gitlab,
-            "codeberg": search_codeberg,
-            "bitbucket": search_bitbucket,
-        }
-        searcher = forge_searchers.get(forge)
-        if searcher:
-            searcher(query)
-        else:
-            print_error(f"Unknown forge: {forge}. Supported: {', '.join(sorted(forge_searchers))}")
+        query = " ".join(cleaned)
+
+        if not query:
+            print_error("Please provide a search query")
             sys.exit(1)
 
+        if search_all:
+            search_all_forges(query, output_file=output_file)
+        else:
+            forge_searchers = {
+                "github": search_github,
+                "gitlab": search_gitlab,
+                "codeberg": search_codeberg,
+                "bitbucket": search_bitbucket,
+            }
+            searcher = forge_searchers.get(forge)
+            if searcher:
+                searcher(query)
+            else:
+                print_error(f"Unknown forge: {forge}. Supported: {', '.join(sorted(forge_searchers))}")
+                sys.exit(1)
+
     elif command == "export":
         if len(sys.argv) < 3:
             print_error("Please provide an output file path")
@@ -1685,6 +2147,26 @@ def main():
             print("Supported shells: bash, zsh")
             sys.exit(1)
 
+    elif command == "pin":
+        if len(sys.argv) < 3:
+            print_error("Please provide an app name")
+            sys.exit(1)
+        pin_app(sys.argv[2])
+
+    elif command == "unpin":
+        if len(sys.argv) < 3:
+            print_error("Please provide an app name")
+            sys.exit(1)
+        unpin_app(sys.argv[2])
+
+    elif command == "self-update":
+        if not self_update():
+            sys.exit(1)
+
+    elif command == "cache":
+        action = sys.argv[2] if len(sys.argv) > 2 else "path"
+        cache_command(action)
+
     elif command == "version":
         print(f"pluck v{__version__}")
 

{pluck_cli-0.2.1 → pluck_cli-0.3.2/src/pluck_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pluck-cli
-Version: 0.2.1
+Version: 0.3.2
 Summary: Pluck any git repo from any forge — auto-detect, auto-install, done!
 Author: pluck contributors
 License: MIT
@@ -175,7 +175,11 @@ Any git hosting platform that follows the standard `host/owner/repo` URL pattern
 | `stats` | Show statistics | `pluck stats` |
 | `doctor` | Check tool availability | `pluck doctor` |
 | `config [key] [val]` | View/set config | `pluck config install_dir ~/Apps` |
-| `search <query> [--forge <name>]` | Search repos (github\|gitlab\|codeberg\|bitbucket) | `pluck search python installer --forge gitlab` |
+| `search <query> [--forge <name>] [--all] [--output <file>]` | Search repos across forges | `pluck search python installer --all --output results.txt` |
+| `pin <name>` | Pin an app to prevent updates | `pluck pin myapp` |
+| `unpin <name>` | Unpin an app | `pluck unpin myapp` |
+| `self-update` | Update pluck itself | `pluck self-update` |
+| `cache prune` | Clear download cache | `pluck cache prune` |
 | `export <file>` | Export registry | `pluck export ~/backup.json` |
 | `import <file>` | Import registry | `pluck import ~/backup.json` |
 | `completion <shell>` | Generate shell completion | `pluck completion bash` |
@@ -197,6 +201,8 @@ Any git hosting platform that follows the standard `host/owner/repo` URL pattern
 | `--no-color` | Disable colored output |
 | `--timeout <secs>` | Timeout for git clone in seconds |
 | `--retries <n>` | Number of retries for failed git clone |
+| `--jobs <n>` | Number of parallel installs (default: 1) |
+| `--release` | Install from pre-built release assets instead of cloning |
 | `--verbose` | Show detailed git clone output |
 
 ## 📥 Installation

{pluck_cli-0.2.1 → pluck_cli-0.3.2}/tests/test_gh_install.py

@@ -356,10 +356,10 @@ class TestSharedPaths:
 
 class TestValidMethods:
     def test_valid_methods_not_empty(self):
-        assert len(VALID_METHODS) == 8
+        assert len(VALID_METHODS) == 9
 
     def test_all_expected_methods_present(self):
-        expected = {"script", "binary", "python", "node", "go", "rust", "make", "download"}
+        expected = {"script", "binary", "python", "node", "go", "rust", "make", "download", "release"}
         assert VALID_METHODS == expected
 
 
@@ -433,7 +433,7 @@ class TestParseArgs:
     def test_urls_only(self):
         (
             install_dir, dry_run, force, shallow, ref,
-            method, json_output, verbose, no_color, timeout, retries, urls,
+            method, json_output, verbose, no_color, timeout, retries, jobs, urls,
         ) = _parse_args(["https://github.com/a/b"])
         assert install_dir is None
         assert dry_run is False
@@ -446,7 +446,7 @@ class TestParseArgs:
     def test_dir_flag(self):
         (
             install_dir, dry_run, force, shallow, ref,
-            method, json_output, verbose, no_color, timeout, retries, urls,
+            method, json_output, verbose, no_color, timeout, retries, jobs, urls,
         ) = _parse_args(["--dir", "/tmp/test", "https://github.com/a/b"])
         assert install_dir == Path("/tmp/test")
         assert urls == ["https://github.com/a/b"]
@@ -454,49 +454,49 @@ class TestParseArgs:
     def test_dry_run_flag(self):
         (
             install_dir, dry_run, force, shallow, ref,
-            method, json_output, verbose, no_color, timeout, retries, urls,
+            method, json_output, verbose, no_color, timeout, retries, jobs, urls,
         ) = _parse_args(["--dry-run", "https://github.com/a/b"])
         assert dry_run is True
 
     def test_force_flag(self):
         (
             install_dir, dry_run, force, shallow, ref,
-            method, json_output, verbose, no_color, timeout, retries, urls,
+            method, json_output, verbose, no_color, timeout, retries, jobs, urls,
         ) = _parse_args(["--force", "https://github.com/a/b"])
         assert force is True
 
     def test_yes_flag(self):
         (
             install_dir, dry_run, force, shallow, ref,
-            method, json_output, verbose, no_color, timeout, retries, urls,
+            method, json_output, verbose, no_color, timeout, retries, jobs, urls,
         ) = _parse_args(["--yes", "https://github.com/a/b"])
         assert force is True
 
     def test_shallow_flag(self):
         (
             install_dir, dry_run, force, shallow, ref,
-            method, json_output, verbose, no_color, timeout, retries, urls,
+            method, json_output, verbose, no_color, timeout, retries, jobs, urls,
         ) = _parse_args(["--shallow", "https://github.com/a/b"])
         assert shallow is True
 
     def test_ref_flag(self):
         (
             install_dir, dry_run, force, shallow, ref,
-            method, json_output, verbose, no_color, timeout, retries, urls,
+            method, json_output, verbose, no_color, timeout, retries, jobs, urls,
         ) = _parse_args(["--ref", "v2.0", "https://github.com/a/b"])
         assert ref == "v2.0"
 
     def test_method_flag(self):
         (
             install_dir, dry_run, force, shallow, ref,
-            method, json_output, verbose, no_color, timeout, retries, urls,
+            method, json_output, verbose, no_color, timeout, retries, jobs, urls,
         ) = _parse_args(["--method", "python", "https://github.com/a/b"])
         assert method == "python"
 
     def test_combined_flags(self):
         (
             install_dir, dry_run, force, shallow, ref,
-            method, json_output, verbose, no_color, timeout, retries, urls,
+            method, json_output, verbose, no_color, timeout, retries, jobs, urls,
         ) = _parse_args([
             "--dir", "/custom", "--dry-run", "--shallow",
             "--ref", "main", "--method", "python",
@@ -511,7 +511,7 @@ class TestParseArgs:
     def test_flags_between_urls(self):
         (
             install_dir, dry_run, force, shallow, ref,
-            method, json_output, verbose, no_color, timeout, retries, urls,
+            method, json_output, verbose, no_color, timeout, retries, jobs, urls,
         ) = _parse_args([
             "https://github.com/a/b", "--dir", "/opt", "https://github.com/c/d",
         ])