bingo-light 2.0.0

package/bingo_core/__init__.py

@@ -0,0 +1,77 @@
+"""
+bingo_core — Complete Python core library for bingo-light.
+
+AI-native fork maintenance: manages customizations as a clean patch stack
+on top of upstream. Every public method returns a dict with {"ok": True, ...}
+or raises BingoError.
+
+Python 3.8+ stdlib only. No pip dependencies.
+"""
+
+from __future__ import annotations
+
+import re
+
+# --- Constants ---
+
+VERSION = "2.0.0"
+PATCH_PREFIX = "[bl]"
+CONFIG_FILE = ".bingolight"
+BINGO_DIR = ".bingo"
+DEFAULT_TRACKING = "upstream-tracking"
+DEFAULT_PATCHES = "bingo-patches"
+MAX_PATCHES = 100
+MAX_DIFF_SIZE = 50000
+PATCH_NAME_RE = re.compile(r"^[a-zA-Z0-9][a-zA-Z0-9_-]*$")
+PATCH_NAME_MAX = 100
+CIRCUIT_BREAKER_LIMIT = 3
+RERERE_MAX_ITER = 50
+MAX_RESOLVE_ITER = 20
+SYNC_HISTORY_MAX = 50
+
+# --- Re-exports (keep `from bingo_core import X` working) ---
+
+from bingo_core.exceptions import (  # noqa: E402
+    BingoError,
+    GitError,
+    NotGitRepoError,
+    NotInitializedError,
+    DirtyTreeError,
+)
+from bingo_core.models import PatchInfo, ConflictInfo  # noqa: E402
+from bingo_core.git import Git  # noqa: E402
+from bingo_core.config import Config  # noqa: E402
+from bingo_core.state import State  # noqa: E402
+from bingo_core.repo import Repo  # noqa: E402
+
+__all__ = [
+    # Constants
+    "VERSION",
+    "PATCH_PREFIX",
+    "CONFIG_FILE",
+    "BINGO_DIR",
+    "DEFAULT_TRACKING",
+    "DEFAULT_PATCHES",
+    "MAX_PATCHES",
+    "MAX_DIFF_SIZE",
+    "PATCH_NAME_RE",
+    "PATCH_NAME_MAX",
+    "CIRCUIT_BREAKER_LIMIT",
+    "RERERE_MAX_ITER",
+    "MAX_RESOLVE_ITER",
+    "SYNC_HISTORY_MAX",
+    # Exceptions
+    "BingoError",
+    "GitError",
+    "NotGitRepoError",
+    "NotInitializedError",
+    "DirtyTreeError",
+    # Data classes
+    "PatchInfo",
+    "ConflictInfo",
+    # Classes
+    "Git",
+    "Config",
+    "State",
+    "Repo",
+]

package/bingo_core/config.py

