bitp 1.0.6__py3-none-any.whl

bitbake_project/commands/repos.py

@@ -0,0 +1,154 @@
+#
+# Copyright (C) 2025 Bruce Ashfield <bruce.ashfield@gmail.com>
+#
+# SPDX-License-Identifier: GPL-2.0-only
+#
+"""Repos command - list layer repositories."""
+
+import os
+import subprocess
+import sys
+from typing import List, Optional, Tuple
+
+from ..core import Colors, current_branch, load_defaults, repo_is_clean, terminal_color
+from .common import (
+    resolve_base_and_layers,
+    repo_display_name,
+    get_upstream_count_ls_remote,
+)
+
+from .update import fetch_repo, get_upstream_commits
+
+def run_repos(args) -> int:
+    """List repos, optionally with one-liner status."""
+    defaults = load_defaults(args.defaults_file)
+    pairs, repo_sets = resolve_base_and_layers(args.bblayers, defaults)
+
+    repo_layers: Dict[str, List[str]] = {}
+    for layer, repo in pairs:
+        repo_layers.setdefault(repo, []).append(layer)
+
+    show_status = args.repos_command == "status"
+    do_fetch = show_status and getattr(args, "fetch", False)
+
+    # Optionally fetch first
+    if do_fetch:
+        print("Fetching from origin...")
+        for repo in repo_layers.keys():
+            if defaults.get(repo, "rebase") != "skip":
+                fetch_repo(repo)
+
+    for repo in repo_layers.keys():
+        is_discovered = repo in repo_sets.discovered
+        discovered_marker = " (?)" if is_discovered else ""
+
+        if not show_status:
+            # Simple list mode
+            print(f"{repo}{discovered_marker}")
+            continue
+
+        # Status mode: one-liner per repo
+        default_action = defaults.get(repo, "rebase")
+        if default_action == "skip":
+            print(f"→ {repo}{discovered_marker}: default=skip")
+            continue
+
+        branch = current_branch(repo)
+        if not branch:
+            is_clean = repo_is_clean(repo)
+            worktree_status = Colors.green("[clean]") if is_clean else Colors.red("[DIRTY]")
+            print(f"→ {repo}{discovered_marker}: detached HEAD {worktree_status}")
+            continue
+
+        remote_ref = f"origin/{branch}"
+        remote_exists = (
+            subprocess.run(
+                ["git", "-C", repo, "rev-parse", "--verify", remote_ref],
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+            ).returncode
+            == 0
+        )
+
+        # Get commit counts
+        local_count = 0
+        upstream_count = 0
+        upstream_unknown = False
+
+        if remote_exists:
+            # Local commits (always use local refs)
+            try:
+                out = subprocess.check_output(
+                    ["git", "-C", repo, "rev-list", "--count", f"{remote_ref}..HEAD"],
+                    text=True,
+                    stderr=subprocess.DEVNULL,
+                )
+                local_count = int(out.strip())
+            except (subprocess.CalledProcessError, ValueError):
+                pass
+
+            # Upstream commits - use ls-remote unless we just fetched
+            if do_fetch:
+                try:
+                    out = subprocess.check_output(
+                        ["git", "-C", repo, "rev-list", "--count", f"HEAD..{remote_ref}"],
+                        text=True,
+                        stderr=subprocess.DEVNULL,
+                    )
+                    upstream_count = int(out.strip())
+                except (subprocess.CalledProcessError, ValueError):
+                    pass
+            else:
+                result = get_upstream_count_ls_remote(repo, branch)
+                if result is None:
+                    pass  # No remote tracking
+                elif result == -1:
+                    upstream_unknown = True  # Has changes but can't count
+                else:
+                    upstream_count = result
+
+        is_clean = repo_is_clean(repo)
+
+        # Build status parts
+        status_parts = []
+        if local_count:
+            status_parts.append(f"{local_count} local commit(s)")
+        if upstream_unknown:
+            status_parts.append(terminal_color("upstream", "upstream has changes"))
+        elif upstream_count:
+            status_parts.append(terminal_color("upstream", f"{upstream_count} to pull"))
+        if not status_parts:
+            status_parts.append("up-to-date")
+
+        # Format with colors
+        if is_clean:
+            if is_discovered:
+                repo_display = terminal_color("repo_discovered", f"{repo}{discovered_marker}")
+                worktree_status = terminal_color("clean", "[clean]")
+            else:
+                repo_display = terminal_color("repo", f"{repo}{discovered_marker}")
+                worktree_status = terminal_color("clean", "[clean]")
+        else:
+            repo_display = f"{repo}{discovered_marker}"
+            worktree_status = terminal_color("dirty", "[DIRTY]")
+
+        branch_display = Colors.bold(branch)
+        print(f"→ {repo_display}: {', '.join(status_parts)} on {branch_display} {worktree_status}")
+
+    return 0
+
+
+def diffstat_for_range(repo: str, range_spec: str) -> str:
+    try:
+        if range_spec == "--root":
+            empty = subprocess.check_output(
+                ["git", "-C", repo, "hash-object", "-t", "tree", "/dev/null"], text=True
+            ).strip()
+            return subprocess.check_output(
+                ["git", "-C", repo, "diff", "--stat", f"{empty}..HEAD"], text=True
+            ).strip()
+        return subprocess.check_output(["git", "-C", repo, "diff", "--stat", range_spec], text=True).strip()
+    except subprocess.CalledProcessError:
+        return ""
+
+

