oneport-debug-cicd 0.1.0__py3-none-any.whl

oneport_debug_cicd/__init__.py

@@ -0,0 +1,24 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2024 OnePort Debug Contributors
+"""
+oneport-debug-cicd: Non-interactive CI/CD background debugging worker.
+
+Use case — The MNC problem:
+  A Jenkins build breaks at 3 AM on the release branch. Tests fail.
+  On-call developer gets paged. They spend 45 minutes reading build logs,
+  checking git blame, and running tests locally to understand what changed.
+
+  Instead, add to your Jenkinsfile:
+    post { failure { sh 'oneport-cicd-worker --build $BUILD_URL --post-jira --post-slack' } }
+
+  → Worker boots non-interactively in a Docker sandbox
+  → Fetches the failed build log from Jenkins API
+  → Diffs the failing commit against the last green build
+  → Runs the failing tests in isolation to confirm the regression
+  → AI generates a patch, creates a Jira ticket, and posts to #builds Slack
+  → On-call sees: "Build #1247 failed. Root cause: UserService.findById() returns null
+    when user has pending_deletion status. Introduced in commit f3a2b1c by bob@corp.com.
+    Fix: add null check at UserService.java:L89. Patch attached."
+"""
+
+__version__ = "0.1.0"

oneport_debug_cicd/analyzers/fix_generator.py

