bingo-light 2.1.2 → 2.2.0

package/bingo_core/decisions.py

@@ -0,0 +1,167 @@
+"""
+bingo_core.decisions — per-patch conflict-resolution memory.
+
+Complements git rerere (which keys by literal conflict text) with a
+pattern-level memory: records how patch X was resolved against upstream
+commit Y, keyed by (patch_name, file, semantic_class). When the same
+patch conflicts again in a similar pattern, previous decisions are
+surfaced to the AI during conflict-analyze so it can consider the
+prior choice.
+
+Storage: .bingo/decisions/<patch-name>.json, one file per patch.
+This avoids hot contention and keeps each patch's history isolated.
+
+Python 3.8+ stdlib only. No external dependencies.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+from datetime import datetime, timezone
+from typing import List, Optional
+
+# Patch name constraint mirrors PATCH_NAME_RE to keep filenames safe.
+_SAFE_PATCH_NAME = re.compile(r"^[a-zA-Z0-9][a-zA-Z0-9_-]*$")
+MAX_DECISIONS_PER_PATCH = 50
+
+
+class DecisionMemory:
+    """Per-patch decision log stored under .bingo/decisions/."""
+
+    def __init__(self, repo_path: str):
+        self.repo_path = repo_path
+        self.dir = os.path.join(repo_path, ".bingo", "decisions")
+
+    def _path_for(self, patch_name: str) -> Optional[str]:
+        if not patch_name or not _SAFE_PATCH_NAME.match(patch_name):
+            return None
+        return os.path.join(self.dir, f"{patch_name}.json")
+
+    def _load_all(self, patch_name: str) -> List[dict]:
+        path = self._path_for(patch_name)
+        if not path or not os.path.isfile(path):
+            return []
+        try:
+            with open(path) as f:
+                data = json.load(f)
+        except (IOError, OSError, json.JSONDecodeError):
+            return []
+        decisions = data.get("decisions", [])
+        return decisions if isinstance(decisions, list) else []
+
+    def _save_all(self, patch_name: str, decisions: List[dict]) -> None:
+        path = self._path_for(patch_name)
+        if not path:
+            return
+        os.makedirs(self.dir, exist_ok=True)
+        tmp = path + ".tmp"
+        try:
+            with open(tmp, "w") as f:
+                json.dump(
+                    {"patch": patch_name, "decisions": decisions},
+                    f, indent=2,
+                )
+            os.replace(tmp, path)
+        except (IOError, OSError):
+            try:
+                os.unlink(tmp)
+            except OSError:
+                pass
+
+    def record(
+        self,
+        patch_name: str,
+        file: str,
+        semantic_class: str,
+        resolution_strategy: str,
+        upstream_sha: Optional[str] = None,
+        upstream_subject: Optional[str] = None,
+        notes: str = "",
+    ) -> None:
+        """Append one decision for a patch.
+
+        Silently no-ops if patch_name is empty or invalid. The newest
+        MAX_DECISIONS_PER_PATCH entries are retained; older entries are
+        dropped FIFO to keep files bounded.
+        """
+        if not patch_name or not _SAFE_PATCH_NAME.match(patch_name):
+            return
+        entry = {
+            "timestamp": datetime.now(timezone.utc).strftime(
+                "%Y-%m-%dT%H:%M:%SZ"
+            ),
+            "file": file,
+            "semantic_class": semantic_class,
+            "resolution_strategy": resolution_strategy,
+            "upstream_sha": upstream_sha,
+            "upstream_subject": upstream_subject,
+            "notes": notes,
+        }
+        decisions = self._load_all(patch_name)
+        decisions.append(entry)
+        if len(decisions) > MAX_DECISIONS_PER_PATCH:
+            decisions = decisions[-MAX_DECISIONS_PER_PATCH:]
+        self._save_all(patch_name, decisions)
+
+    def lookup(
+        self,
+        patch_name: str,
+        file: Optional[str] = None,
+        semantic_class: Optional[str] = None,
+        limit: int = 5,
+    ) -> List[dict]:
+        """Return up to `limit` previous decisions, most-recent first,
+        ranked by relevance to the given file/semantic_class.
+
+        Ranking: +2 if file matches, +1 if semantic_class matches.
+        Ties broken by recency.
+        """
+        decisions = self._load_all(patch_name)
+        if not decisions:
+            return []
+
+        def score(d: dict) -> tuple:
+            relevance = 0
+            if file and d.get("file") == file:
+                relevance += 2
+            if semantic_class and d.get("semantic_class") == semantic_class:
+                relevance += 1
+            return (relevance, d.get("timestamp", ""))
+
+        ranked = sorted(decisions, key=score, reverse=True)
+        result = []
+        for d in ranked[:limit]:
+            # Add a human-readable relevance tag
+            tag = []
+            if file and d.get("file") == file:
+                tag.append("same_file")
+            if semantic_class and d.get("semantic_class") == semantic_class:
+                tag.append("same_class")
+            entry = dict(d)
+            entry["relevance"] = "+".join(tag) if tag else "recent"
+            result.append(entry)
+        return result
+
+
+def detect_resolution_strategy(
+    resolved_content: str, ours: str, theirs: str
+) -> str:
+    """Classify how a resolution was produced by comparing bytes.
+
+    Returns "keep_ours" / "keep_theirs" / "manual". Exact-match required
+    because partial merges still count as manual. Empty `resolved_content`
+    returns "manual" (caller didn't tell us what was written).
+    """
+    if not resolved_content:
+        return "manual"
+    # Strip trailing whitespace on both sides to be forgiving of newline diffs.
+    r = resolved_content.rstrip()
+    o = (ours or "").rstrip()
+    t = (theirs or "").rstrip()
+    if r == o:
+        return "keep_ours"
+    if r == t:
+        return "keep_theirs"
+    return "manual"

package/bingo_core/dep.py

@@ -26,6 +26,7 @@ import shutil
 import subprocess
 import tempfile
 from dataclasses import dataclass, field
+from datetime import datetime, timezone
 from typing import Any, Dict, List, Optional, Tuple
 
 
@@ -525,6 +526,226 @@ class DepManager:
         self._save_config()
         return {"ok": True, "package": package, "dropped": patch_name or "all"}
 
+    # ── Override Management ─────────────────────────────────────────────────
+
+    def _read_package_json(self) -> Optional[dict]:
+        """Read package.json from cwd. Returns None if not found."""
+        pj_path = os.path.join(self.cwd, "package.json")
+        if not os.path.isfile(pj_path):
+            return None
+        try:
+            with open(pj_path) as f:
+                return json.load(f)
+        except (json.JSONDecodeError, IOError):
+            return None
+
+    def _write_package_json(self, data: dict) -> None:
+        """Atomically write package.json preserving 2-space indent."""
+        pj_path = os.path.join(self.cwd, "package.json")
+        fd, tmp = tempfile.mkstemp(suffix=".tmp", dir=self.cwd)
+        try:
+            with os.fdopen(fd, "w") as f:
+                json.dump(data, f, indent=2)
+                f.write("\n")
+            os.replace(tmp, pj_path)
+        except Exception:
+            try:
+                os.unlink(tmp)
+            except FileNotFoundError:
+                pass
+            raise
+
+    def _load_overrides_tracking(self) -> dict:
+        """Load .bingo-deps/overrides.json tracking data."""
+        path = os.path.join(self.cwd, DEP_DIR, "overrides.json")
+        if not os.path.isfile(path):
+            return {"overrides": {}}
+        try:
+            with open(path) as f:
+                return json.load(f)
+        except (json.JSONDecodeError, IOError):
+            return {"overrides": {}}
+
+    def _save_overrides_tracking(self, data: dict) -> None:
+        """Write .bingo-deps/overrides.json."""
+        os.makedirs(os.path.join(self.cwd, DEP_DIR), exist_ok=True)
+        path = os.path.join(self.cwd, DEP_DIR, "overrides.json")
+        with open(path, "w") as f:
+            json.dump(data, f, indent=2)
+            f.write("\n")
+
+    def override_list(self) -> dict:
+        """List npm/yarn overrides with tracked reasons.
+
+        Returns {"ok": True, "overrides": [...], "count": N}
+        """
+        pj = self._read_package_json()
+        if pj is None:
+            return {"ok": True, "overrides": [], "count": 0, "note": "No package.json"}
+
+        # npm uses "overrides", yarn uses "resolutions"
+        overrides = pj.get("overrides", {})
+        resolutions = pj.get("resolutions", {})
+        all_ovs = {}
+        for pkg, ver in overrides.items():
+            all_ovs[pkg] = {"version": ver if isinstance(ver, str) else json.dumps(ver), "source": "overrides"}
+        for pkg, ver in resolutions.items():
+            if pkg not in all_ovs:
+                all_ovs[pkg] = {"version": ver, "source": "resolutions"}
+
+        # Merge with tracking data
+        tracking = self._load_overrides_tracking()
+        result = []
+        for pkg, info in all_ovs.items():
+            tracked = tracking.get("overrides", {}).get(pkg, {})
+            result.append({
+                "package": pkg,
+                "version": info["version"],
+                "source": info["source"],
+                "reason": tracked.get("reason", ""),
+                "created": tracked.get("created", ""),
+                "tracked": bool(tracked),
+            })
+
+        return {"ok": True, "overrides": result, "count": len(result)}
+
+    def override_check(self) -> dict:
+        """Check if npm overrides are still needed.
+
+        Reads package-lock.json to determine what version the tree resolves to.
+        Returns {"ok": True, "overrides": [{"package", "status", "reason"}]}
+        """
+        pj = self._read_package_json()
+        if pj is None:
+            return {"ok": True, "overrides": [], "count": 0}
+
+        overrides = pj.get("overrides", {})
+        resolutions = pj.get("resolutions", {})
+        all_ovs = dict(overrides)
+        all_ovs.update(resolutions)
+
+        if not all_ovs:
+            return {"ok": True, "overrides": [], "count": 0}
+
+        # Try reading package-lock.json for resolved versions
+        lock_path = os.path.join(self.cwd, "package-lock.json")
+        lock_data: Optional[dict] = None
+        if os.path.isfile(lock_path):
+            try:
+                with open(lock_path) as f:
+                    lock_data = json.load(f)
+            except (json.JSONDecodeError, IOError):
+                pass
+
+        results = []
+        for pkg, override_ver in all_ovs.items():
+            if not isinstance(override_ver, str):
+                results.append({
+                    "package": pkg,
+                    "override_version": json.dumps(override_ver),
+                    "status": "complex",
+                    "reason": "Nested override — manual check required",
+                })
+                continue
+
+            # Look up in lock file
+            resolved_ver = None
+            if lock_data:
+                # npm v2/v3 lock format: packages["node_modules/<pkg>"].version
+                packages = lock_data.get("packages", {})
+                lock_key = f"node_modules/{pkg}"
+                if lock_key in packages:
+                    resolved_ver = packages[lock_key].get("version", "")
+
+            if resolved_ver is None:
+                results.append({
+                    "package": pkg,
+                    "override_version": override_ver,
+                    "status": "unknown",
+                    "reason": "Cannot determine resolved version",
+                })
+            elif resolved_ver == override_ver:
+                # Lock resolved to override version — could be redundant
+                # Check if the package's parent requires a different version
+                # by looking at the dependency entry in lock file
+                # If the lock resolves to the same version, the override
+                # may no longer be needed
+                results.append({
+                    "package": pkg,
+                    "override_version": override_ver,
+                    "resolved_version": resolved_ver,
+                    "status": "redundant",
+                    "reason": "Lock resolves to override version — may no longer be needed",
+                })
+            else:
+                results.append({
+                    "package": pkg,
+                    "override_version": override_ver,
+                    "resolved_version": resolved_ver,
+                    "status": "active",
+                    "reason": f"Override forcing {override_ver} (tree wants {resolved_ver})",
+                })
+
+        redundant = sum(1 for r in results if r["status"] == "redundant")
+        return {"ok": True, "overrides": results, "count": len(results), "redundant": redundant}
+
+    def override_add(self, package: str, version: str, reason: str = "") -> dict:
+        """Add an npm override with reason tracking.
+
+        Returns {"ok": True, "package": ..., "version": ...}
+        """
+        pj = self._read_package_json()
+        if pj is None:
+            return {"ok": False, "error": "No package.json found"}
+
+        # Detect yarn vs npm
+        yarn_lock = os.path.isfile(os.path.join(self.cwd, "yarn.lock"))
+        field = "resolutions" if yarn_lock else "overrides"
+
+        if field not in pj:
+            pj[field] = {}
+        pj[field][package] = version
+        self._write_package_json(pj)
+
+        # Track reason
+        tracking = self._load_overrides_tracking()
+        tracking.setdefault("overrides", {})[package] = {
+            "version": version,
+            "reason": reason,
+            "created": datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ"),
+            "manager_field": field,
+        }
+        self._save_overrides_tracking(tracking)
+
+        return {"ok": True, "package": package, "version": version, "field": field}
+
+    def override_drop(self, package: str) -> dict:
+        """Remove an npm override.
+
+        Returns {"ok": True, "package": ..., "dropped": True}
+        """
+        pj = self._read_package_json()
+        if pj is None:
+            return {"ok": False, "error": "No package.json found"}
+
+        dropped = False
+        for pj_key in ("overrides", "resolutions"):
+            if pj_key in pj and package in pj[pj_key]:
+                del pj[pj_key][package]
+                if not pj[pj_key]:
+                    del pj[pj_key]
+                dropped = True
+        if dropped:
+            self._write_package_json(pj)
+
+        # Remove tracking
+        tracking = self._load_overrides_tracking()
+        if package in tracking.get("overrides", {}):
+            del tracking["overrides"][package]
+            self._save_overrides_tracking(tracking)
+
+        return {"ok": True, "package": package, "dropped": dropped}
+
 
 # ─── Diff Utilities ──────────────────────────────────────────────────────────
 
@@ -610,36 +831,175 @@ def _apply_patch(patch_path: str, target_dir: str) -> Tuple[bool, str]:
 
 
 def _apply_patch_python(patch_path: str, target_dir: str) -> Tuple[bool, str]:
-    """Pure-Python patch application (basic unified diff support)."""
+    """Pure-Python unified diff patch application.
+
+    Parses unified diff format and applies hunks to target files.
+    Supports: context matching, fuzzy offset (±3 lines), new/deleted files.
+    Processes hunks in reverse order to avoid line number cascading.
+    """
+    import re
+
     try:
         with open(patch_path) as f:
-            patch_text = f.read()
+            patch_lines = f.readlines()
     except OSError as e:
         return (False, str(e))
 
-    # Parse hunks
-    current_file = None
-    hunks: Dict[str, List[str]] = {}
-
-    for line in patch_text.splitlines(keepends=True):
-        if line.startswith("+++ b/"):
-            # Extract relative path after the package name prefix
-            parts = line[6:].strip().split("/", 1)
-            current_file = parts[1] if len(parts) > 1 else parts[0]
-            hunks.setdefault(current_file, [])
-        elif current_file and (line.startswith("+") or line.startswith("-")
-                               or line.startswith(" ") or line.startswith("@@")):
-            hunks[current_file].append(line)
-
-    if not hunks:
-        return (False, "No hunks found in patch")
-
-    # For now, just verify the files exist — full Python patching is complex
-    missing = [f for f in hunks if not os.path.isfile(os.path.join(target_dir, f))]
-    if missing:
-        return (False, f"Files not found: {', '.join(missing[:3])}")
-
-    return (False, "Python-only patch application not fully implemented; install 'patch' command")
+    # Parse into file-level diffs
+    file_diffs: List[dict] = []
+    i = 0
+    while i < len(patch_lines):
+        line = patch_lines[i]
+
+        # Find --- a/... and +++ b/... pair
+        if line.startswith("--- "):
+            if i + 1 < len(patch_lines) and patch_lines[i + 1].startswith("+++ "):
+                old_path = line[4:].strip()
+                new_line = patch_lines[i + 1]
+                # Strip p2: +++ b/<pkg>/<file> -> <file>
+                new_path_raw = new_line[6:].strip()
+                parts = new_path_raw.split("/", 1)
+                rel_path = parts[1] if len(parts) > 1 else parts[0]
+
+                is_new = old_path == "/dev/null" or old_path.endswith("/dev/null")
+                is_delete = new_line.strip().endswith("/dev/null")
+
+                # Collect hunks for this file
+                hunks: List[dict] = []
+                i += 2
+                while i < len(patch_lines):
+                    hunk_line = patch_lines[i]
+                    m = re.match(
+                        r'^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@',
+                        hunk_line,
+                    )
+                    if m:
+                        old_start = int(m.group(1))
+                        old_count = int(m.group(2)) if m.group(2) is not None else 1
+                        new_start = int(m.group(3))
+                        new_count = int(m.group(4)) if m.group(4) is not None else 1
+                        hunk_body: List[str] = []
+                        i += 1
+                        while i < len(patch_lines):
+                            hl = patch_lines[i]
+                            if hl.startswith((" ", "+", "-")):
+                                hunk_body.append(hl)
+                                i += 1
+                            elif hl.startswith("\\ No newline"):
+                                i += 1  # skip no-newline marker
+                            else:
+                                break
+                        hunks.append({
+                            "old_start": old_start,
+                            "old_count": old_count,
+                            "new_start": new_start,
+                            "new_count": new_count,
+                            "lines": hunk_body,
+                        })
+                    elif hunk_line.startswith("--- ") or hunk_line.startswith("diff "):
+                        break  # next file diff
+                    else:
+                        i += 1
+
+                file_diffs.append({
+                    "path": rel_path,
+                    "is_new": is_new,
+                    "is_delete": is_delete,
+                    "hunks": hunks,
+                })
+                continue
+        i += 1
+
+    if not file_diffs:
+        return (False, "No file diffs found in patch")
+
+    # Apply each file diff
+    for fd in file_diffs:
+        target_file = os.path.join(target_dir, fd["path"])
+
+        if fd["is_delete"]:
+            try:
+                os.remove(target_file)
+            except FileNotFoundError:
+                pass
+            continue
+
+        if fd["is_new"]:
+            os.makedirs(os.path.dirname(target_file) or ".", exist_ok=True)
+            new_lines: List[str] = []
+            for hunk in fd["hunks"]:
+                for hl in hunk["lines"]:
+                    if hl.startswith("+"):
+                        new_lines.append(hl[1:])
+                    elif hl.startswith(" "):
+                        new_lines.append(hl[1:])
+            with open(target_file, "w") as f:
+                f.writelines(new_lines)
+            continue
+
+        # Existing file — read, apply hunks in reverse, write
+        if not os.path.isfile(target_file):
+            return (False, f"File not found: {fd['path']}")
+
+        with open(target_file) as f:
+            file_lines = f.readlines()
+
+        # Process hunks in reverse order to preserve line numbers
+        for hunk in reversed(fd["hunks"]):
+            old_start = hunk["old_start"] - 1  # 0-indexed
+            hunk_lines = hunk["lines"]
+
+            # Build expected old lines and new lines
+            old_expected: List[str] = []
+            new_replacement: List[str] = []
+            for hl in hunk_lines:
+                if hl.startswith(" "):
+                    old_expected.append(hl[1:])
+                    new_replacement.append(hl[1:])
+                elif hl.startswith("-"):
+                    old_expected.append(hl[1:])
+                elif hl.startswith("+"):
+                    new_replacement.append(hl[1:])
+
+            # Try exact match first, then fuzzy offset ±3
+            match_pos = -1
+            for offset in range(0, 4):
+                for sign in (0, -1, 1) if offset == 0 else (-1, 1):
+                    pos = old_start + offset * sign
+                    if pos < 0 or pos + len(old_expected) > len(file_lines):
+                        continue
+                    chunk = file_lines[pos:pos + len(old_expected)]
+                    if _lines_match(chunk, old_expected):
+                        match_pos = pos
+                        break
+                if match_pos >= 0:
+                    break
+
+            if match_pos < 0:
+                context = old_expected[0].rstrip() if old_expected else "(empty)"
+                return (
+                    False,
+                    f"Hunk failed for {fd['path']} at line {hunk['old_start']}: "
+                    f"context mismatch near '{context}'",
+                )
+
+            # Apply: replace old lines with new lines
+            file_lines[match_pos:match_pos + len(old_expected)] = new_replacement
+
+        with open(target_file, "w") as f:
+            f.writelines(file_lines)
+
+    return (True, "")
+
+
+def _lines_match(actual: List[str], expected: List[str]) -> bool:
+    """Compare lines ignoring trailing whitespace differences."""
+    if len(actual) != len(expected):
+        return False
+    for a, e in zip(actual, expected):
+        if a.rstrip("\n\r") != e.rstrip("\n\r"):
+            return False
+    return True
 
 
 def _is_binary(path: str) -> bool: