@misterhuydo/sentinel 1.4.66 → 1.4.68

package/package.json

@@ -1,21 +1,21 @@
-{
-  "name": "@misterhuydo/sentinel",
-  "version": "1.4.66",
-  "description": "Sentinel — Autonomous DevOps Agent installer and manager",
-  "bin": {
-    "sentinel": "./bin/sentinel.js"
-  },
-  "scripts": {
-    "prepublishOnly": "node scripts/test-scripts.js && node scripts/bundle.js"
-  },
-  "dependencies": {
-    "chalk": "^4.1.2",
-    "fs-extra": "^11.2.0",
-    "prompts": "^2.4.2"
-  },
-  "engines": {
-    "node": ">=16"
-  },
-  "author": "misterhuydo",
-  "license": "MIT"
-}
+{
+  "name": "@misterhuydo/sentinel",
+  "version": "1.4.68",
+  "description": "Sentinel — Autonomous DevOps Agent installer and manager",
+  "bin": {
+    "sentinel": "./bin/sentinel.js"
+  },
+  "scripts": {
+    "prepublishOnly": "node scripts/test-scripts.js && node scripts/bundle.js"
+  },
+  "dependencies": {
+    "chalk": "^4.1.2",
+    "fs-extra": "^11.2.0",
+    "prompts": "^2.4.2"
+  },
+  "engines": {
+    "node": ">=16"
+  },
+  "author": "misterhuydo",
+  "license": "MIT"
+}

package/python/sentinel/dependency_manager.py

@@ -0,0 +1,206 @@
+"""
+dependency_manager.py — Maven pom.xml dependency cascade updates.
+
+Handles:
+  - Parsing pom.xml for artifact ID and version
+  - Finding repos that depend on a given artifact
+  - Updating dependency versions in pom.xml
+  - Full cascade: update all dependents, commit, push / open PR
+"""
+from __future__ import annotations
+
+import logging
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from .config_loader import RepoConfig, SentinelConfig
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class CascadeResult:
+    repo_name: str
+    success: bool
+    old_version: str = ""
+    new_version: str = ""
+    branch: str = ""
+    pr_url: str = ""
+    error: str = ""
+
+
+# ── pom.xml helpers ────────────────────────────────────────────────────────────
+
+def get_artifact_id(local_path: str) -> str:
+    """Return the root <artifactId> from pom.xml."""
+    pom = Path(local_path) / "pom.xml"
+    if not pom.exists():
+        return ""
+    text = pom.read_text(encoding="utf-8", errors="ignore")
+    m = re.search(r"<artifactId>([^<]+)</artifactId>", text)
+    return m.group(1).strip() if m else ""
+
+
+def get_pom_version(local_path: str) -> str:
+    """Return current version from pom.xml (may be SNAPSHOT)."""
+    pom = Path(local_path) / "pom.xml"
+    if not pom.exists():
+        return ""
+    text = pom.read_text(encoding="utf-8", errors="ignore")
+    m = re.search(r"<version>([^<]+)</version>", text)
+    return m.group(1).strip() if m else ""
+
+
+def get_release_version(local_path: str) -> str:
+    """Strip -SNAPSHOT to get the last release version."""
+    return get_pom_version(local_path).replace("-SNAPSHOT", "")
+
+
+def find_dependents(
+    artifact_id: str,
+    repos: dict,
+    skip_repo: str = "",
+) -> list[tuple[RepoConfig, str]]:
+    """
+    Scan all repo pom.xml files for a <dependency> on artifact_id.
+    Returns list of (RepoConfig, current_version) — sorted by repo_name.
+    skip_repo: repo_name to exclude (the source repo itself).
+    """
+    results = []
+    for repo in repos.values():
+        if repo.repo_name == skip_repo or not repo.local_path:
+            continue
+        pom = Path(repo.local_path) / "pom.xml"
+        if not pom.exists():
+            continue
+        text = pom.read_text(encoding="utf-8", errors="ignore")
+        pattern = rf"<dependency>.*?<artifactId>{re.escape(artifact_id)}</artifactId>.*?</dependency>"
+        block_m = re.search(pattern, text, re.DOTALL)
+        if block_m:
+            ver_m = re.search(r"<version>([^<]+)</version>", block_m.group(0))
+            current_ver = ver_m.group(1).strip() if ver_m else "?"
+            results.append((repo, current_ver))
+    return sorted(results, key=lambda t: t[0].repo_name)
+
+
+def update_dependency(local_path: str, artifact_id: str, new_version: str) -> bool:
+    """
+    Update the <version> inside the <dependency> block for artifact_id in pom.xml.
+    Returns True if the file was changed.
+    """
+    pom = Path(local_path) / "pom.xml"
+    if not pom.exists():
+        return False
+    text = pom.read_text(encoding="utf-8", errors="ignore")
+
+    def _replace_version(match: re.Match) -> str:
+        block = match.group(0)
+        return re.sub(r"<version>[^<]+</version>", f"<version>{new_version}</version>", block, count=1)
+
+    pattern = rf"<dependency>.*?<artifactId>{re.escape(artifact_id)}</artifactId>.*?</dependency>"
+    new_text, n = re.subn(pattern, _replace_version, text, flags=re.DOTALL)
+    if n == 0 or new_text == text:
+        return False
+    pom.write_text(new_text, encoding="utf-8")
+    return True
+
+
+# ── Cascade planning & execution ───────────────────────────────────────────────
+
+def plan_cascade(
+    source_repo_name: str,
+    repos: dict,
+    target_repo_names: list[str] | None = None,
+) -> dict:
+    """
+    Build a cascade plan without executing anything.
+    Returns a dict suitable for presenting to the admin for confirmation.
+    """
+    source = repos.get(source_repo_name)
+    if not source:
+        return {"error": f"Repo '{source_repo_name}' not found in config"}
+
+    artifact_id = get_artifact_id(source.local_path)
+    if not artifact_id:
+        return {"error": f"Could not read artifactId from {source_repo_name}/pom.xml"}
+
+    new_version = get_release_version(source.local_path)
+    if not new_version:
+        return {"error": f"Could not determine release version from {source_repo_name}/pom.xml"}
+
+    all_dependents = find_dependents(artifact_id, repos, skip_repo=source_repo_name)
+
+    if target_repo_names:
+        # Filter to only the requested repos that actually depend on this artifact
+        all_dependents = [(r, v) for r, v in all_dependents if r.repo_name in target_repo_names]
+
+    return {
+        "source_repo": source_repo_name,
+        "artifact_id": artifact_id,
+        "new_version": new_version,
+        "dependents": [
+            {
+                "repo": r.repo_name,
+                "current_version": v,
+                "auto_publish": r.auto_publish,
+                "action": "push to main" if r.auto_publish else "open PR",
+            }
+            for r, v in all_dependents
+        ],
+    }
+
+
+def execute_cascade(
+    source_repo_name: str,
+    new_version: str,
+    artifact_id: str,
+    repos: dict,
+    cfg: SentinelConfig,
+    target_repo_names: list[str] | None = None,
+) -> list[CascadeResult]:
+    """
+    Update the dependency in each dependent repo, commit, and push/PR.
+    Returns one CascadeResult per dependent repo attempted.
+    """
+    # Import here to avoid circular imports
+    from .git_manager import commit_file_change, push_dep_update, open_dep_pr, _git_env
+
+    all_dependents = find_dependents(artifact_id, repos, skip_repo=source_repo_name)
+    if target_repo_names:
+        all_dependents = [(r, v) for r, v in all_dependents if r.repo_name in target_repo_names]
+
+    results: list[CascadeResult] = []
+
+    for repo, old_version in all_dependents:
+        result = CascadeResult(repo_name=repo.repo_name, success=False, old_version=old_version, new_version=new_version)
+        try:
+            changed = update_dependency(repo.local_path, artifact_id, new_version)
+            if not changed:
+                result.error = "pom.xml not changed (already up to date?)"
+                results.append(result)
+                continue
+
+            commit_msg = (
+                f"chore(deps): update {artifact_id} to {new_version} [sentinel]\n\n"
+                f"Automated dependency bump by Sentinel after {source_repo_name} release."
+            )
+            status, commit_hash = commit_file_change(repo, ["pom.xml"], commit_msg)
+            if status != "committed":
+                result.error = "git commit failed"
+                results.append(result)
+                continue
+
+            branch, pr_url = push_dep_update(repo, cfg, artifact_id, new_version, commit_hash)
+            result.success = True
+            result.branch = branch
+            result.pr_url = pr_url
+            logger.info("Cascade updated %s → %s=%s (branch: %s)", repo.repo_name, artifact_id, new_version, branch)
+
+        except Exception as exc:
+            result.error = str(exc)
+            logger.error("Cascade failed for %s: %s", repo.repo_name, exc)
+
+        results.append(result)
+
+    return results

package/python/sentinel/git_manager.py

@@ -9,6 +9,7 @@ from __future__ import annotations
 
 import logging
 import os
+import re
 import subprocess
 from pathlib import Path
 
@@ -157,6 +158,118 @@ def _append_changelog(repo: RepoConfig, event: ErrorEvent, commit_hash: str):
     _git(["commit", "--amend", "--no-edit"], cwd=repo.local_path, env=env)
 
 
+def commit_file_change(
+    repo: RepoConfig,
+    files: list[str],
+    commit_msg: str,
+) -> tuple[str, str]:
+    """
+    Pull, stage the given files, and commit.
+    Returns (status, commit_hash) — status: "committed" | "failed".
+    Does NOT run tests (dependency bumps don't need them).
+    """
+    env = _git_env(repo)
+    local_path = repo.local_path
+
+    r = _git(["pull", "--rebase", "origin", repo.branch], cwd=local_path, env=env)
+    if r.returncode != 0:
+        logger.error("git pull failed for %s:\n%s", repo.repo_name, r.stderr)
+        return "failed", ""
+
+    _git(["add"] + files, cwd=local_path, env=env)
+    r = _git(["commit", "-m", commit_msg], cwd=local_path, env=env)
+    if r.returncode != 0:
+        logger.error("git commit failed for %s:\n%s", repo.repo_name, r.stderr)
+        _git(["checkout", "."], cwd=local_path, env=env)
+        return "failed", ""
+
+    commit_hash = _git(["rev-parse", "HEAD"], cwd=local_path, env=env).stdout.strip()
+    logger.info("Committed %s for %s", commit_hash[:8], repo.repo_name)
+    return "committed", commit_hash
+
+
+def push_dep_update(
+    repo: RepoConfig,
+    cfg: SentinelConfig,
+    artifact_id: str,
+    new_version: str,
+    commit_hash: str,
+) -> tuple[str, str]:
+    """
+    Push a dependency update commit. AUTO_PUBLISH=true → main branch.
+    AUTO_PUBLISH=false → sentinel/dep-<artifact>-<version> branch + open PR.
+    Returns (branch, pr_url).
+    """
+    env = _git_env(repo)
+    local_path = repo.local_path
+
+    if repo.auto_publish:
+        r = _git(["push", "origin", repo.branch], cwd=local_path, env=env)
+        if r.returncode != 0:
+            logger.error("git push failed for %s:\n%s", repo.repo_name, r.stderr)
+        return repo.branch, ""
+    else:
+        safe_artifact = re.sub(r"[^a-zA-Z0-9_-]", "-", artifact_id)
+        safe_version = re.sub(r"[^a-zA-Z0-9._-]", "-", new_version)
+        branch = f"{cfg.project_name or 'sentinel'}/dep-{safe_artifact}-{safe_version}"
+        _git(["checkout", "-B", branch], cwd=local_path, env=env)
+        r = _git(["push", "-u", "origin", branch], cwd=local_path, env=env)
+        if r.returncode != 0:
+            logger.error("git push branch failed for %s:\n%s", repo.repo_name, r.stderr)
+            _git(["checkout", repo.branch], cwd=local_path, env=env)
+            return branch, ""
+        _git(["checkout", repo.branch], cwd=local_path, env=env)
+        pr_url = open_dep_pr(repo, cfg, branch, artifact_id, new_version, commit_hash)
+        return branch, pr_url
+
+
+def open_dep_pr(
+    repo: RepoConfig,
+    cfg: SentinelConfig,
+    branch: str,
+    artifact_id: str,
+    new_version: str,
+    commit_hash: str,
+) -> str:
+    """Open a GitHub PR for a dependency version bump."""
+    if not cfg.github_token:
+        logger.warning("GITHUB_TOKEN not set — cannot open PR")
+        return ""
+
+    repo_url = repo.repo_url
+    if repo_url.startswith("git@"):
+        owner_repo = repo_url.split(":")[-1].removesuffix(".git")
+    else:
+        owner_repo = "/".join(repo_url.rstrip("/").split("/")[-2:]).removesuffix(".git")
+
+    title = f"[Sentinel] chore(deps): update {artifact_id} to {new_version}"
+    body = (
+        f"## Automated dependency update by Sentinel\n\n"
+        f"| | |\n|---|---|\n"
+        f"| **Dependency** | `{artifact_id}` |\n"
+        f"| **New version** | `{new_version}` |\n"
+        f"| **Commit** | `{commit_hash[:8]}` |\n\n"
+        f"This PR was opened automatically after a Sentinel-triggered release of `{artifact_id}`.\n\n"
+        f"---\n_To apply: merge this PR. To reject: close it._"
+    )
+    resp = requests.post(
+        f"https://api.github.com/repos/{owner_repo}/pulls",
+        json={"title": title, "body": body, "head": branch, "base": repo.branch},
+        headers={
+            "Authorization": f"Bearer {cfg.github_token}",
+            "Accept": "application/vnd.github+json",
+        },
+        timeout=30,
+    )
+    if resp.status_code == 201:
+        pr_url = resp.json().get("html_url", "")
+        logger.info("Dep PR opened: %s", pr_url)
+        return pr_url
+    else:
+        logger.error("Failed to open dep PR (%s): %s", resp.status_code, resp.text[:300])
+        return ""
+
+
 def remote_fix_exists(repo: RepoConfig, fingerprint: str, cfg: SentinelConfig) -> bool:
     """Return True if any Sentinel instance already pushed a fix branch for this fingerprint."""
     pattern = f"refs/heads/*/fix-{fingerprint[:8]}"