@@ -0,0 +1,193 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2024 OnePort Debug Contributors
+"""
+FixGenerator — turns an RCAResult into an actionable unified diff patch.
+
+The AI model already identified root cause + recommended fix in the RCAResult.
+This module takes that free-text fix and:
+  1. Reads the actual source file at the blamed line
+  2. Calls the LLM again with targeted "generate a patch" prompt
+  3. Parses the LLM response for a unified diff block
+  4. Validates the diff is syntactically well-formed
+  5. Returns a FixProposal with the diff ready to apply via `git apply`
+
+The generated patch is intentionally minimal — one focused change, not a refactor.
+
+Enterprise note:
+  - The patch is NOT auto-applied. It's attached to the Jira ticket / Slack block.
+  - The developer reviews and applies with: git apply < fix.patch
+  - This satisfies SOX change-management requirements (human approval gate).
+
+Usage:
+    generator = FixGenerator(orchestrator)
+    proposal = await generator.generate(rca_result, repo_path)
+    if proposal:
+        print(proposal.unified_diff)
+        proposal.write(Path("fix.patch"))
+"""
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import structlog
+
+from oneport_debug_core.engine.orchestrator import Orchestrator
+from oneport_debug_core.llm.base import LLMCompletionOptions
+from oneport_debug_core.models.rca import RCAResult, Evidence
+
+log = structlog.get_logger(__name__)
+
+_MAX_CONTEXT_LINES = 40  # lines of code around the blame line to include in prompt
+
+
+@dataclass
+class FixProposal:
+    unified_diff: str          # ready to pass to `git apply`
+    target_file: str           # repo-relative file path
+    target_line: int           # approximate line number
+    confidence: float          # 0.0–1.0 from model
+    explanation: str           # human-readable description of the fix
+
+    def write(self, path: Path) -> None:
+        path.write_text(self.unified_diff, encoding="utf-8")
+        log.info("fix_generator.patch_written", path=str(path))
+
+    @property
+    def is_valid(self) -> bool:
+        """Basic sanity check — diff must start with --- and have at least one hunk."""
+        return "---" in self.unified_diff and "@@" in self.unified_diff
+
+
+class FixGenerator:
+    def __init__(self, orchestrator: Orchestrator) -> None:
+        self._orchestrator = orchestrator
+
+    async def generate(
+        self,
+        rca: RCAResult,
+        repo_root: Path,
+    ) -> FixProposal | None:
+        """
+        Generate a patch for the first high-confidence code location in the RCA.
+        Returns None if no actionable location exists or the LLM can't produce a valid diff.
+        """
+        if not rca.locations:
+            log.info("fix_generator.no_locations")
+            return None
+
+        # Pick the highest-confidence location we can read
+        loc = next(
+            (l for l in rca.locations
+             if l.file_path and (repo_root / l.file_path).exists()),
+            None,
+        )
+        if not loc:
+            log.info("fix_generator.no_readable_location")
+            return None
+
+        file_path = repo_root / loc.file_path
+        source_lines = file_path.read_text(encoding="utf-8", errors="replace").splitlines()
+        line_no = loc.line_number or 1
+
+        # Extract context window
+        start = max(0, line_no - _MAX_CONTEXT_LINES // 2)
+        end = min(len(source_lines), line_no + _MAX_CONTEXT_LINES // 2)
+        context = "\n".join(
+            f"{i + 1:4d}  {line}"
+            for i, line in enumerate(source_lines[start:end], start=start)
+        )
+
+        prompt = f"""You are an expert software engineer. Generate a minimal unified diff patch to fix the following bug.
+
+## Bug Summary
+{rca.summary}
+
+## Root Cause
+{rca.root_cause}
+
+## Recommended Fix
+{rca.recommended_fix or "Not specified"}
+
+## File: {loc.file_path} (around line {line_no})
+```
+{context}
+```
+
+## Instructions
+1. Output a syntactically valid unified diff that can be applied with `git apply`
+2. Patch ONLY the minimum necessary lines — do not refactor or add features
+3. Use the exact file path from above in the `---` / `+++` header
+4. After the diff, add a JSON block with: {{"confidence": 0.0-1.0, "explanation": "one sentence"}}
+5. If you cannot generate a safe patch, output: {{"confidence": 0, "explanation": "reason"}}
+
+Output format:
+```diff
+--- a/{loc.file_path}
++++ b/{loc.file_path}
+@@ ... @@
+...patch content...
+```
+```json
+{{"confidence": 0.85, "explanation": "Fixed null check before accessing user.groups"}}
+```"""
+
+        try:
+            raw = await self._orchestrator.llm.complete(
+                prompt,
+                LLMCompletionOptions(temperature=0.05, max_tokens=2000),
+            )
+        except Exception as err:
+            log.warning("fix_generator.llm_failed", error=str(err))
+            return None
+
+        return self._parse_response(raw, loc.file_path, line_no)
+
+    def _parse_response(self, raw: str, file_path: str, line_no: int) -> FixProposal | None:
+        # Extract unified diff
+        diff_match = re.search(r"```diff\s*([\s\S]*?)```", raw, re.IGNORECASE)
+        if not diff_match:
+            # Try without fence
+            diff_start = raw.find("---")
+            if diff_start == -1:
+                log.warning("fix_generator.no_diff_found")
+                return None
+            diff_text = raw[diff_start:]
+            # Cut at next ``` if present
+            fence_end = diff_text.find("```")
+            if fence_end != -1:
+                diff_text = diff_text[:fence_end]
+        else:
+            diff_text = diff_match.group(1)
+
+        diff_text = diff_text.strip()
+        if not diff_text or "@@" not in diff_text:
+            log.warning("fix_generator.invalid_diff")
+            return None
+
+        # Extract JSON metadata
+        confidence = 0.7
+        explanation = "AI-generated patch"
+        json_match = re.search(r"```json\s*([\s\S]*?)```", raw, re.IGNORECASE)
+        if json_match:
+            try:
+                import json
+                meta = json.loads(json_match.group(1))
+                confidence = float(meta.get("confidence", 0.7))
+                explanation = meta.get("explanation", explanation)
+            except Exception:
+                pass
+
+        if confidence == 0:
+            log.info("fix_generator.model_declined", explanation=explanation)
+            return None
+
+        return FixProposal(
+            unified_diff=diff_text,
+            target_file=file_path,
+            target_line=line_no,
+            confidence=min(1.0, max(0.0, confidence)),
+            explanation=explanation,
+        )

oneport_debug_cicd/cli.py

@@ -0,0 +1,119 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2024 OnePort Debug Contributors
+"""
+oneport-cicd CLI — manual trigger and status management.
+
+The worker.py is for automated CI hooks.
+This CLI is for developers to manually trigger analysis, check status, and replay.
+
+Usage:
+  # Manually trigger analysis of a failed GitHub Actions run
+  oneport-cicd analyze --platform github-actions --run-id 12345678 --repo myorg/payment-service
+
+  # View the last N RCAs from the audit log
+  oneport-cicd history --last 10
+
+  # Re-run analysis on a cached build log
+  oneport-cicd replay --log-file ./saved_build.log --platform github-actions
+"""
+from __future__ import annotations
+
+import asyncio
+import json
+import sys
+from pathlib import Path
+
+import click
+
+from oneport_debug_core.config.settings import load_config
+from oneport_debug_core.cli.output import print_rca, print_error, print_step, console
+
+
+@click.group()
+@click.option("--config", default=None, type=click.Path())
+@click.pass_context
+def main(ctx: click.Context, config: str | None) -> None:
+    """oneport-debug-cicd — CI/CD failure root cause analysis."""
+    from oneport_debug_core.cli.output import ensure_utf8_console
+    ensure_utf8_console()
+    ctx.ensure_object(dict)
+    ctx.obj["config"] = load_config(Path(config) if config else None)
+
+
+@main.command()
+@click.option("--format", "output_format", default="rich", type=click.Choice(["rich", "json"]), help="Output format")
+def demo(output_format: str) -> None:
+    """Run a zero-config demo on a bundled CI regression (no CI server/API key needed)."""
+    from oneport_debug_cicd.demo import run_demo
+    run_demo(json_output=(output_format == "json"))
+
+
+@main.command()
+@click.option("--platform", required=True, type=click.Choice(["github-actions", "gitlab", "jenkins"]))
+@click.option("--run-id", default=None)
+@click.option("--repo", default=None)
+@click.option("--pipeline-id", default=None)
+@click.option("--project-id", default=None)
+@click.option("--build-url", default=None)
+@click.option("--post-jira", is_flag=True)
+@click.option("--post-slack", is_flag=True)
+@click.option("--format", "output_format", default="rich", type=click.Choice(["rich", "json"]))
+@click.pass_context
+def analyze(ctx: click.Context, platform, run_id, repo, pipeline_id, project_id, build_url, post_jira, post_slack, output_format):
+    """Manually analyze a failed CI build and produce an RCA."""
+    from oneport_debug_cicd.worker import _run
+    config = ctx.obj["config"]
+    print_step(f"Analyzing {platform} build failure...")
+    exit_code = asyncio.run(_run(config, platform, run_id, repo, pipeline_id, project_id, build_url, post_jira, post_slack, output_format))
+    sys.exit(exit_code)
+
+
+@main.command()
+@click.option("--log", "log_path", default="/var/log/oneport-debug/audit.jsonl", type=click.Path())
+@click.option("--last", default=10, show_default=True)
+def history(log_path: str, last: int) -> None:
+    """Show the last N CI/CD analysis sessions from the audit log."""
+    path = Path(log_path)
+    if not path.exists():
+        print_error(f"Audit log not found: {log_path}")
+        return
+
+    sessions = [json.loads(line) for line in path.read_text().splitlines() if line.strip()]
+    cicd_sessions = [s for s in sessions if s.get("module") == "cicd"][-last:]
+
+    console.print(f"\n[bold]Last {len(cicd_sessions)} CI/CD analyses:[/bold]\n")
+    for s in reversed(cicd_sessions):
+        color = "red" if float(s.get("confidence", 0)) < 0.5 else "green"
+        console.print(
+            f"  [{color}]●[/{color}] {s.get('timestamp', '')}  "
+            f"confidence={s.get('confidence', 0):.0%}  "
+            f"provider={s.get('provider', '?')}  "
+            f"duration={s.get('duration_ms', 0)}ms"
+        )
+
+
+@main.command()
+@click.option("--log-file", required=True, type=click.Path(exists=True))
+@click.option("--platform", default="github-actions")
+@click.option("--format", "output_format", default="rich", type=click.Choice(["rich", "json"]))
+@click.pass_context
+def replay(ctx: click.Context, log_file: str, platform: str, output_format: str) -> None:
+    """Re-run analysis on a saved build log file."""
+    config = ctx.obj["config"]
+    from oneport_debug_core.engine.orchestrator import Orchestrator
+    from oneport_debug_core.models.rca import Evidence
+
+    try:
+        log_text = Path(log_file).read_text(encoding="utf-8", errors="replace")
+        evidence = Evidence(source=f"{platform}-replay", raw={"build_log": log_text[-6000:]})
+        orchestrator = Orchestrator(config)
+
+        result = asyncio.run(orchestrator.analyze(
+            module="cicd",
+            evidence=[evidence],
+            extra_context={"platform": platform, "source": "replay"},
+        ))
+        print_rca(result, output_format)
+    except Exception as err:
+        print_error(str(err), hint="Check the log file and your model configuration (ONEPORT_MODE / API keys)")
+        sys.exit(1)

oneport_debug_cicd/demo/__init__.py

@@ -0,0 +1,7 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2024 OnePort Debug Contributors
+"""Zero-config demo for oneport-cicd — runs the real RegressionDetector on a bundled failure."""
+
+from oneport_debug_cicd.demo.runner import run_demo
+
+__all__ = ["run_demo"]

oneport_debug_cicd/demo/runner.py

@@ -0,0 +1,220 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2024 OnePort Debug Contributors
+"""
+Runner for `oneport-cicd demo`.
+
+Materializes a real two-commit git repository (a green build, then a commit that
+regresses it) and runs the *real* RegressionDetector over it — the same code path
+used against a live GitHub Actions / Jenkins / GitLab failure. The culprit commit,
+author, changed file, and changed function are all computed live; only the AI
+narrative is curated so the demo needs no API key or network.
+
+This shows the thing Claude Code structurally cannot do: it knows the diff, but
+not *which commit since the last green build* broke things, or *who* owns it.
+"""
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+import tempfile
+from pathlib import Path
+
+from rich import box
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+from oneport_debug_core.cli.output import console, print_rca
+from oneport_debug_core.models.rca import CodeLocation, RCAResult, Severity
+from oneport_debug_cicd.demo import sample_data as sd
+from oneport_debug_cicd.sandbox.regression_detector import RegressionDetector, RegressionReport
+
+
+def _quiet_logs() -> None:
+    import logging
+    import structlog
+    structlog.configure(wrapper_class=structlog.make_filtering_bound_logger(logging.WARNING))
+
+
+def run_demo(json_output: bool = False) -> RCAResult:
+    """Materialize the sample repo, run the real regression detector, render the RCA."""
+    _quiet_logs()
+
+    tmp = Path(tempfile.mkdtemp(prefix="oneport-cicd-demo-"))
+    try:
+        green_sha, red_sha = _materialize_repo(tmp)
+        report = RegressionDetector(tmp).detect(red_sha, green_sha)
+        rca = _build_rca(report, red_sha)
+
+        if json_output:
+            console.print_json(rca.model_dump_json(indent=2))
+            return rca
+
+        _render_intro()
+        _render_build_log()
+        _render_regression(report)
+        console.print()
+        print_rca(rca, output_format="rich")
+        _render_outro()
+        return rca
+    finally:
+        shutil.rmtree(tmp, ignore_errors=True)
+
+
+# --------------------------------------------------------------------------- #
+# Repo materialization                                                          #
+# --------------------------------------------------------------------------- #
+
+def _git(args: list[str], cwd: Path, author: tuple[str, str] | None = None) -> str:
+    env = dict(os.environ)
+    # Deterministic, isolated identity — never touches the user's git config.
+    env.update({
+        "GIT_CONFIG_GLOBAL": os.devnull,
+        "GIT_CONFIG_SYSTEM": os.devnull,
+        "GIT_TERMINAL_PROMPT": "0",
+    })
+    if author:
+        name, email = author
+        env.update({
+            "GIT_AUTHOR_NAME": name, "GIT_AUTHOR_EMAIL": email,
+            "GIT_COMMITTER_NAME": name, "GIT_COMMITTER_EMAIL": email,
+        })
+    out = subprocess.run(
+        ["git", *args], cwd=str(cwd), env=env,
+        capture_output=True, text=True, check=True,
+    )
+    return out.stdout.strip()
+
+
+def _materialize_repo(root: Path) -> tuple[str, str]:
+    """Create services/payment.py + a test, commit green, then commit the regression."""
+    (root / "services").mkdir(parents=True, exist_ok=True)
+    (root / "tests").mkdir(parents=True, exist_ok=True)
+    (root / "services" / "__init__.py").write_text("", encoding="utf-8")
+
+    _git(["init", "-q", "-b", "main"], root)
+
+    payment = root / "services" / "payment.py"
+    test = root / "tests" / "test_payment.py"
+
+    payment.write_text(sd.GREEN_PAYMENT, encoding="utf-8")
+    test.write_text(sd.TEST_FILE, encoding="utf-8")
+    _git(["add", "-A"], root)
+    _git(["commit", "-q", "-m", sd.GREEN_MESSAGE], root, author=sd.GREEN_AUTHOR)
+    green_sha = _git(["rev-parse", "HEAD"], root)
+
+    payment.write_text(sd.RED_PAYMENT, encoding="utf-8")
+    _git(["add", "-A"], root)
+    _git(["commit", "-q", "-m", sd.RED_MESSAGE], root, author=sd.RED_AUTHOR)
+    red_sha = _git(["rev-parse", "HEAD"], root)
+
+    return green_sha, red_sha
+
+
+# --------------------------------------------------------------------------- #
+# RCA construction (real regression facts + curated narrative)                  #
+# --------------------------------------------------------------------------- #
+
+def _build_rca(report: RegressionReport, red_sha: str) -> RCAResult:
+    culprit_sha = report.likely_culprit_sha or red_sha
+    culprit_author = report.likely_culprit_author or sd.RED_AUTHOR[0]
+
+    prod = next((f for f in report.changed_files if not f.is_test_file and not f.is_config_file), None)
+    file_path = prod.file_path if prod else "services/payment.py"
+    function = (prod.changed_functions[0] if prod and prod.changed_functions else "charge")
+    line = (prod.added_lines[0] if prod and prod.added_lines else 6)
+
+    root_cause = sd.CURATED_RCA["root_cause_template"].format(
+        culprit=culprit_sha[:8], author=culprit_author,
+    )
+    return RCAResult(
+        module="cicd",
+        severity=Severity(sd.CURATED_RCA["severity"]),
+        summary=sd.CURATED_RCA["summary"],
+        root_cause=root_cause,
+        recommended_fix=sd.CURATED_RCA["recommended_fix"],
+        confidence=sd.CURATED_RCA["confidence"],
+        locations=[CodeLocation(
+            repo=sd.REPO,
+            file_path=file_path,
+            line_number=line,
+            function_name=function,
+            commit_sha=culprit_sha,
+            blame_author=culprit_author,
+        )],
+        affected_services=[sd.REPO],
+        tags={
+            "platform": "github-actions",
+            "branch": sd.BRANCH,
+            "build": sd.BUILD_NUMBER,
+            "culprit_commit": culprit_sha[:8],
+            "culprit_author": culprit_author,
+        },
+        model_used="bundled sample (offline demo)",
+    )
+
+
+# --------------------------------------------------------------------------- #
+# Rendering                                                                     #
+# --------------------------------------------------------------------------- #
+
+def _render_intro() -> None:
+    body = Text()
+    body.append("Running on a freshly materialized git repo — no CI server, no API key, no setup.\n\n", style="dim")
+    body.append("Scenario: ", style="bold")
+    body.append(f"build #{sd.BUILD_NUMBER} of ")
+    body.append(sd.REPO, style="cyan")
+    body.append(" on ")
+    body.append(sd.BRANCH, style="cyan")
+    body.append(" went ")
+    body.append("RED", style="bold red")
+    body.append(".\n")
+    body.append("The last build was green. One commit since then broke it.", style="dim")
+    console.print()
+    console.print(Panel(body, title="[bold]OnePort Debug — oneport-cicd demo[/bold]",
+                        border_style="cyan", box=box.ROUNDED))
+
+
+def _render_build_log() -> None:
+    body = Text(sd.BUILD_LOG.rstrip(), style="dim")
+    console.print()
+    console.print(Panel(body, title="[bold]Failing build log (from CI)[/bold]",
+                        border_style="red", box=box.ROUNDED))
+
+
+def _render_regression(report: RegressionReport) -> None:
+    table = Table(title="Regression analysis  (failing build   vs  last green)",
+                  box=box.SIMPLE_HEAVY, title_style="bold", show_lines=False)
+    table.add_column("", style="cyan", no_wrap=True)
+    table.add_column("", style="white")
+
+    commits = report.commits_since_green
+    table.add_row("Commits since green", str(len(commits)))
+    for c in commits:
+        table.add_row("", f"[yellow]{c['sha'][:8]}[/yellow]  {c['message']}  — {c['author']}")
+
+    for f in report.changed_files:
+        kind = "test" if f.is_test_file else ("config" if f.is_config_file else "prod")
+        fns = ", ".join(f.changed_functions) or "—"
+        table.add_row("Changed file", f"{f.file_path}  [dim]({kind})[/dim]  →  {fns}()")
+
+    table.add_row("", "")
+    table.add_row("[bold]Likely culprit[/bold]",
+                  f"[bold red]{(report.likely_culprit_sha or '')[:8]}[/bold red]  "
+                  f"by [bold]{report.likely_culprit_author or '?'}[/bold]")
+    console.print()
+    console.print(table)
+
+
+def _render_outro() -> None:
+    body = Text()
+    body.append("This ran the real RegressionDetector on a real git history.\n", style="dim")
+    body.append("Wire it into your pipeline's failure hook:\n\n", style="dim")
+    body.append("  # GitHub Actions\n", style="dim")
+    body.append("  - if: failure()\n", style="green")
+    body.append("    run: oneport-cicd-worker --platform github-actions \\\n", style="green")
+    body.append("           --run-id ${{ github.run_id }} --repo ${{ github.repository }} \\\n", style="green")
+    body.append("           --post-jira --post-slack\n", style="green")
+    console.print()
+    console.print(Panel(body, title="[bold]Next[/bold]", border_style="dim", box=box.ROUNDED))

oneport_debug_cicd/demo/sample_data.py

@@ -0,0 +1,107 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2024 OnePort Debug Contributors
+"""
+Bundled sample data for `oneport-cicd demo`.
+
+A realistic 3 AM regression: the `release/2.4` build of payment-service goes red.
+The last green build was fine. Between green and red, one commit "refactored" a
+guard clause and silently broke the zero-amount rejection — a test caught it, but
+the on-call engineer still has to figure out *which* commit, *who* wrote it, and
+*what* changed.
+
+The demo materializes a real two-commit git repo and runs the REAL
+RegressionDetector over it, so the culprit commit, author, and changed function
+are computed live — not hard-coded. Only the AI narrative is curated so the demo
+needs no API key.
+"""
+from __future__ import annotations
+
+REPO = "payment-service"
+BRANCH = "release/2.4"
+BUILD_NUMBER = "1247"
+WORKFLOW = "ci"
+
+# Last-known-good ("green") version of the file.
+GREEN_PAYMENT = """\
+class PaymentService:
+    \"\"\"Charges a customer's card through the payment gateway.\"\"\"
+
+    def charge(self, amount: int) -> str:
+        # Reject non-positive amounts before we ever hit the gateway.
+        if amount <= 0:
+            raise ValueError("amount must be positive")
+        return f"charged {amount}"
+"""
+
+# The "refactor" that broke the build: <= became <, so charge(0) is now accepted.
+RED_PAYMENT = """\
+class PaymentService:
+    \"\"\"Charges a customer's card through the payment gateway.\"\"\"
+
+    def charge(self, amount: int) -> str:
+        # Reject non-positive amounts before we ever hit the gateway.
+        if amount < 0:
+            raise ValueError("amount must be positive")
+        return f"charged {amount}"
+"""
+
+TEST_FILE = """\
+import pytest
+from services.payment import PaymentService
+
+
+def test_rejects_zero():
+    with pytest.raises(ValueError):
+        PaymentService().charge(0)
+"""
+
+# Authors used for the two commits (so blame is meaningful in the demo).
+GREEN_AUTHOR = ("Alice Green", "alice@corp.com")
+GREEN_MESSAGE = "Add zero-amount guard to PaymentService.charge"
+RED_AUTHOR = ("Bob Builder", "bob@corp.com")
+RED_MESSAGE = "Refactor charge() guard clause"
+
+# The build log the CI runner would have surfaced (last failing job).
+BUILD_LOG = """\
+=== Job: test (step: Run pytest) ===
+============================= test session starts =============================
+collected 5 items
+
+tests/test_payment.py::test_rejects_zero FAILED                          [ 20%]
+
+================================== FAILURES ===================================
+______________________________ test_rejects_zero ______________________________
+
+    def test_rejects_zero():
+        with pytest.raises(ValueError):
+>           PaymentService().charge(0)
+E           Failed: DID NOT RAISE <class 'ValueError'>
+
+tests/test_payment.py:6: Failed
+=========================== short test summary info ===========================
+FAILED tests/test_payment.py::test_rejects_zero - Failed: DID NOT RAISE Value...
+========================= 1 failed, 4 passed in 0.42s =========================
+"""
+
+# Curated AI narrative. The {culprit}/{author}/{loc} placeholders are filled in
+# at runtime with the values the real RegressionDetector computes.
+CURATED_RCA = {
+    "severity": "high",
+    "summary": (
+        f"Build #{BUILD_NUMBER} on {BRANCH} failed: test_rejects_zero now fails "
+        "because PaymentService.charge() no longer rejects a zero amount."
+    ),
+    "root_cause_template": (
+        "Commit {culprit} by {author} changed the guard in "
+        "PaymentService.charge from `amount <= 0` to `amount < 0`. charge(0) is "
+        "now accepted instead of raising ValueError, so test_rejects_zero "
+        "(which asserts a zero charge is rejected) fails. This is the only "
+        "production change between the last green build and this one."
+    ),
+    "recommended_fix": (
+        "Restore the inclusive comparison in services/payment.py: change "
+        "`if amount < 0:` back to `if amount <= 0:`. If zero charges are now "
+        "intentionally allowed, update test_rejects_zero to match the new policy."
+    ),
+    "confidence": 0.93,
+}

oneport_debug_cicd/py.typed

@@ -0,0 +1 @@
+# Marker file for PEP 561. This package ships inline type hints.

oneport_debug_cicd/reporters/__init__.py

@@ -0,0 +1,6 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2024 OnePort Debug Contributors
+from oneport_debug_cicd.reporters.jira_reporter import JiraReporter
+from oneport_debug_cicd.reporters.slack_reporter import SlackReporter
+
+__all__ = ["JiraReporter", "SlackReporter"]