@@ -0,0 +1,110 @@
+"""
+bingo_core.config — Configuration management for bingo-light.
+"""
+
+from __future__ import annotations
+
+import os
+import subprocess
+from typing import Optional
+
+from bingo_core import CONFIG_FILE, DEFAULT_PATCHES, DEFAULT_TRACKING
+from bingo_core.exceptions import NotInitializedError
+
+
+class Config:
+    """Manages the .bingolight configuration file (git config format)."""
+
+    def __init__(self, repo_dir: str):
+        self.repo_dir = repo_dir
+        self.config_path = os.path.join(repo_dir, CONFIG_FILE)
+
+    def exists(self) -> bool:
+        """Check if config file exists."""
+        return os.path.isfile(self.config_path)
+
+    def load(self) -> dict:
+        """Load all bingo-light config values.
+
+        Returns:
+            dict with upstream_url, upstream_branch, patches_branch, tracking_branch
+
+        Raises:
+            NotInitializedError: if config file doesn't exist
+        """
+        if not self.exists():
+            raise NotInitializedError()
+
+        return {
+            "upstream_url": self.get("upstream-url") or "",
+            "upstream_branch": self.get("upstream-branch") or "main",
+            "patches_branch": self.get("patches-branch") or DEFAULT_PATCHES,
+            "tracking_branch": self.get("tracking-branch") or DEFAULT_TRACKING,
+        }
+
+    def save(
+        self,
+        url: str,
+        branch: str,
+        patches_branch: str = DEFAULT_PATCHES,
+        tracking_branch: str = DEFAULT_TRACKING,
+    ) -> None:
+        """Write config values."""
+        self.set("upstream-url", url)
+        self.set("upstream-branch", branch)
+        self.set("patches-branch", patches_branch)
+        self.set("tracking-branch", tracking_branch)
+
+    def get(self, key: str) -> Optional[str]:
+        """Get a config value. Returns None if not found."""
+        try:
+            result = subprocess.run(
+                ["git", "config", "--file", self.config_path, f"bingolight.{key}"],
+                cwd=self.repo_dir,
+                capture_output=True,
+                text=True,
+            )
+            if result.returncode == 0:
+                return result.stdout.strip()
+            # Try without bingolight prefix
+            result = subprocess.run(
+                ["git", "config", "--file", self.config_path, key],
+                cwd=self.repo_dir,
+                capture_output=True,
+                text=True,
+            )
+            if result.returncode == 0:
+                return result.stdout.strip()
+            return None
+        except Exception:
+            return None
+
+    def set(self, key: str, value: str) -> None:
+        """Set a config value."""
+        subprocess.run(
+            ["git", "config", "--file", self.config_path, f"bingolight.{key}", value],
+            cwd=self.repo_dir,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+
+    def list_all(self) -> dict:
+        """List all config values as a dict."""
+        try:
+            result = subprocess.run(
+                ["git", "config", "--file", self.config_path, "--list"],
+                cwd=self.repo_dir,
+                capture_output=True,
+                text=True,
+            )
+            if result.returncode != 0:
+                return {}
+            items = {}
+            for line in result.stdout.strip().splitlines():
+                if "=" in line:
+                    k, v = line.split("=", 1)
+                    items[k] = v
+            return items
+        except Exception:
+            return {}

package/bingo_core/exceptions.py

@@ -0,0 +1,48 @@
+"""
+bingo_core.exceptions — Exception classes for bingo-light.
+"""
+
+from __future__ import annotations
+
+from typing import List
+
+
+class BingoError(Exception):
+    """Base error for bingo-light operations."""
+
+
+class GitError(BingoError):
+    """A git command failed."""
+
+    def __init__(self, cmd: List[str], returncode: int, stderr: str):
+        self.cmd = cmd
+        self.returncode = returncode
+        self.stderr = stderr
+        super().__init__(
+            f"git command failed (exit {returncode}): {' '.join(cmd)}\n{stderr}"
+        )
+
+
+class NotGitRepoError(BingoError):
+    """Not inside a git repository."""
+
+    def __init__(self):
+        super().__init__("Not a git repository. Run this inside a git repo.")
+
+
+class NotInitializedError(BingoError):
+    """bingo-light not initialized in this repo."""
+
+    def __init__(self):
+        super().__init__(
+            "bingo-light not initialized. Run: bingo-light init <upstream-url>"
+        )
+
+
+class DirtyTreeError(BingoError):
+    """Working tree has uncommitted changes."""
+
+    def __init__(self, msg: str = ""):
+        super().__init__(
+            msg or "Working tree is dirty. Commit or stash your changes first."
+        )

package/bingo_core/git.py

@@ -0,0 +1,194 @@
+"""
+bingo_core.git — Git subprocess wrapper.
+"""
+
+from __future__ import annotations
+
+import os
+import re
+import subprocess
+from typing import List, Optional
+
+from bingo_core.exceptions import GitError
+from bingo_core.models import PatchInfo
+
+
+class Git:
+    """Unified git subprocess wrapper. All git calls go through here."""
+
+    def __init__(self, cwd: Optional[str] = None):
+        self.cwd = cwd or os.getcwd()
+
+    def run(self, *args: str, check: bool = True) -> str:
+        """Run a git command and return stdout (stripped).
+
+        Args:
+            *args: git subcommand and arguments (e.g. "rev-parse", "HEAD")
+            check: if True, raise GitError on non-zero exit
+
+        Returns:
+            stdout as stripped string
+
+        Raises:
+            GitError: if check=True and command fails
+        """
+        cmd = ["git"] + list(args)
+        result = subprocess.run(
+            cmd,
+            cwd=self.cwd,
+            capture_output=True,
+            text=True,
+        )
+        if check and result.returncode != 0:
+            raise GitError(cmd, result.returncode, result.stderr.strip())
+        return result.stdout.strip()
+
+    def run_ok(self, *args: str) -> bool:
+        """Run a git command and return True if it succeeds."""
+        try:
+            cmd = ["git"] + list(args)
+            result = subprocess.run(
+                cmd,
+                cwd=self.cwd,
+                capture_output=True,
+                text=True,
+            )
+            return result.returncode == 0
+        except Exception:
+            return False
+
+    def run_unchecked(self, *args: str) -> subprocess.CompletedProcess:
+        """Run a git command and return the full CompletedProcess."""
+        cmd = ["git"] + list(args)
+        return subprocess.run(
+            cmd,
+            cwd=self.cwd,
+            capture_output=True,
+            text=True,
+        )
+
+    def rev_parse(self, ref: str) -> Optional[str]:
+        """Resolve a ref to a commit hash. Returns None if missing."""
+        try:
+            return self.run("rev-parse", ref)
+        except GitError:
+            return None
+
+    def rev_parse_short(self, ref: str) -> str:
+        """Resolve a ref to a short commit hash."""
+        try:
+            return self.run("rev-parse", "--short", ref)
+        except GitError:
+            return ""
+
+    def rev_list_count(self, range_spec: str) -> int:
+        """Count commits in a range. Returns 0 on error."""
+        try:
+            return int(self.run("rev-list", "--count", range_spec))
+        except (GitError, ValueError):
+            return 0
+
+    def fetch(self, remote: str) -> bool:
+        """Fetch from a remote. Returns True on success."""
+        return self.run_ok("fetch", remote)
+
+    def is_clean(self) -> bool:
+        """Check if working tree is clean (no staged or unstaged changes)."""
+        return (
+            self.run_ok("diff", "--quiet", "HEAD")
+            and self.run_ok("diff", "--cached", "--quiet")
+        )
+
+    def ls_files_unmerged(self) -> List[str]:
+        """Return list of unmerged file paths (sorted, unique)."""
+        try:
+            output = self.run("ls-files", "--unmerged", check=False)
+            if not output:
+                return []
+            files = set()
+            for line in output.splitlines():
+                # format: mode hash stage\tfilename
+                parts = line.split("\t", 1)
+                if len(parts) == 2:
+                    files.add(parts[1])
+            return sorted(files)
+        except Exception:
+            return []
+
+    def diff_names(self, range_spec: str) -> List[str]:
+        """Return list of changed file names in a range."""
+        try:
+            output = self.run("diff", "--name-only", range_spec, check=False)
+            if not output:
+                return []
+            return sorted(set(output.splitlines()))
+        except Exception:
+            return []
+
+    def merge_base(self, ref1: str, ref2: str) -> Optional[str]:
+        """Find merge base of two refs. Returns None if not found."""
+        try:
+            return self.run("merge-base", ref1, ref2)
+        except GitError:
+            return None
+
+    def current_branch(self) -> str:
+        """Return name of current branch."""
+        try:
+            return self.run("branch", "--show-current")
+        except GitError:
+            return ""
+
+    def log_patches(self, base: str, branch: str) -> List[PatchInfo]:
+        """Parse patches from git log in a single pass.
+
+        Returns list of PatchInfo for commits in base..branch.
+        """
+        try:
+            output = self.run(
+                "log",
+                "--format=PATCH\t%h\t%s",
+                "--shortstat",
+                "--numstat",
+                "--reverse",
+                f"{base}..{branch}",
+            )
+        except GitError:
+            return []
+
+        patches: List[PatchInfo] = []
+        current: Optional[PatchInfo] = None
+
+        for line in output.splitlines():
+            if line.startswith("PATCH\t"):
+                if current is not None:
+                    patches.append(current)
+                parts = line.split("\t", 2)
+                hash_val = parts[1] if len(parts) > 1 else ""
+                subject = parts[2] if len(parts) > 2 else ""
+                name = ""
+                m = re.match(r"^\[bl\] ([^:]+):", subject)
+                if m:
+                    name = m.group(1)
+                current = PatchInfo(
+                    name=name, hash=hash_val, subject=subject, files=0, stat=""
+                )
+            elif current is not None:
+                # numstat line: add\tdel\tfile (binary shows -\t-\tfile)
+                if re.match(r"^(\d+|-)\t(\d+|-)\t", line):
+                    current.files += 1
+                    parts = line.split("\t", 2)
+                    if len(parts) >= 2:
+                        try:
+                            current.insertions += int(parts[0])
+                            current.deletions += int(parts[1])
+                        except ValueError:
+                            pass  # binary: -\t-\t — counted but no line stats
+                # shortstat line
+                elif re.match(r"^\s*\d+ file", line):
+                    current.stat = line.strip()
+
+        if current is not None:
+            patches.append(current)
+
+        return patches

package/bingo_core/models.py

@@ -0,0 +1,37 @@
+"""
+bingo_core.models — Data classes for bingo-light.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, asdict
+
+
+@dataclass
+class PatchInfo:
+    """Information about a single patch in the stack."""
+
+    name: str
+    hash: str
+    subject: str
+    files: int = 0
+    stat: str = ""
+    insertions: int = 0
+    deletions: int = 0
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+
+@dataclass
+class ConflictInfo:
+    """Information about a conflict in a single file."""
+
+    file: str
+    ours: str = ""
+    theirs: str = ""
+    conflict_count: int = 0
+    merge_hint: str = ""
+
+    def to_dict(self) -> dict:
+        return asdict(self)