package/python/sentinel/main.py

@@ -29,7 +29,7 @@ from .log_parser import parse_all, scan_all_for_markers, ErrorEvent
 from .issue_watcher import scan_issues, mark_done, IssueEvent
 from .repo_router import route
 from .reporter import build_and_send, send_fix_notification, send_failure_notification, send_confirmed_notification, send_regression_notification, send_startup_notification, send_upgrade_notification
-from .notify import notify_fix_blocked, notify_fix_applied, notify_missing_tool, notify_tool_installing
+from .notify import notify_fix_blocked, notify_fix_applied, notify_missing_tool, notify_tool_installing, notify_cascade_started, notify_cascade_result
 from .health_checker import evaluate_repos
 from .state_store import StateStore
 
@@ -147,6 +147,28 @@ def _auto_install_if_safe(
 
 # ── Fix pipeline ──────────────────────────────────────────────────────────────
 
+
+def _run_cascade(repo, sentinel, cfg_loader):
+    """After a jenkins_release succeeds, cascade the version bump to all dependent repos."""
+    from .dependency_manager import get_artifact_id, get_release_version, plan_cascade, execute_cascade
+    artifact_id = get_artifact_id(repo.local_path)
+    new_version = get_release_version(repo.local_path)
+    if not artifact_id or not new_version:
+        logger.warning("Cascade skipped for %s — could not read artifact/version from pom.xml", repo.repo_name)
+        return
+    cascade_plan = plan_cascade(repo.repo_name, cfg_loader.repos)
+    target_repo_names = [d["repo"] for d in cascade_plan.get("dependents", [])]
+    if not target_repo_names:
+        logger.info("Cascade: no dependents found for %s", artifact_id)
+        return
+    logger.info("Cascade: updating %s in %d repo(s): %s", artifact_id, len(target_repo_names), target_repo_names)
+    notify_cascade_started(sentinel, artifact_id, new_version, target_repo_names)
+    results = execute_cascade(repo.repo_name, new_version, artifact_id, cfg_loader.repos, sentinel)
+    notify_cascade_result(sentinel, artifact_id, new_version, results)
+    ok = sum(1 for r in results if r.success)
+    logger.info("Cascade complete: %d/%d repos updated for %s=%s", ok, len(results), artifact_id, new_version)
+
+
 async def _handle_error(event: ErrorEvent, cfg_loader: ConfigLoader, store: StateStore):
     sentinel = cfg_loader.sentinel
 
@@ -248,7 +270,9 @@ async def _handle_error(event: ErrorEvent, cfg_loader: ConfigLoader, store: Stat
     })
 
     if repo.auto_publish:
-        cicd_trigger(repo, store, event.fingerprint)
+        ok = cicd_trigger(repo, store, event.fingerprint)
+        if ok and repo.cicd_type.lower() in ("jenkins_release", "jenkins-release"):
+            _run_cascade(repo, sentinel, cfg_loader)
 
 
 # ── Poll cycle ────────────────────────────────────────────────────────────────
@@ -344,7 +368,9 @@ async def _handle_issue(event: IssueEvent, cfg_loader: ConfigLoader, store: Stat
         mark_done(event.issue_file)
 
         if repo.auto_publish:
-            cicd_trigger(repo, store, event.fingerprint)
+            ok = cicd_trigger(repo, store, event.fingerprint)
+            if ok and repo.cicd_type.lower() in ("jenkins_release", "jenkins-release"):
+                _run_cascade(repo, sentinel, cfg_loader)
 
     except MissingToolError as e:
         logger.warning("Missing tool for %s: %s", event.source, e)
@@ -390,7 +416,9 @@ async def _handle_issue(event: IssueEvent, cfg_loader: ConfigLoader, store: Stat
                            submitter_user_id=submitter_uid)
         mark_done(event.issue_file)
         if repo.auto_publish:
-            cicd_trigger(repo, store, event.fingerprint)
+            ok = cicd_trigger(repo, store, event.fingerprint)
+            if ok and repo.cicd_type.lower() in ("jenkins_release", "jenkins-release"):
+                _run_cascade(repo, sentinel, cfg_loader)
 
     except Exception:
         logger.exception("Unexpected error processing issue %s — archiving to prevent retry loop", event.source)