bitbake_project/commands/search.py

@@ -0,0 +1,313 @@
+#
+# Copyright (C) 2025 Bruce Ashfield <bruce.ashfield@gmail.com>
+#
+# SPDX-License-Identifier: GPL-2.0-only
+#
+"""Search command - search OpenEmbedded Layer Index."""
+
+import json
+import os
+import shutil
+import subprocess
+import sys
+import urllib.request
+from typing import List, Optional
+
+from ..core import Colors, get_fzf_color_args, get_fzf_preview_resize_bindings
+from .init import _fetch_layer_index, _fetch_layer_dependencies
+
+def run_search(args) -> int:
+    """Search OpenEmbedded Layer Index for layers."""
+    branch = args.branch
+    query = args.query
+    force = getattr(args, "force", False)
+
+    # Fetch layers (from cache or API)
+    data = _fetch_layer_index(force=force)
+    if data is None:
+        return 1
+
+    # Filter by branch and deduplicate
+    seen = set()
+    layers = []
+    for entry in data:
+        entry_branch = entry.get("branch", {}).get("name", "")
+        if entry_branch != branch:
+            continue
+        layer_info = entry.get("layer", {})
+        name = layer_info.get("name", "")
+        if name in seen:
+            continue
+        seen.add(name)
+        layers.append({
+            "name": name,
+            "summary": layer_info.get("summary", ""),
+            "description": layer_info.get("description", ""),
+            "vcs_url": layer_info.get("vcs_url", ""),
+            "vcs_subdir": entry.get("vcs_subdir", ""),
+        })
+
+    # Filter by query if provided
+    if query:
+        query_lower = query.lower()
+        layers = [
+            l for l in layers
+            if query_lower in l["name"].lower()
+            or query_lower in l["summary"].lower()
+            or query_lower in l["description"].lower()
+        ]
+
+    if not layers:
+        if query:
+            print(f"No layers found matching '{query}' on branch '{branch}'")
+        else:
+            print(f"No layers found on branch '{branch}'")
+        return 1
+
+    # Handle --clone flag
+    do_clone = getattr(args, "clone", False)
+    clone_target = getattr(args, "target", None)
+    if do_clone:
+        # Try exact match first
+        exact = next((l for l in layers if l["name"].lower() == query.lower()), None) if query else None
+        if exact:
+            layer = exact
+        elif len(layers) == 1:
+            layer = layers[0]
+        else:
+            print(f"Multiple layers match '{query}' - be more specific or use exact name:")
+            for l in sorted(layers, key=lambda x: x["name"])[:10]:
+                print(f"  {l['name']}")
+            if len(layers) > 10:
+                print(f"  ... and {len(layers) - 10} more")
+            return 1
+
+        if not layer["vcs_url"]:
+            print(f"No VCS URL for {layer['name']}")
+            return 1
+
+        # Show dependencies
+        deps = _fetch_layer_dependencies(layer["name"], branch)
+        if deps:
+            required = [d["name"] for d in deps if d["required"]]
+            optional = [d["name"] for d in deps if not d["required"]]
+            if required:
+                print(f"{Colors.yellow('Dependencies')}: {', '.join(required)}")
+            if optional:
+                print(f"{Colors.dim('Optional')}: {', '.join(optional)}")
+
+        # Determine target directory
+        target = clone_target or f"layers/{layer['name']}"
+        if os.path.exists(target):
+            print(f"Target already exists: {target}")
+            return 1
+
+        print(f"Cloning {layer['name']} ({layer['vcs_url']}) -> {target}")
+        try:
+            subprocess.run(
+                ["git", "clone", "-b", branch, layer["vcs_url"], target],
+                check=True,
+            )
+            print(f"{Colors.green('Done.')}")
+            if layer["vcs_subdir"]:
+                print(f"Layer path: {target}/{layer['vcs_subdir']}")
+            return 0
+        except subprocess.CalledProcessError as e:
+            print(f"{Colors.red('Clone failed')}: {e}")
+            return 1
+
+    # Handle --info flag (scriptable output)
+    do_info = getattr(args, "info", False)
+    if do_info:
+        if not query:
+            print("Error: --info requires a layer name", file=sys.stderr)
+            return 1
+        # Try exact match first
+        exact = next((l for l in layers if l["name"].lower() == query.lower()), None)
+        if exact:
+            layer = exact
+        elif len(layers) == 1:
+            layer = layers[0]
+        else:
+            print(f"Error: Multiple layers match '{query}' - be more specific:", file=sys.stderr)
+            for l in sorted(layers, key=lambda x: x["name"])[:10]:
+                print(f"  {l['name']}", file=sys.stderr)
+            return 1
+
+        # Output machine-readable info
+        print(f"name={layer['name']}")
+        print(f"url={layer['vcs_url']}")
+        if layer["vcs_subdir"]:
+            print(f"subdir={layer['vcs_subdir']}")
+        deps = _fetch_layer_dependencies(layer["name"], branch)
+        if deps:
+            required = [d["name"] for d in deps if d["required"]]
+            optional = [d["name"] for d in deps if not d["required"]]
+            if required:
+                print(f"depends={','.join(required)}")
+            if optional:
+                print(f"optional={','.join(optional)}")
+        return 0
+
+    # Calculate max name length for alignment
+    max_name_len = max(len(l["name"]) for l in layers)
+    max_name_len = min(max_name_len, 35)  # Cap at 35 chars
+
+    # Interactive selection with fzf if available
+    if shutil.which("fzf") and not query:
+        # Build menu for fzf with alignment
+        # Format: name\tdisplay\tsummary\tdescription\tvcs_url\tvcs_subdir
+        menu_lines = []
+        for l in sorted(layers, key=lambda x: x["name"]):
+            name = l["name"][:35]
+            summary = l["summary"][:50] if l["summary"] else ""
+            display = f"{name:<{max_name_len}}  {summary}"
+            # Escape special chars in description for shell
+            desc = l["description"].replace("'", "'\\''").replace("\n", " ") if l["description"] else ""
+            vcs_url = l["vcs_url"] or ""
+            vcs_subdir = l["vcs_subdir"] or ""
+            menu_lines.append(f"{l['name']}\t{display}\t{desc}\t{vcs_url}\t{vcs_subdir}")
+
+        # Preview command to format layer details
+        preview_cmd = r'''
+            echo -e "\033[1m{1}\033[0m"
+            echo
+            echo "{3}" | fold -s -w 70
+            echo
+            if [ -n "{4}" ]; then
+                echo -e "\033[36mClone:\033[0m git clone {4}"
+            fi
+            if [ -n "{5}" ]; then
+                echo -e "\033[36mLayer:\033[0m {5}"
+            fi
+        '''
+
+        while True:
+            try:
+                result = subprocess.run(
+                    [
+                        "fzf",
+                        "--height", "~70%",
+                        "--header", f"OpenEmbedded Layers ({branch}) | Enter=copy clone cmd | Ctrl-y=clone | ?=preview | Esc=quit",
+                        "--prompt", "Search: ",
+                        "--with-nth", "2",
+                        "--delimiter", "\t",
+                        "--preview", preview_cmd,
+                        "--preview-window", "right:50%:wrap",
+                        "--bind", "?:toggle-preview",
+                        "--bind", r"ctrl-y:become(printf 'CLONE\t%s\t%s\n' {1} {4})",
+                    ] + get_fzf_preview_resize_bindings() + get_fzf_color_args(),
+                    input="\n".join(menu_lines),
+                    stdout=subprocess.PIPE,
+                    text=True,
+                )
+            except FileNotFoundError:
+                break
+
+            if result.returncode != 0 or not result.stdout.strip():
+                break
+
+            output = result.stdout.strip()
+
+            if output.startswith("CLONE\t"):
+                # Clone the layer repo - output is "CLONE\t<name>\t<url>"
+                parts = output.split("\t")
+                layer_name = parts[1] if len(parts) > 1 else ""
+                vcs_url = parts[2] if len(parts) > 2 else ""
+                if not vcs_url:
+                    print(f"\n  No VCS URL for {layer_name}")
+                    continue
+
+                # Show dependencies
+                print()
+                deps = _fetch_layer_dependencies(layer_name, branch)
+                if deps:
+                    required = [d["name"] for d in deps if d["required"]]
+                    optional = [d["name"] for d in deps if not d["required"]]
+                    if required:
+                        print(f"  {Colors.yellow('Dependencies')}: {', '.join(required)}")
+                    if optional:
+                        print(f"  {Colors.dim('Optional')}: {', '.join(optional)}")
+
+                # Prompt for target directory
+                default_target = f"layers/{layer_name}"
+                try:
+                    target = input(f"Clone {layer_name} to [{default_target}]: ").strip()
+                except (EOFError, KeyboardInterrupt):
+                    print("\nCancelled.")
+                    continue
+                if not target:
+                    target = default_target
+
+                if os.path.exists(target):
+                    print(f"  {Colors.yellow('exists')}: {target}")
+                    continue
+
+                print(f"  Cloning {vcs_url} -> {target}...")
+                try:
+                    subprocess.run(
+                        ["git", "clone", "-b", branch, vcs_url, target],
+                        check=True,
+                    )
+                    print(f"  {Colors.green('done')}")
+                except subprocess.CalledProcessError as e:
+                    print(f"  {Colors.red('failed')}: {e}")
+                continue
+
+            # Enter was pressed - show details
+            selected_name = output.split("\t")[0]
+            selected = next((l for l in layers if l["name"] == selected_name), None)
+            if selected:
+                _show_layer_details(selected, branch)
+
+        return 0
+
+    # Text output with alignment
+    print(f"\n{Colors.bold(f'Layers on {branch} branch')} ({len(layers)} results)\n")
+    for l in sorted(layers, key=lambda x: x["name"]):
+        name = l["name"][:35]
+        summary = l["summary"][:60] if l["summary"] else ""
+        print(f"  {Colors.green(f'{name:<{max_name_len}}')}  {summary}")
+        if l["vcs_url"]:
+            subdir = f" (subdir: {l['vcs_subdir']})" if l["vcs_subdir"] else ""
+            print(f"  {' ' * max_name_len}  {Colors.dim(l['vcs_url'])}{Colors.dim(subdir)}")
+
+    return 0
+
+
+def _show_layer_details(layer: dict, branch: str) -> None:
+    """Show detailed info for a layer and offer to clone."""
+    print()
+    print(f"  {Colors.bold(layer['name'])}")
+    print()
+    if layer["summary"]:
+        print(f"  {layer['summary']}")
+        print()
+    if layer["description"]:
+        # Word wrap description
+        desc = layer["description"]
+        for line in desc.split("\n"):
+            print(f"  {line}")
+        print()
+    if layer["vcs_url"]:
+        print(f"  {Colors.cyan('Clone:')} git clone {layer['vcs_url']}")
+        if layer["vcs_subdir"]:
+            print(f"  {Colors.cyan('Layer path:')} {layer['vcs_subdir']}")
+        print()
+
+    # Offer to copy clone command
+    clone_cmd = f"git clone {layer['vcs_url']}"
+    if layer["vcs_subdir"]:
+        clone_cmd += f"  # layer in: {layer['vcs_subdir']}"
+
+    try:
+        if shutil.which("xclip"):
+            subprocess.run(["xclip", "-selection", "clipboard"], input=clone_cmd.encode(), check=True)
+            print(Colors.dim("  (clone command copied to clipboard)"))
+        elif shutil.which("xsel"):
+            subprocess.run(["xsel", "--clipboard", "--input"], input=clone_cmd.encode(), check=True)
+            print(Colors.dim("  (clone command copied to clipboard)"))
+    except Exception:
+        pass
+
+

