lcdp-back-merge 1.0.0__tar.gz

lcdp_back_merge-1.0.0/PKG-INFO

@@ -0,0 +1,114 @@
+Metadata-Version: 2.4
+Name: lcdp-back-merge
+Version: 1.0.0
+Summary: Cross-platform automated back-merge bot (Bitbucket / GitHub) with AI-assisted conflict resolution
+Author: Le Comptoir Des Pharmacies
+Author-email: webmaster@lecomptoirdespharmacies.fr
+Requires-Python: >=3.9,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: anthropic (>=0.40.0)
+Requires-Dist: pyjwt[crypto] (>=2.4.0)
+Requires-Dist: requests (>=2.31.0,<3.0.0)
+Description-Content-Type: text/markdown
+
+# lcdp-back-merge
+
+Bot de back-merge automatique multi-plateforme (Bitbucket Cloud / GitHub) avec résolution IA des conflits.
+
+## Quoi ça fait
+
+Pour chaque branche divergente de la branche source courante :
+
+1. Crée une branche `auto-merge/<source>-into-<target>`
+2. Tente le merge ; si conflit, demande à Claude une proposition de résolution par fichier
+3. Ouvre une PR avec une description riche (statut, fichiers en conflit, suggestions IA)
+4. **Auto-merge** si pas de conflit OU si l'IA a résolu tous les fichiers avec confiance `high`
+5. **Notifie Slack** sinon (review requise)
+
+## Configuration
+
+### Variables d'environnement requises
+
+| Variable | Plateforme | Description |
+|---|---|---|
+| `BB_AUTH_STRING` | Bitbucket | `client_id:client_secret` OAuth pour l'API Bitbucket |
+| `GITHUB_APP_ID` | GitHub | App ID du GitHub App (auth App uniquement, pas de PAT) |
+| `GITHUB_APP_PRIVATE_KEY` | GitHub | Clé privée PEM du GitHub App. Permissions requises : `contents:write` + `pull-requests:write` |
+
+La plateforme est détectée automatiquement via les variables CI standard (`BITBUCKET_BRANCH`, `GITHUB_ACTIONS`).
+
+> GitHub : l'auth se fait **exclusivement via GitHub App** (le script génère lui-même un installation token court). L'App doit être **installée sur le repo** cible.
+
+### Variables d'environnement optionnelles
+
+| Variable | Défaut | Description |
+|---|---|---|
+| `ANTHROPIC_API_KEY` | — | Active la résolution IA des conflits |
+| `ANTHROPIC_MODEL` | `claude-sonnet-4-6` | Modèle Claude utilisé pour la résolution |
+| `SLACK_WEBHOOK_URL` | — | Active les notifications Slack |
+| `AUTO_MERGE_TARGET_PATTERNS` | (toutes) | Globs séparés par virgule : `develop,release/*` |
+| `AUTO_MERGE_BRANCH_MAP` | — | Mapping source→patterns : `master:develop;develop:feature/*` |
+| `AUTO_MERGE_DEFAULT_REVIEWERS` | — | Reviewers fallback en CSV (UUIDs Bitbucket ou logins GitHub) |
+| `AUTO_MERGE_PR_RUN_LIMIT` | -1 (illimité) | Nombre max de PR créées par run |
+
+## Utilisation en pipeline
+
+### Bitbucket Pipelines
+
+```yaml
+branches:
+  "{master}":
+    - step:
+        name: Back merge
+        # image uv officielle (debian bookworm) → uv + git déjà présents
+        image: ghcr.io/astral-sh/uv:python3.11-bookworm
+        clone:
+          depth: full          # toutes les branches divergentes
+        script:
+          - export AUTO_MERGE_TARGET_PATTERNS="develop"
+          - uvx lcdp-back-merge
+        # Variables (repository/deployment) : BB_AUTH_STRING, ANTHROPIC_API_KEY, SLACK_WEBHOOK_URL
+```
+
+### GitHub Actions
+
+```yaml
+- uses: actions/checkout@v4
+  with:
+    fetch-depth: 0          # toutes les branches divergentes
+    persist-credentials: false   # le script gère l'auth git via le token App
+- uses: astral-sh/setup-uv@v5
+- name: Back-merge
+  run: uvx lcdp-back-merge
+  env:
+    # Noms des secrets GitHub explicites (à gauche = ce que lit le script,
+    # à droite = le secret/variable côté repo, nommé sans ambiguïté).
+    GITHUB_APP_ID: ${{ vars.LCDP_BACKMERGE_APP_ID }}
+    GITHUB_APP_PRIVATE_KEY: ${{ secrets.LCDP_BACKMERGE_APP_PRIVATE_KEY }}
+    ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
+    SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }}
+```
+
+## Architecture
+
+```
+lcdp_back_merge/
+├── cli.py              # argparse, entry point
+├── runner.py           # boucle principale, orchestration
+├── ai_resolver.py      # résolution de conflits via Claude
+├── slack.py            # notifications Slack
+├── git_utils.py        # wrappers subprocess git
+└── platforms/
+    ├── base.py         # abstract Platform
+    ├── bitbucket.py    # adaptateur Bitbucket Cloud
+    └── github.py       # adaptateur GitHub
+```
+
+Ajouter une plateforme = ajouter une sous-classe de `Platform` dans `platforms/`, l'enregistrer dans `platforms.__init__.detect_platform()`.
+

