codefetch-cli 1.2.3__py3-none-any.whl → 1.2.5__py3-none-any.whl

codefetch/__init__.py

@@ -16,17 +16,17 @@ Usage in Python:
     files = cf.list("torvalds/linux")
 """
 
-__version__ = "1.2.3"
+__version__ = "1.2.5"
 
 
-def get(target, filename=None, branch="main"):
+def get(target, filename=None, branch=None):
     """
     Fetch and return the text content of a file from GitHub.
 
     Args:
         target: 'owner/repo' or full path 'owner/repo/path/to/file' or full GitHub URL.
         filename: Optional path to file in repo if target is 'owner/repo'.
-        branch: Branch name (default: 'main', automatically falls back to 'master').
+        branch: Branch name (default: None, automatically detects repo default branch).
 
     Returns:
         str: File content.
@@ -37,8 +37,10 @@ def get(target, filename=None, branch="main"):
     """
     import urllib.request
     from .cli import (
-        fetch_raw_direct,
-        get_repo_tree_with_branch,
+        get_default_branch,
+        check_branch_exists,
+        fetch_raw_single,
+        get_repo_tree,
         resolve_file_in_tree,
         parse_repo_identifier,
         resolve_invocation,
@@ -49,7 +51,7 @@ def get(target, filename=None, branch="main"):
         file_path = filename.strip("/\\")
     else:
         owner, repo, resolved_branch, file_path = resolve_invocation(
-            [target], None, None, branch, None, None, "main"
+            [target], None, None, branch, None, None
         )
         if resolved_branch:
             branch = resolved_branch
@@ -57,24 +59,30 @@ def get(target, filename=None, branch="main"):
     if not owner or not repo or not file_path:
         raise ValueError(f"Could not resolve owner, repo, and filename from target='{target}', filename='{filename}'")
 
+    target_branch = branch
+    if not target_branch:
+        target_branch = get_default_branch(owner, repo)
+    elif not check_branch_exists(owner, repo, target_branch):
+        target_branch = get_default_branch(owner, repo)
+
     # 1. Try fast direct raw fetch
-    found_branch, content = fetch_raw_direct(owner, repo, branch, file_path)
+    content = fetch_raw_single(owner, repo, target_branch, file_path)
     if content is not None:
         return content
 
     # 2. Try repository tree search
-    actual_branch, tree_data = get_repo_tree_with_branch(owner, repo, branch)
+    tree_data = get_repo_tree(owner, repo, target_branch)
     matched = resolve_file_in_tree(tree_data, file_path)
     if matched:
-        url = f"https://raw.githubusercontent.com/{owner}/{repo}/{actual_branch}/{matched}"
+        url = f"https://raw.githubusercontent.com/{owner}/{repo}/{target_branch}/{matched}"
         req = urllib.request.Request(url, headers={"User-Agent": "codefetch"})
         with urllib.request.urlopen(req, timeout=15) as resp:
             return resp.read().decode("utf-8")
 
-    raise FileNotFoundError(f"File '{file_path}' not found in {owner}/{repo} ({actual_branch})")
+    raise FileNotFoundError(f"File '{file_path}' not found in {owner}/{repo} ({target_branch})")
 
 
-def download(target, filename=None, output=None, branch="main"):
+def download(target, filename=None, output=None, branch=None):
     """
     Download a file from GitHub and save it locally.
 
@@ -82,7 +90,7 @@ def download(target, filename=None, output=None, branch="main"):
         target: 'owner/repo' or full path 'owner/repo/path/to/file'.
         filename: Optional path to file in repo if target is 'owner/repo'.
         output: Destination filename/path on local disk (default: original filename).
-        branch: Branch name (default: 'main').
+        branch: Branch name (default: None, automatically detects repo default branch).
 
     Returns:
         str: Path to the downloaded file.
@@ -99,20 +107,22 @@ def download(target, filename=None, output=None, branch="main"):
     return dest_name
 
 
-def list(target, branch="main"):
+def list(target, branch=None):
     """
     List supported code files in a repository.
 
     Args:
         target: 'owner/repo' or repository URL.
-        branch: Branch name (default: 'main').
+        branch: Branch name (default: None, automatically detects repo default branch).
 
     Returns:
         list[str]: Relative paths of code files in the repository.
     """
     from .cli import (
         parse_repo_identifier,
-        get_repo_tree_with_branch,
+        get_default_branch,
+        check_branch_exists,
+        get_repo_tree,
         CODE_EXTENSIONS,
         NAMED_FILES,
     )
@@ -121,7 +131,11 @@ def list(target, branch="main"):
     if not owner or not repo:
         raise ValueError(f"Invalid repository identifier: '{target}'")
 