bitbake_project/commands/update.py

@@ -0,0 +1,181 @@
+#
+# Copyright (C) 2025 Bruce Ashfield <bruce.ashfield@gmail.com>
+#
+# SPDX-License-Identifier: GPL-2.0-only
+#
+"""Update command - git pull/rebase layer repositories."""
+
+import subprocess
+import sys
+from typing import List, Optional, Tuple
+
+from ..core import (
+    Colors,
+    current_branch,
+    load_defaults,
+    save_defaults,
+)
+from .common import (
+    collect_repos,
+    find_repo_by_identifier,
+    load_resume,
+    save_resume,
+    prompt_action,
+    run_cmd,
+    repo_display_name,
+)
+
+def run_update(args) -> int:
+    defaults = load_defaults(args.defaults_file)
+    discover_all = getattr(args, 'all', False)
+    repos, _repo_sets = collect_repos(args.bblayers, defaults, discover_all=discover_all)
+
+    # If specific repo requested, filter to just that one
+    if getattr(args, 'repo', None):
+        target_repo = find_repo_by_identifier(repos, args.repo, defaults)
+        if not target_repo:
+            print(f"Repo not found: {args.repo}")
+            return 1
+        repos = [target_repo]
+
+    resume_state = load_resume(args.resume_file) if args.resume else None
+    next_idx = 0
+    if resume_state:
+        saved_idx, saved_repos = resume_state
+        if saved_repos == repos and 0 <= saved_idx < len(repos):
+            next_idx = saved_idx
+            print(f"Resuming from index {next_idx+1}/{len(repos)} using {args.resume_file}.")
+        else:
+            print("Resume data does not match current layer repos; starting over.")
+
+    if args.resume:
+        save_resume(args.resume_file, next_idx, repos)
+
+    completed = False
+    idx = next_idx - 1
+    try:
+        for idx in range(next_idx, len(repos)):
+            repo = repos[idx]
+            default_action = defaults.get(repo, "rebase")
+            branch = current_branch(repo)
+            action = prompt_action(repo, branch, default_action, use_fzf=not args.plain)
+            if action is None:
+                continue
+            op, target, new_default = action
+
+            if new_default:
+                defaults[repo] = new_default
+                save_defaults(args.defaults_file, defaults)
+
+            if op == "quit":
+                print("Aborting on user request.")
+                break
+            if op == "skip":
+                if args.resume:
+                    save_resume(args.resume_file, idx + 1, repos)
+                continue
+
+            if op == "custom":
+                print(f"Custom command in {repo}")
+                run_cmd(repo, target, args.dry_run, shell=True)
+            else:
+                remote_ref = f"origin/{target}"
+                verb = "pull --rebase" if op == "rebase" else "pull"
+                print(f"Updating {repo}: git {verb} {remote_ref}")
+                if op == "rebase":
+                    run_cmd(repo, ["git", "pull", "--rebase", "origin", target], args.dry_run)
+                elif op == "merge":
+                    run_cmd(repo, ["git", "pull", "origin", target], args.dry_run)
+
+            if args.resume:
+                save_resume(args.resume_file, idx + 1, repos)
+        else:
+            completed = True
+    except subprocess.CalledProcessError as exc:
+        print(f"Command failed in {repo}: {exc}")
+        return exc.returncode or 1
+
+    if args.resume and completed and os.path.exists(args.resume_file):
+        os.remove(args.resume_file)
+
+    return 0
+
+
+def get_repo_log(repo: str, branch: str, remote_exists: bool, max_commits: int, show_all: bool) -> Tuple[str, List[str]]:
+    remote_ref = f"origin/{branch}"
+    log_args = ["git", "-C", repo, "log", "--oneline"]
+    desc = ""
+    if remote_exists:
+        log_args.append(f"{remote_ref}..HEAD")
+        desc = f"local commits vs {remote_ref}"
+    else:
+        log_args.extend(["-n", str(max_commits if not show_all else 1000000)])
+        desc = f"recent commits (no {remote_ref})"
+
+    try:
+        out = subprocess.check_output(log_args, text=True)
+    except subprocess.CalledProcessError:
+        return "failed to read log", []
+
+    lines = [line for line in out.strip().splitlines() if line.strip()]
+    return desc, lines
+
+
+def get_upstream_commits(repo: str, branch: str) -> List[str]:
+    """Get commits in origin/<branch> that are not in HEAD (pending upstream changes)."""
+    remote_ref = f"origin/{branch}"
+    try:
+        out = subprocess.check_output(
+            ["git", "-C", repo, "log", "--oneline", f"HEAD..{remote_ref}"],
+            text=True,
+            stderr=subprocess.DEVNULL,
+        )
+        return [line for line in out.strip().splitlines() if line.strip()]
+    except subprocess.CalledProcessError:
+        return []
+
+
+def fetch_repo(repo: str) -> bool:
+    """Fetch from origin. Returns True on success."""
+    try:
+        subprocess.run(
+            ["git", "-C", repo, "fetch", "origin"],
+            check=True,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+        return True
+    except subprocess.CalledProcessError:
+        return False
+
+
+
+def run_single_repo_update(repo: str, branch: str, action: str) -> bool:
+    """Run update for a single repo. action: 'rebase' or 'merge'. Returns True on success."""
+    if not branch:
+        print(f"  No branch (detached HEAD)")
+        return False
+
+    try:
+        if action == "rebase":
+            print(f"  git pull --rebase origin/{branch}")
+            subprocess.run(
+                ["git", "-C", repo, "pull", "--rebase", "origin", branch],
+                check=True,
+            )
+        elif action == "merge":
+            print(f"  git pull origin/{branch}")
+            subprocess.run(
+                ["git", "-C", repo, "pull", "origin", branch],
+                check=True,
+            )
+        else:
+            return False
+
+        print(f"  Done.")
+        return True
+    except subprocess.CalledProcessError as e:
+        print(f"  Failed: {e}")
+        return False
+
+