lcdp_back_merge-1.0.0/README.md

@@ -0,0 +1,94 @@
+# lcdp-back-merge
+
+Bot de back-merge automatique multi-plateforme (Bitbucket Cloud / GitHub) avec résolution IA des conflits.
+
+## Quoi ça fait
+
+Pour chaque branche divergente de la branche source courante :
+
+1. Crée une branche `auto-merge/<source>-into-<target>`
+2. Tente le merge ; si conflit, demande à Claude une proposition de résolution par fichier
+3. Ouvre une PR avec une description riche (statut, fichiers en conflit, suggestions IA)
+4. **Auto-merge** si pas de conflit OU si l'IA a résolu tous les fichiers avec confiance `high`
+5. **Notifie Slack** sinon (review requise)
+
+## Configuration
+
+### Variables d'environnement requises
+
+| Variable | Plateforme | Description |
+|---|---|---|
+| `BB_AUTH_STRING` | Bitbucket | `client_id:client_secret` OAuth pour l'API Bitbucket |
+| `GITHUB_APP_ID` | GitHub | App ID du GitHub App (auth App uniquement, pas de PAT) |
+| `GITHUB_APP_PRIVATE_KEY` | GitHub | Clé privée PEM du GitHub App. Permissions requises : `contents:write` + `pull-requests:write` |
+
+La plateforme est détectée automatiquement via les variables CI standard (`BITBUCKET_BRANCH`, `GITHUB_ACTIONS`).
+
+> GitHub : l'auth se fait **exclusivement via GitHub App** (le script génère lui-même un installation token court). L'App doit être **installée sur le repo** cible.
+
+### Variables d'environnement optionnelles
+
+| Variable | Défaut | Description |
+|---|---|---|
+| `ANTHROPIC_API_KEY` | — | Active la résolution IA des conflits |
+| `ANTHROPIC_MODEL` | `claude-sonnet-4-6` | Modèle Claude utilisé pour la résolution |
+| `SLACK_WEBHOOK_URL` | — | Active les notifications Slack |
+| `AUTO_MERGE_TARGET_PATTERNS` | (toutes) | Globs séparés par virgule : `develop,release/*` |
+| `AUTO_MERGE_BRANCH_MAP` | — | Mapping source→patterns : `master:develop;develop:feature/*` |
+| `AUTO_MERGE_DEFAULT_REVIEWERS` | — | Reviewers fallback en CSV (UUIDs Bitbucket ou logins GitHub) |
+| `AUTO_MERGE_PR_RUN_LIMIT` | -1 (illimité) | Nombre max de PR créées par run |
+
+## Utilisation en pipeline
+
+### Bitbucket Pipelines
+
+```yaml
+branches:
+  "{master}":
+    - step:
+        name: Back merge
+        # image uv officielle (debian bookworm) → uv + git déjà présents
+        image: ghcr.io/astral-sh/uv:python3.11-bookworm
+        clone:
+          depth: full          # toutes les branches divergentes
+        script:
+          - export AUTO_MERGE_TARGET_PATTERNS="develop"
+          - uvx lcdp-back-merge
+        # Variables (repository/deployment) : BB_AUTH_STRING, ANTHROPIC_API_KEY, SLACK_WEBHOOK_URL
+```
+
+### GitHub Actions
+
+```yaml
+- uses: actions/checkout@v4
+  with:
+    fetch-depth: 0          # toutes les branches divergentes
+    persist-credentials: false   # le script gère l'auth git via le token App
+- uses: astral-sh/setup-uv@v5
+- name: Back-merge
+  run: uvx lcdp-back-merge
+  env:
+    # Noms des secrets GitHub explicites (à gauche = ce que lit le script,
+    # à droite = le secret/variable côté repo, nommé sans ambiguïté).
+    GITHUB_APP_ID: ${{ vars.LCDP_BACKMERGE_APP_ID }}
+    GITHUB_APP_PRIVATE_KEY: ${{ secrets.LCDP_BACKMERGE_APP_PRIVATE_KEY }}
+    ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
+    SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }}
+```
+
+## Architecture
+
+```
+lcdp_back_merge/
+├── cli.py              # argparse, entry point
+├── runner.py           # boucle principale, orchestration
+├── ai_resolver.py      # résolution de conflits via Claude
+├── slack.py            # notifications Slack
+├── git_utils.py        # wrappers subprocess git
+└── platforms/
+    ├── base.py         # abstract Platform
+    ├── bitbucket.py    # adaptateur Bitbucket Cloud
+    └── github.py       # adaptateur GitHub
+```
+
+Ajouter une plateforme = ajouter une sous-classe de `Platform` dans `platforms/`, l'enregistrer dans `platforms.__init__.detect_platform()`.