-    actual_branch, tree_data = get_repo_tree_with_branch(owner, repo, branch)
+    target_branch = branch
+    if not target_branch or not check_branch_exists(owner, repo, target_branch):
+        target_branch = get_default_branch(owner, repo)
+
+    tree_data = get_repo_tree(owner, repo, target_branch)
     files = []
     for item in tree_data.get("tree", []):
         if item.get("type") != "blob":

codefetch/cli.py

@@ -7,6 +7,7 @@ import argparse
 import json
 import os
 import re
+import subprocess
 import sys
 import urllib.error
 import urllib.request
@@ -14,11 +15,10 @@ from pathlib import Path
 
 DEFAULT_OWNER = None
 DEFAULT_REPO = None
-DEFAULT_BRANCH = "main"
 
 CONFIG_FILE = Path.home() / ".codefetch.json"
 
-__version__ = "1.2.3"
+__version__ = "1.2.5"
 
 # Supported code, data, and config extensions
 CODE_EXTENSIONS = {
@@ -62,6 +62,7 @@ USAGE:
   codefetch -s <owner>/<repo> <filename>   Preview file in terminal without saving
   codefetch -l <owner>/<repo>              List all code files in a repository
   codefetch -R <username>                  List public repositories for a user
+  codefetch --update                       Update CodeFetch to the latest version
 
 POPULAR EXAMPLES:
   # Download from any repository:
@@ -93,36 +94,42 @@ FLAGS & OPTIONS:
   -R, --repos               List public repositories for a GitHub user
   -r, --repo <repo>         Specify repository name or URL
   -u, --user <user>         Specify GitHub username / organization
-  -b, --branch <branch>     Specify branch name (default: main)
+  -b, --branch <branch>     Specify branch name (default: repository default branch)
   --set-default <repo>      Save default repository (e.g. owner/repo)
   --set-default-user <user> Save default user/organization
   --config                  Show current saved configuration
   --reset-config            Reset configuration back to defaults
+  -U, --update              Update CodeFetch to the latest version from PyPI
   -v, --version             Show version number
   -h, --help                Show this help message
 """
 
+_REPO_DEFAULT_BRANCH_CACHE = {}
+_REPO_BRANCHES_CACHE = {}
+
 
 def load_config():
     """Load user configuration from ~/.codefetch.json."""
     if CONFIG_FILE.exists():
         try:
             with open(CONFIG_FILE, "r", encoding="utf-8") as f:
-                return json.load(f)
+                data = json.load(f)
+                return {
+                    "owner": data.get("owner"),
+                    "repo": data.get("repo"),
+                }
         except Exception:
             return {}
     return {}
 
 
-def save_config(owner=None, repo=None, branch=None):
+def save_config(owner=None, repo=None):
     """Save user configuration to ~/.codefetch.json."""
     cfg = load_config()
     if owner is not None:
         cfg["owner"] = owner
     if repo is not None:
         cfg["repo"] = repo
-    if branch is not None:
-        cfg["branch"] = branch
 
     try:
         with open(CONFIG_FILE, "w", encoding="utf-8") as f:
@@ -168,76 +175,99 @@ def parse_repo_identifier(repo_str, default_owner=None):
     return default_owner, repo_str.removesuffix(".git")
 
 
-def fetch_raw_direct(owner, repo, branch, clean_filename):
+def get_default_branch(owner, repo):
     """
-    Direct raw fetch from raw.githubusercontent.com.
-    Tries requested branch first. If branch is 'main', also tries 'master',
-    and vice versa.
-    Returns (branch_used, content_str) or (None, None).
+    Get the default branch of a repository (e.g. 'main', 'master', 'unstable').
+    Queries GitHub API and caches the result. Falls back to probing if rate limited.
     """
-    branches_to_try = [branch]
-    if branch == "main":
-        branches_to_try.append("master")
-    elif branch == "master":
-        branches_to_try.append("main")
-
-    for b in branches_to_try:
-        url = f"https://raw.githubusercontent.com/{owner}/{repo}/{b}/{clean_filename}"
-        try:
-            req = urllib.request.Request(url, headers={"User-Agent": "codefetch"})
-            with urllib.request.urlopen(req, timeout=15) as resp:
-                return b, resp.read().decode("utf-8")
-        except urllib.error.HTTPError as e:
-            if e.code == 404:
-                continue
-            raise
-    return None, None
+    key = f"{owner.lower()}/{repo.lower()}"
+    if key in _REPO_DEFAULT_BRANCH_CACHE:
+        return _REPO_DEFAULT_BRANCH_CACHE[key]
 
+    try:
+        url = f"https://api.github.com/repos/{owner}/{repo}"
+        data = get_json(url)
+        def_b = data.get("default_branch")
+        if def_b:
+            _REPO_DEFAULT_BRANCH_CACHE[key] = def_b
+            return def_b
+    except Exception:
+        pass
 
-def get_repo_tree_with_branch(owner, repo, branch="main"):
-    """
-    Fetch the Git tree for a repository, returning (actual_branch, tree_data).
-    Tries branch first, then fallback to master/main, then checks repository info for default_branch.
-    """
-    branches_to_try = [branch]
-    if branch == "main":
-        branches_to_try.append("master")
-    elif branch == "master":
-        branches_to_try.append("main")
-
-    for b in branches_to_try:
-        url = f"https://api.github.com/repos/{owner}/{repo}/git/trees/{b}?recursive=1"
+    # Fast fallback probe via CDN if API is unavailable or rate-limited
+    for b in ("main", "master"):
         try:
-            return b, get_json(url)
-        except urllib.error.HTTPError as e:
-            if e.code == 404:
-                continue
-            raise
+            req = urllib.request.Request(
+                f"https://raw.githubusercontent.com/{owner}/{repo}/{b}/README.md",
+                headers=get_headers(),
+            )
+            with urllib.request.urlopen(req, timeout=5):
+                _REPO_DEFAULT_BRANCH_CACHE[key] = b
+                return b
+        except Exception:
+            continue
+
+    return "main"
+
+
+def get_repo_branches(owner, repo):
+    """Fetch the list of all branch names in a repository."""
+    key = f"{owner.lower()}/{repo.lower()}"
+    if key in _REPO_BRANCHES_CACHE:
+        return _REPO_BRANCHES_CACHE[key]
 
-    # Query repository info to discover actual default branch (e.g. develop, trunk, etc.)
     try:
-        info_url = f"https://api.github.com/repos/{owner}/{repo}"
-        info = get_json(info_url)
-        def_branch = info.get("default_branch")
-        if def_branch and def_branch not in branches_to_try:
-            url = f"https://api.github.com/repos/{owner}/{repo}/git/trees/{def_branch}?recursive=1"
-            return def_branch, get_json(url)
+        url = f"https://api.github.com/repos/{owner}/{repo}/branches?per_page=100"
+        data = get_json(url)
+        branches = [b["name"] for b in data if isinstance(b, dict) and b.get("name")]
+        if branches:
+            _REPO_BRANCHES_CACHE[key] = branches
+            return branches
     except Exception:
         pass
+    return []
 
-    raise urllib.error.HTTPError(
-        f"https://api.github.com/repos/{owner}/{repo}/git/trees/{branch}",
-        404,
-        "Branch tree not found",
-        {},
-        None,
-    )
+
+def check_branch_exists(owner, repo, branch):
+    """Check if a specific branch exists in a repository."""
+    if not branch:
+        return False
+    branches = get_repo_branches(owner, repo)
+    if branches:
+        return branch in branches
+    try:
+        get_json(f"https://api.github.com/repos/{owner}/{repo}/branches/{branch}")
+        return True
+    except urllib.error.HTTPError as e:
+        if e.code == 404:
+            return False
+        return True
+    except Exception:
+        return True
+
+
+def fetch_raw_single(owner, repo, branch, clean_filename):
+    """
+    Direct raw fetch from raw.githubusercontent.com for a specific branch.
+    Returns content string or None if 404.
+    """
+    url = f"https://raw.githubusercontent.com/{owner}/{repo}/{branch}/{clean_filename}"
+    try:
+        req = urllib.request.Request(url, headers={"User-Agent": "codefetch"})
+        with urllib.request.urlopen(req, timeout=15) as resp:
+            return resp.read().decode("utf-8")
+    except urllib.error.HTTPError as e:
+        if e.code == 404:
+            return None
+        raise
+    except UnicodeDecodeError:
+        raise
 
 
-def get_repo_tree(owner, repo, branch="main"):
-    """Fetch the Git tree for a repository (backwards compatible helper)."""
-    _, tree_data = get_repo_tree_with_branch(owner, repo, branch)
-    return tree_data
+def get_repo_tree(owner, repo, branch):
+    """Fetch the Git tree for a repository on a given branch."""
+    url = f"https://api.github.com/repos/{owner}/{repo}/git/trees/{branch}?recursive=1"
+    return get_json(url)
 
 
 def get_user_repos(owner):
@@ -247,7 +277,7 @@ def get_user_repos(owner):
 
 
 def list_repos(owner=None, default_repo=None):
-    """List all public repositories for a GitHub user."""
+    """List all public repositories for a GitHub user with clean spacing."""
     if not owner:
         print("Error: No GitHub username specified.")
         print("Usage: codefetch --repos <username>")
@@ -259,21 +289,21 @@ def list_repos(owner=None, default_repo=None):
             print(f"No public repositories found for user '{owner}'.")
             return
 
-        print(f"Public repositories for '{owner}':\n")
+        print(f"Public repositories for '{owner}' ({len(repos)} total):\n")
         for i, r in enumerate(repos, 1):
             name = r.get("name", "")
-            desc = r.get("description") or "No description"
+            desc = (r.get("description") or "").strip()
             is_def = " (default)" if default_repo and name.lower() == default_repo.lower() else ""
-            marker = "*" if is_def else "-"
-            print(f"  {marker} {name:<22}{is_def}")
-            if desc and desc != "No description":
+            print(f"  {i:>2}. {name}{is_def}")
+            if desc:
                 print(f"      {desc}")
+            print()
 
-        print(f"\nTotal: {len(repos)} repositories")
-        print("\nCommands:")
-        print(f"  codefetch -l {owner}/<repo>                  List files in a repository")
-        print(f"  codefetch {owner}/<repo> <filename>          Download a file from a repository")
-        print(f"  codefetch --set-default {owner}/<repo>       Set default repository")
+        print("Commands:")
+        print(f"  codefetch {owner}/<repo> <filename>          Download a file")
+        print(f"  codefetch -s {owner}/<repo> <filename>       Preview file in terminal")
+        print(f"  codefetch -l {owner}/<repo>                  List files in repository")
+        print(f"  codefetch --set-default {owner}/<repo>       Set as default repository")
 
     except urllib.error.HTTPError as e:
         print(f"Could not list repositories: HTTP {e.code}")
@@ -283,8 +313,8 @@ def list_repos(owner=None, default_repo=None):
         print(f"Could not list repositories: {e}")
 
 
-def list_files(owner, repo, branch="main"):
-    """List code files in a repository."""
+def list_files(owner, repo, branch=None):
+    """List code files in a repository, with automatic branch detection and fallback."""
     if not owner or not repo:
         print("Error: No repository specified to list.\n")
         print("Usage:")
@@ -292,8 +322,25 @@ def list_files(owner, repo, branch="main"):
         print("  codefetch -u <owner> -r <repo> -l")
         return
 
+    target_branch = branch
+    default_branch = get_default_branch(owner, repo)
+
+    # If branch was specified by user, verify it first
+    if target_branch:
+        if not check_branch_exists(owner, repo, target_branch):
+            print(f"Notice: Branch '{target_branch}' was not found in {owner}/{repo}.")
+            available_branches = get_repo_branches(owner, repo)
+            if available_branches:
+                shown = available_branches[:15]
+                extra = f" (+{len(available_branches) - 15} more)" if len(available_branches) > 15 else ""
+                print(f"Available branches in {owner}/{repo}: {', '.join(shown)}{extra}")
+            print(f"Listing files from default branch '{default_branch}' instead:\n")
+            target_branch = default_branch
+    else:
+        target_branch = default_branch
+
     try:
-        actual_branch, data = get_repo_tree_with_branch(owner, repo, branch)
+        data = get_repo_tree(owner, repo, target_branch)
         if data.get("truncated"):
             print("Warning: GitHub returned a truncated file list.")
 
@@ -314,10 +361,10 @@ def list_files(owner, repo, branch="main"):
         files.sort(key=str.lower)
 
         if not files:
-            print(f"No supported code files found in {owner}/{repo} ({actual_branch}).")
+            print(f"No supported code files found in {owner}/{repo} ({target_branch}).")
             return
 
-        print(f"Available files in {owner}/{repo} ({actual_branch}):\n")
+        print(f"Available files in {owner}/{repo} ({target_branch}):\n")
         for i, path in enumerate(files, 1):
             print(f"{i:>3}. {path}")
 
@@ -387,9 +434,9 @@ def find_file_in_other_repos(owner, current_repo, target_filename):
             r_name = r.get("name")
             if not r_name or (current_repo and r_name.lower() == current_repo.lower()):
                 continue
-            default_branch = r.get("default_branch", "main")
+            default_b = r.get("default_branch") or "main"
             try:
-                tree_data = get_repo_tree(owner, r_name, default_branch)
+                tree_data = get_repo_tree(owner, r_name, default_b)
                 match = resolve_file_in_tree(tree_data, target_filename)
                 if match:
                     return r_name, match
@@ -400,9 +447,14 @@ def find_file_in_other_repos(owner, current_repo, target_filename):
     return None, None
 
 
-def fetch_file(filename, owner=None, repo=None, branch=DEFAULT_BRANCH,
+def fetch_file(filename, owner=None, repo=None, branch=None,
                show=False, output=None):
-    """Fetch or download a file from GitHub."""
+    """
+    Fetch or download a file from GitHub.
+    - If branch is None: fetches the default branch of the repository.
+    - If branch is specified: tries that branch first; if not found, shows message,
+      displays all available branches, and falls back to default branch.
+    """
     if not owner or not repo:
         print("Error: No GitHub repository specified.\n")
         print("Usage:")
@@ -422,63 +474,150 @@ def fetch_file(filename, owner=None, repo=None, branch=DEFAULT_BRANCH,
 
     content = None
     resolved_path = clean_filename
-    actual_branch = branch
+    actual_branch = None
 
-    # 1. Direct raw fetch first (fastest, preserves GitHub API rate limit)
-    try:
-        found_branch, raw_content = fetch_raw_direct(owner, repo, branch, clean_filename)
-        if raw_content is not None:
-            actual_branch = found_branch
-            content = raw_content
-    except UnicodeDecodeError:
-        print("The file is not UTF-8 text, so it cannot be displayed or saved as text.")
-        return
-    except urllib.error.HTTPError as e:
-        print(f"Download failed: HTTP {e.code}")
-        return
-    except urllib.error.URLError:
-        print("Could not connect to GitHub.")
-        return
+    default_branch = get_default_branch(owner, repo)
 
-    # 2. If direct fetch didn't find the file (404), fall back to smart repository tree search
-    if content is None:
+    # Case A: Branch parameter was explicitly entered by the user
+    if branch:
+        branch_exists = check_branch_exists(owner, repo, branch)
+
+        if not branch_exists:
+            print(f"Notice: Branch '{branch}' was not found in {owner}/{repo}.")
+            available_branches = get_repo_branches(owner, repo)
+            if available_branches:
+                shown = available_branches[:15]
+                extra = f" (+{len(available_branches) - 15} more)" if len(available_branches) > 15 else ""
+                print(f"Available branches in {owner}/{repo}: {', '.join(shown)}{extra}")
+            print(f"Trying default branch '{default_branch}'...")
+
+            actual_branch = default_branch
+            try:
+                content = fetch_raw_single(owner, repo, default_branch, clean_filename)
+            except UnicodeDecodeError:
+                print("The file is not UTF-8 text, so it cannot be displayed or saved as text.")
+                return
+            except Exception:
+                pass
+
+            if content is None:
+                try:
+                    tree_data = get_repo_tree(owner, repo, default_branch)
+                    matched = resolve_file_in_tree(tree_data, clean_filename)
+                    if matched:
+                        resolved_path = matched
+                        content = download_url(f"https://raw.githubusercontent.com/{owner}/{repo}/{default_branch}/{resolved_path}")
+                        if resolved_path != clean_filename:
+                            print(f"(Resolved '{clean_filename}' -> '{resolved_path}')")
+                except Exception:
+                    pass
+
+            if content is None:
+                print(f"File not found: '{clean_filename}' in {owner}/{repo} (checked '{branch}' and default '{default_branch}').")
+                print(f"To fetch from a specific branch: codefetch -b <branch> {owner}/{repo} {clean_filename}")
+                return
+
+        else:
+            actual_branch = branch
+            try:
+                content = fetch_raw_single(owner, repo, branch, clean_filename)
+            except UnicodeDecodeError:
+                print("The file is not UTF-8 text, so it cannot be displayed or saved as text.")
+                return
+            except Exception:
+                pass
+
+            if content is None:
+                try:
+                    tree_data = get_repo_tree(owner, repo, branch)
+                    matched = resolve_file_in_tree(tree_data, clean_filename)
+                    if matched:
+                        resolved_path = matched
+                        content = download_url(f"https://raw.githubusercontent.com/{owner}/{repo}/{branch}/{resolved_path}")
+                        if resolved_path != clean_filename:
+                            print(f"(Resolved '{clean_filename}' -> '{resolved_path}')")
+                except Exception:
+                    pass
+
+            if content is None and branch.lower() != default_branch.lower():
+                print(f"Notice: File '{clean_filename}' not found on branch '{branch}'.")
+                available_branches = get_repo_branches(owner, repo)
+                if available_branches:
+                    shown = available_branches[:15]
+                    extra = f" (+{len(available_branches) - 15} more)" if len(available_branches) > 15 else ""
+                    print(f"Available branches in {owner}/{repo}: {', '.join(shown)}{extra}")
+                print(f"Trying default branch '{default_branch}'...")
+
+                try:
+                    content = fetch_raw_single(owner, repo, default_branch, clean_filename)
+                    if content is not None:
+                        actual_branch = default_branch
+                except Exception:
+                    pass
+
+                if content is None:
+                    try:
+                        tree_data = get_repo_tree(owner, repo, default_branch)
+                        matched = resolve_file_in_tree(tree_data, clean_filename)
+                        if matched:
+                            resolved_path = matched
+                            actual_branch = default_branch
+                            content = download_url(f"https://raw.githubusercontent.com/{owner}/{repo}/{default_branch}/{resolved_path}")
+                            if resolved_path != clean_filename:
+                                print(f"(Resolved '{clean_filename}' -> '{resolved_path}')")
+                    except Exception:
+                        pass
+
+            if content is None:
+                print(f"File not found: '{clean_filename}' in {owner}/{repo} ({branch}).")
+                return
+
+    # Case B: No branch was specified (branch is None) -> fetch repo default branch
+    else:
+        actual_branch = default_branch
         try:
-            actual_branch, tree_data = get_repo_tree_with_branch(owner, repo, branch)
-            matched = resolve_file_in_tree(tree_data, clean_filename)
-            if matched:
-                resolved_path = matched
-                raw_url = f"https://raw.githubusercontent.com/{owner}/{repo}/{actual_branch}/{resolved_path}"
-                content = download_url(raw_url)
-                if resolved_path != clean_filename:
-                    print(f"(Resolved '{clean_filename}' -> '{resolved_path}')")
-            else:
-                # Check other public repositories for the same user
-                other_repo, other_match = find_file_in_other_repos(owner, repo, clean_filename)
-                if other_repo:
-                    print(f"File not found: '{clean_filename}' in {owner}/{repo}.")
-                    print(f"\n[Tip] Found '{other_match}' in repository '{other_repo}'!")
-                    print(f"To fetch it, run:\n  codefetch {owner}/{other_repo} {other_match}")
-                    return
-                else:
-                    print(f"File not found: '{clean_filename}' in {owner}/{repo}.")
-                    print(f"Run 'codefetch -l {owner}/{repo}' to see available files.")
-                    return
-        except urllib.error.HTTPError as e:
-            if e.code == 404:
-                print(f"Repository or branch not found: {owner}/{repo} ({branch})")
-            else:
-                print(f"Could not search repository: HTTP {e.code}")
-            return
-        except urllib.error.URLError:
-            print("Could not connect to GitHub.")
-            return
+            content = fetch_raw_single(owner, repo, default_branch, clean_filename)
         except UnicodeDecodeError:
             print("The file is not UTF-8 text, so it cannot be displayed or saved as text.")
             return
-        except Exception:
-            print(f"File not found: '{clean_filename}' in {owner}/{repo}.")
+        except urllib.error.HTTPError as e:
+            if e.code != 404:
+                print(f"Download failed: HTTP {e.code}")
+                return
+        except urllib.error.URLError:
+            print("Could not connect to GitHub.")
             return
 
+        if content is None:
+            try:
+                tree_data = get_repo_tree(owner, repo, default_branch)
+                matched = resolve_file_in_tree(tree_data, clean_filename)
+                if matched:
+                    resolved_path = matched
+                    content = download_url(f"https://raw.githubusercontent.com/{owner}/{repo}/{default_branch}/{resolved_path}")
+                    if resolved_path != clean_filename:
+                        print(f"(Resolved '{clean_filename}' -> '{resolved_path}')")
+                else:
+                    other_repo, other_match = find_file_in_other_repos(owner, repo, clean_filename)
+                    if other_repo:
+                        print(f"File not found: '{clean_filename}' in {owner}/{repo} ({default_branch}).")
+                        print(f"\n[Tip] Found '{other_match}' in repository '{other_repo}'!")
+                        print(f"To fetch it, run:\n  codefetch {owner}/{other_repo} {other_match}")
+                        return
+                    else:
+                        print(f"File not found: '{clean_filename}' in {owner}/{repo} ({default_branch}).")
+                        print(f"Run 'codefetch -l {owner}/{repo}' to see available files.")
+                        return
+            except urllib.error.HTTPError as e:
+                print(f"Could not search repository: HTTP {e.code}")
+                return
+            except urllib.error.URLError:
+                print("Could not connect to GitHub.")
+                return
+            except Exception:
+                print(f"File not found: '{clean_filename}' in {owner}/{repo} ({default_branch}).")
+                return
+
     if content is None:
         return
 
@@ -494,6 +633,56 @@ def fetch_file(filename, owner=None, repo=None, branch=DEFAULT_BRANCH,
             print(f"Error saving file '{out_name}': {e}")
 
 
+def parse_version_tuple(v_str):
+    """Parse version string like '1.2.5' into a comparable tuple of integers."""
+    try:
+        return tuple(int(x) for x in re.findall(r"\d+", v_str))
+    except Exception:
+        return (0,)
+
+
+def update_codefetch():
+    """Update codefetch-cli to the latest version from PyPI."""
+    print("Checking for updates from PyPI...")
+    package_name = "codefetch-cli"
+    latest_version = None
+
+    try:
+        url = f"https://pypi.org/pypi/{package_name}/json"
+        req = urllib.request.Request(url, headers={"User-Agent": "codefetch"})
+        with urllib.request.urlopen(req, timeout=10) as resp:
+            data = json.loads(resp.read().decode("utf-8"))
+            latest_version = data.get("info", {}).get("version")
+    except Exception as e:
+        print(f"Note: Could not check PyPI metadata ({e}).")
+
+    if latest_version:
+        curr_tuple = parse_version_tuple(__version__)
+        latest_tuple = parse_version_tuple(latest_version)
+
+        if latest_tuple <= curr_tuple:
+            print(f"CodeFetch is already up to date (version {__version__}).")
+            return
+
+        print(f"Update available: v{latest_version} (current: v{__version__})")
+        print(f"Updating {package_name}...")
+    else:
+        print(f"Updating {package_name} to latest version...")
+
+    cmd = [sys.executable, "-m", "pip", "install", "--upgrade", package_name]
+    try:
+        result = subprocess.run(cmd)
+        if result.returncode == 0:
+            target_v = f"v{latest_version}" if latest_version else "the latest version"
+            print(f"\nSuccessfully updated CodeFetch to {target_v}!")
+        else:
+            print(f"\nUpdate failed (exit code {result.returncode}).")
+            print(f"You can manually update with: pip install --upgrade {package_name}")
+    except Exception as e:
+        print(f"\nError running update: {e}")
+        print(f"You can manually update with: pip install --upgrade {package_name}")
+
+
 class CodefetchParser(argparse.ArgumentParser):
     """Custom parser providing clean, intuitive help formatting."""
 
@@ -518,12 +707,13 @@ def build_parser():
     parser.add_argument("-R", "--repos", action="store_true", help="List public repositories for a user")
     parser.add_argument("-r", "--repo", type=str, help="Repository name or URL")
     parser.add_argument("-u", "--user", type=str, help="GitHub username")
-    parser.add_argument("-b", "--branch", type=str, help="Branch name (default: main)")
+    parser.add_argument("-b", "--branch", type=str, default=None, help="Branch name (default: repository default branch)")
     parser.add_argument("-o", "--output", type=str, help="Custom output filename or path")
     parser.add_argument("--set-default", type=str, help="Save default repository (e.g. owner/repo)")
     parser.add_argument("--set-default-user", type=str, help="Save default GitHub user")
     parser.add_argument("--config", action="store_true", help="Display active configuration")
     parser.add_argument("--reset-config", action="store_true", help="Reset configuration back to defaults")
+    parser.add_argument("-U", "--update", action="store_true", help="Update CodeFetch to the latest version")
     parser.add_argument("-v", "--version", action="version", version=f"%(prog)s {__version__}")
     parser.add_argument("-h", "--help", action="help", help="Show help message")
 
@@ -531,13 +721,13 @@ def build_parser():
 
 
 def resolve_invocation(positional_args, repo_flag, user_flag, branch_flag,
-                       default_owner, default_repo, default_branch):
+                       default_owner, default_repo):
     """
     Resolve arguments into (owner, repo, branch, filename).
     """
     owner = user_flag or default_owner
     repo = default_repo
-    branch = branch_flag or default_branch
+    branch = branch_flag  # None if not provided
     filename = None
 
     if repo_flag:
@@ -593,10 +783,14 @@ def main():
     parser = build_parser()
     args = parser.parse_args()
 
+    # Handle --update
+    if args.update:
+        update_codefetch()
+        return
+
     config = load_config()
     default_owner = config.get("owner", DEFAULT_OWNER)
     default_repo = config.get("repo", DEFAULT_REPO)
-    default_branch = config.get("branch", DEFAULT_BRANCH)
 
     # Handle --reset-config
     if args.reset_config:
@@ -632,12 +826,11 @@ def main():
         print("CodeFetch Configuration:")
         print(f"  Default User:        {default_owner or 'None (not set)'}")
         print(f"  Default Repository:  {default_repo or 'None (not set)'}")
-        print(f"  Default Branch:      {default_branch}")
         print(f"  Config File:         {CONFIG_FILE}")
         return
 
     owner = args.user or default_owner
-    branch = args.branch or default_branch
+    branch = args.branch  # None if not provided
 
     # Handle --repos (list repositories)
     if args.repos:
@@ -682,7 +875,6 @@ def main():
         args.branch,
         default_owner,
         default_repo,
-        default_branch,
     )
 
     if not resolved_filename:

{codefetch_cli-1.2.3.dist-info → codefetch_cli-1.2.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codefetch-cli
-Version: 1.2.3
+Version: 1.2.5
 Summary: Quickly fetch code files from GitHub repositories with simple commands
 Home-page: https://github.com/InzamamulQureshi/Codefetch
 Author: Inzamamul Qureshi
@@ -35,6 +35,7 @@ CodeFetch is a lightweight command-line utility and Python library designed to q
 - **Automatic Path & Case Resolution**: Automatically resolves case mismatches and finds files nested inside subdirectories.
 - **Repository Discovery**: List all public repositories for any GitHub user with `--repos`.
 - **Tree Exploration**: List all supported code files within a repository with `--list`.
+- **Self-Updating**: Keep CodeFetch updated to the latest PyPI release with `codefetch --update`.
 - **Python Library Support**: Import and use programmatically with `import codefetch as cf`.
 - **Optional Persistent Defaults**: Save a default repository or user with `--set-default` if you frequently work with the same repository.
 - **Zero Runtime Dependencies**: Built using only the Python standard library with zero third-party dependencies.
@@ -129,6 +130,13 @@ codefetch --config
 codefetch --reset-config
 ```
 
+### 5. Self-Updating
+
+```bash
+# Update CodeFetch to the latest version published on PyPI
+codefetch --update
+```
+
 ---
 
 ## Python API Usage
@@ -163,11 +171,12 @@ print(f"Found {len(files)} files")
 | `-R`, `--repos` | List public repositories for a user | `codefetch -R -u username` |
 | `-r`, `--repo` | Specify repository name or URL | `codefetch -r repo main.py` |
 | `-u`, `--user` | Specify GitHub username or organization | `codefetch -u username -r repo main.py` |
-| `-b`, `--branch` | Branch name (default: `main`) | `codefetch -b master owner/repo Makefile` |
+| `-b`, `--branch` | Branch name (default: repo default branch) | `codefetch -b master owner/repo Makefile` |
 | `--set-default` | Set persistent default repository | `codefetch --set-default owner/repo` |
 | `--set-default-user` | Set persistent default user | `codefetch --set-default-user username` |
 | `--config` | Display active configuration | `codefetch --config` |
 | `--reset-config` | Reset configuration back to defaults | `codefetch --reset-config` |
+| `-U`, `--update` | Update CodeFetch to latest PyPI version | `codefetch --update` |
 | `-v`, `--version` | Display version information | `codefetch --version` |
 | `-h`, `--help` | Display help and usage message | `codefetch --help` |
 

codefetch_cli-1.2.5.dist-info/RECORD

@@ -0,0 +1,8 @@
+codefetch/__init__.py,sha256=TnExw5rEX9F0Y72dvp-rNut71JfVHBT6jco4-x8nfmE,5049
+codefetch/cli.py,sha256=UC-ZpV3kYJ2zuAmOCD64YgT3unnhPAMDhYQ4a5TNTUo,33929
+codefetch_cli-1.2.5.dist-info/licenses/LICENSE,sha256=hqEPPm8jxPava5BfKIj3wTIXNyWNwsIvPv2daPCOijY,1094
+codefetch_cli-1.2.5.dist-info/METADATA,sha256=gjQ8dwKPqb3v-AyGvurQV0oD6XX00SLulqvkFcbiYNU,6994
+codefetch_cli-1.2.5.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+codefetch_cli-1.2.5.dist-info/entry_points.txt,sha256=jFLRsBB_USeSdqjewcXZfnOzY56s0PZat7mnYkYdrXg,49
+codefetch_cli-1.2.5.dist-info/top_level.txt,sha256=kHrftHbyqugb8LQXjW1dR9uI-JFjZQJ0sUReIa45yXQ,10
+codefetch_cli-1.2.5.dist-info/RECORD,,

codefetch_cli-1.2.3.dist-info/RECORD

@@ -1,8 +0,0 @@
-codefetch/__init__.py,sha256=4eDsjK1Bul-KXSSDOJqK2OsrS_2ckHtW_n8Z_jQiC5U,4542
-codefetch/cli.py,sha256=sftww8iPXrpcOfTnbULLXPN0AXoSzKA_S-TvjSiOrQc,25531
-codefetch_cli-1.2.3.dist-info/licenses/LICENSE,sha256=hqEPPm8jxPava5BfKIj3wTIXNyWNwsIvPv2daPCOijY,1094
-codefetch_cli-1.2.3.dist-info/METADATA,sha256=pIx0QNujNrvHrf9YgdB0w1NwxFrPrBF2362xcO_NQsQ,6675
-codefetch_cli-1.2.3.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-codefetch_cli-1.2.3.dist-info/entry_points.txt,sha256=jFLRsBB_USeSdqjewcXZfnOzY56s0PZat7mnYkYdrXg,49
-codefetch_cli-1.2.3.dist-info/top_level.txt,sha256=kHrftHbyqugb8LQXjW1dR9uI-JFjZQJ0sUReIa45yXQ,10
-codefetch_cli-1.2.3.dist-info/RECORD,,