lcdp_back_merge-1.0.0/lcdp_back_merge/__init__.py

@@ -0,0 +1 @@
+"""lcdp-back-merge — Cross-platform automated back-merge bot."""

lcdp_back_merge-1.0.0/lcdp_back_merge/__main__.py

@@ -0,0 +1,4 @@
+from lcdp_back_merge.cli import main
+
+if __name__ == "__main__":
+    main()

lcdp_back_merge-1.0.0/lcdp_back_merge/ai_resolver.py

@@ -0,0 +1,241 @@
+"""Résolution de conflits Git via Claude.
+
+Port direct de l'ancien ai-resolve-conflict.py. Lit base/ours/theirs depuis
+l'index Git (le merge doit être en cours, c.-à-d. avant tout `git add` /
+`git commit`) pour éviter de parser les marqueurs de conflit (qui peuvent être
+au format standard ou diff3 selon la config locale).
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional
+
+import anthropic
+
+# Sonnet 4.6 plutôt qu'Opus 4.7 : la résolution de conflits ne nécessite pas la
+# capacité d'Opus, et Sonnet a une limite TPM plus élevée. Override via
+# ANTHROPIC_MODEL si besoin.
+DEFAULT_MODEL = "claude-sonnet-4-6"
+
+MAX_FILE_BYTES = 200_000
+MAX_DIFF_BYTES = 30_000
+MAX_BASE_BYTES = 10_000
+MAX_LOG_COMMITS = 8
+
+
+@dataclass
+class Resolution:
+    confidence: str  # "high" | "medium" | "low"
+    explanation: str
+    should_apply: bool
+    resolved_path: Optional[Path] = None
+
+
+def _git(args: list[str]) -> str:
+    try:
+        return subprocess.check_output(
+            ["git", *args], text=True, stderr=subprocess.DEVNULL
+        )
+    except subprocess.CalledProcessError:
+        return ""
+
+
+def _get_index_stage(stage: int, file_path: str) -> str:
+    return _git(["show", f":{stage}:{file_path}"])
+
+
+def _get_index_diff(stage_from: int, stage_to: int, file_path: str) -> str:
+    out = _git(["diff", f":{stage_from}:{file_path}", f":{stage_to}:{file_path}"])
+    if len(out) > MAX_DIFF_BYTES:
+        out = out[:MAX_DIFF_BYTES] + f"\n\n[... diff truncated, showed first {MAX_DIFF_BYTES} bytes ...]"
+    return out or "(no changes)"
+
+
+def _get_commit_log(branch: str, n: int = MAX_LOG_COMMITS) -> str:
+    out = _git(["log", f"-{n}", "--format=%h %s", branch])
+    return out.strip() or "(no log available)"
+
+
+def is_available() -> bool:
+    """True si ANTHROPIC_API_KEY est défini et anthropic est importable."""
+    return bool(os.environ.get("ANTHROPIC_API_KEY"))
+
+
+def resolve(
+    file_path: Path,
+    source_branch: str,
+    target_branch: str,
+    out_path: Path,
+) -> Resolution:
+    """Demande à Claude une résolution pour un fichier en conflit.
+
+    Écrit la résolution dans `out_path` UNIQUEMENT si `should_apply=True`.
+    L'orchestrateur applique ensuite ces fichiers selon sa stratégie.
+    """
+    raw = file_path.read_text(encoding="utf-8", errors="replace")
+
+    if len(raw.encode("utf-8")) > MAX_FILE_BYTES:
+        return Resolution(
+            confidence="low",
+            explanation="File too large for AI resolution.",
+            should_apply=False,
+        )
+
+    file_str = str(file_path)
+
+    base_content = _get_index_stage(1, file_str)
+    diff_ours = _get_index_diff(1, 2, file_str)
+    diff_theirs = _get_index_diff(1, 3, file_str)
+
+    if diff_ours == "(no changes)" and diff_theirs == "(no changes)":
+        return Resolution(
+            confidence="low",
+            explanation="No unmerged stages found for this file in the Git index.",
+            should_apply=False,
+        )
+
+    source_log = _get_commit_log(source_branch)
+    target_log = _get_commit_log(target_branch)
+
+    base_section = (
+        f"--- Common ancestor version of `{file_str}` ---\n```\n{base_content}\n```"
+        if base_content and len(base_content.encode("utf-8")) <= MAX_BASE_BYTES
+        else f"--- Common ancestor version of `{file_str}`: omitted (too large or not present) ---"
+    )
+
+    # max_retries=5 : le SDK gère la backoff exponentielle sur les 429 et 5xx.
+    # Utile car un back-merge avec beaucoup de fichiers en conflit peut taper
+    # sporadiquement les rate limits.
+    client = anthropic.Anthropic(max_retries=5)
+    model = os.environ.get("ANTHROPIC_MODEL", DEFAULT_MODEL)
+
+    system_prompt = """You are a senior software engineer resolving Git merge conflicts.
+
+You will be given:
+- A file currently containing Git conflict markers (<<<<<<<, =======, >>>>>>>)
+- The diff of changes made on the TARGET branch (where the merge is happening) since the common ancestor, scoped to this file
+- The diff of changes made on the SOURCE branch (the incoming changes) since the common ancestor, scoped to this file
+- Optionally the common ancestor version of the file
+- Recent commit messages from both branches for intent context
+
+Your job:
+1. Use the diffs to understand WHAT each side intended to do — the markers alone hide the
+   real intent.
+2. Resolve every conflict in the file by producing the most likely correct merged version
+   that preserves the intent of BOTH sides whenever possible.
+3. If the two sides are TRULY incompatible (they implement opposite behaviors, or modify
+   the same business logic in contradictory ways), say so honestly — do NOT invent a
+   resolution that papers over the disagreement.
+4. Be especially careful with: authentication, authorization, cryptography, payment logic,
+   database migrations, security-critical paths. Default to should_apply=false on these
+   even if the resolution looks straightforward.
+
+Output format — respond EXACTLY like this and nothing else:
+
+<RESOLVED_FILE>
+...the fully resolved file content with no conflict markers...
+</RESOLVED_FILE>
+<METADATA>
+{"confidence": "high"|"medium"|"low", "explanation": "one or two sentences", "should_apply": true|false}
+</METADATA>
+
+Be conservative. A bad resolution is worse than no resolution because it can mask bugs
+behind code that compiles and looks reasonable."""
+
+    user_prompt = f"""Merging source branch `{source_branch}` INTO target branch `{target_branch}`.
+File path: `{file_str}`
+
+=== Recent commits on `{source_branch}` (the INCOMING changes) ===
+{source_log}
+
+=== Recent commits on `{target_branch}` (the branch BEING UPDATED) ===
+{target_log}
+
+=== Changes on `{target_branch}` (ours/target) since common ancestor, for this file ===
+```diff
+{diff_ours}
+```
+
+=== Changes on `{source_branch}` (theirs/source) since common ancestor, for this file ===
+```diff
+{diff_theirs}
+```
+
+{base_section}
+
+=== Current file with unresolved conflict markers ===
+In the markers below, "ours" (between <<<<<<< and =======) is the TARGET branch's version,
+and "theirs" (between ======= and >>>>>>>) is the SOURCE branch's version.
+
+```
+{raw}
+```
+
+Resolve all conflicts and respond in the format specified."""
+
+    # Prompt caching sur le system prompt : identique entre tous les appels d'un
+    # même back-merge run. NB : pour que le cache se déclenche, le préfixe doit
+    # dépasser ~2048 tokens sur Sonnet 4.6.
+    response = client.messages.create(
+        model=model,
+        max_tokens=8000,
+        system=[
+            {
+                "type": "text",
+                "text": system_prompt,
+                "cache_control": {"type": "ephemeral"},
+            }
+        ],
+        messages=[{"role": "user", "content": user_prompt}],
+    )
+
+    text = response.content[0].text
+
+    file_match = re.search(r"<RESOLVED_FILE>\n?(.*?)\n?</RESOLVED_FILE>", text, re.DOTALL)
+    meta_match = re.search(r"<METADATA>\n?(.*?)\n?</METADATA>", text, re.DOTALL)
+
+    if not file_match or not meta_match:
+        return Resolution(
+            confidence="low",
+            explanation="AI response did not match expected format.",
+            should_apply=False,
+        )
+
+    resolved_content = file_match.group(1)
+    try:
+        metadata = json.loads(meta_match.group(1).strip())
+    except json.JSONDecodeError:
+        return Resolution(
+            confidence="low",
+            explanation="AI metadata was not valid JSON.",
+            should_apply=False,
+        )
+
+    # `<<<<<<<` ne peut pas apparaître naturellement, canary suffisant pour les
+    # deux formats (standard et diff3).
+    if "<<<<<<<" in resolved_content:
+        return Resolution(
+            confidence="low",
+            explanation="AI output still contains conflict markers; not applied.",
+            should_apply=False,
+        )
+
+    should_apply = bool(metadata.get("should_apply"))
+    resolved_path = None
+    if should_apply:
+        out_path.parent.mkdir(parents=True, exist_ok=True)
+        out_path.write_text(resolved_content, encoding="utf-8")
+        resolved_path = out_path
+
+    return Resolution(
+        confidence=metadata.get("confidence", "low"),
+        explanation=metadata.get("explanation", ""),
+        should_apply=should_apply,
+        resolved_path=resolved_path,
+    )

lcdp_back_merge-1.0.0/lcdp_back_merge/cli.py

@@ -0,0 +1,139 @@
+"""Entry point CLI : `lcdp-back-merge`.
+
+Les options peuvent être passées via flags CLI OU variables d'environnement
+(noms historiques `AUTO_MERGE_*` pour compat avec les pipelines existantes).
+Le flag CLI a priorité sur la variable d'env.
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+
+from lcdp_back_merge.platforms import detect_platform
+from lcdp_back_merge.runner import (
+    BackMergeRunner,
+    Config,
+    parse_branch_map,
+    parse_csv,
+    parse_patterns,
+)
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="lcdp-back-merge",
+        description="Cross-platform automated back-merge bot (Bitbucket / GitHub).",
+    )
+    parser.add_argument(
+        "--target-patterns",
+        default=None,
+        help=(
+            "Globs de branches cibles, séparés par virgule (ex: 'develop,release/*'). "
+            "Par défaut : toutes les branches divergentes. "
+            "Override de AUTO_MERGE_TARGET_PATTERNS."
+        ),
+    )
+    parser.add_argument(
+        "--branch-map",
+        default=None,
+        help=(
+            "Mapping source→patterns pour piloter plusieurs branches sans dupliquer "
+            "la pipeline. Format : 'src1:patterns1;src2:patterns2'. "
+            "Override de AUTO_MERGE_BRANCH_MAP."
+        ),
+    )
+    parser.add_argument(
+        "--default-reviewers",
+        default=None,
+        help=(
+            "Reviewers fallback en CSV (UUIDs Bitbucket ou logins GitHub). "
+            "Override de AUTO_MERGE_DEFAULT_REVIEWERS."
+        ),
+    )
+    parser.add_argument(
+        "--pr-limit",
+        type=int,
+        default=None,
+        help="Nombre max de PR créées par run (-1 = illimité). Override de AUTO_MERGE_PR_RUN_LIMIT.",
+    )
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="N'effectue aucun push, aucune PR ni aucun merge — uniquement les logs.",
+    )
+    parser.add_argument(
+        "--bot-name",
+        default="Merge Resolver Bot",
+        help="Nom du commiter utilisé pour les commits auto-merge.",
+    )
+    parser.add_argument(
+        "--bot-email",
+        default="merge-resolver-bot@noreply.local",
+        help="Email du commiter utilisé pour les commits auto-merge.",
+    )
+    return parser
+
+
+def _build_config(args: argparse.Namespace) -> Config:
+    target_patterns = parse_patterns(
+        args.target_patterns
+        if args.target_patterns is not None
+        else os.environ.get("AUTO_MERGE_TARGET_PATTERNS", "")
+    )
+
+    branch_map = parse_branch_map(
+        args.branch_map
+        if args.branch_map is not None
+        else os.environ.get("AUTO_MERGE_BRANCH_MAP", "")
+    )
+
+    default_reviewers = parse_csv(
+        args.default_reviewers
+        if args.default_reviewers is not None
+        else os.environ.get("AUTO_MERGE_DEFAULT_REVIEWERS", "")
+    )
+
+    pr_run_limit = (
+        args.pr_limit
+        if args.pr_limit is not None
+        else int(os.environ.get("AUTO_MERGE_PR_RUN_LIMIT", "-1"))
+    )
+
+    return Config(
+        target_patterns=target_patterns,
+        branch_map=branch_map,
+        default_reviewers=default_reviewers,
+        pr_run_limit=pr_run_limit,
+        dry_run=args.dry_run,
+        bot_name=args.bot_name,
+        bot_email=args.bot_email,
+    )
+
+
+def main() -> int:
+    args = _build_parser().parse_args()
+    config = _build_config(args)
+
+    try:
+        platform = detect_platform()
+    except RuntimeError as exc:
+        print(f"ERROR: {exc}", file=sys.stderr)
+        return 1
+
+    print(f"Detected platform: {platform.name}")
+    print(f"  Source branch: {platform.ctx.source_branch}")
+    print(f"  Repository: {platform.ctx.repo_owner}/{platform.ctx.repo_slug}")
+
+    runner = BackMergeRunner(config, platform)
+    try:
+        runner.run()
+    except RuntimeError as exc:
+        print(f"ERROR: {exc}", file=sys.stderr)
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())