Standards Enforcer Bot

def coverage_from_coverage_xml_tool(xml_text: str) -> Dict[str, Any]:
    """
    Compute line/branch coverage percentages from a Cobertura/Jacoco-like XML file.
    Returns: {"line_pct": float, "branch_pct": float}
    """
    if not xml_text:
        return {"line_pct": 0.0, "branch_pct": 0.0}
    try:
        root = ET.fromstring(xml_text)
        line_rate = float(root.attrib.get("line-rate", 0.0)) * 100.0
        branch_rate = float(root.attrib.get("branch-rate", 0.0)) * 100.0
        return {"line_pct": round(line_rate, 2), "branch_pct": round(branch_rate, 2)}
    except Exception:
        return {"line_pct": 0.0, "branch_pct": 0.0}

def coverage_from_lcov_tool(lcov_text: str) -> Dict[str, Any]:
    """
    Compute a line coverage summary from an lcov.info file.
    Returns: {"line_pct": float, "lines_total": int, "lines_covered": int}
    """
    if not lcov_text:
        return {"line_pct": 0.0, "lines_total": 0, "lines_covered": 0}
    total, covered = 0, 0
    for line in lcov_text.splitlines():
        if line.startswith("DA:"):
            try:
                _, rest = line.split("DA:", 1)
                _, count = rest.split(",")
                total += 1
                if int(count) > 0:
                    covered += 1
            except Exception:
                continue
    pct = (covered / total * 100.0) if total else 0.0
    return {"line_pct": round(pct, 2), "lines_total": total, "lines_covered": covered}

def normalize_semgrep_tool(doc_text: str) -> Dict[str, Any]:
    """
    Normalize a Semgrep JSON/YAML report into generic findings.
    Returns: {"findings":[{"rule_id","title","severity","file","line","message"}]}
    """
    data = extract_json_tool(doc_text)["data"] or extract_yaml_tool(doc_text)["data"] or {}
    findings: List[Dict[str, Any]] = []
    for r in (data or {}).get("results", []):
        loc = r.get("path") or (r.get("extra", {}).get("metavars", {}).get("path", {}).get("abstract_content"))
        sev = (r.get("extra", {}).get("severity") or "LOW").upper()
        findings.append(
            {
                "rule_id": r.get("check_id") or r.get("rule_id"),
                "title": r.get("extra", {}).get("message") or "Semgrep finding",
                "severity": sev,
                "file": loc or r.get("path"),
                "line": (r.get("start") or {}).get("line"),
                "message": (r.get("extra", {}).get("metadata") or {}).get("shortlink", ""),
            }
        )
    return {"findings": findings}

def normalize_bandit_tool(doc_text: str) -> Dict[str, Any]:
    """
    Normalize a Bandit JSON/YAML report into generic findings.
    Returns: {"findings":[{"rule_id","title","severity","file","line","message"}]}
    """
    data = extract_json_tool(doc_text)["data"] or extract_yaml_tool(doc_text)["data"] or {}
    findings: List[Dict[str, Any]] = []
    for r in (data or {}).get("results", []):
        findings.append(
            {
                "rule_id": r.get("test_id") or r.get("test_name"),
                "title": r.get("issue_text"),
                "severity": (r.get("issue_severity") or "LOW").upper(),
                "file": r.get("filename"),
                "line": r.get("line_number"),
                "message": r.get("more_info") or r.get("issue_confidence"),
            }
        )
    return {"findings": findings}

def extract_json_tool(text: str) -> Dict[str, Any]:
    """
    Extract a JSON object from arbitrary text.
    Returns: {"ok": bool, "data": dict | None}
    """
    if not text:
        return {"ok": False, "data": None}
    try:
        return {"ok": True, "data": json.loads(text)}
    except Exception:
        start = text.find("{")
        end = text.rfind("}")
        if start >= 0 and end > start:
            try:
                return {"ok": True, "data": json.loads(text[start : end + 1])}
            except Exception:
                return {"ok": False, "data": None}
        return {"ok": False, "data": None}

def extract_yaml_tool(text: str) -> Dict[str, Any]:
    """
    Extract a YAML object from text if PyYAML is available.
    Returns: {"ok": bool, "data": dict | None}
    """
    if not text or yaml is None:
        return {"ok": False, "data": None}
    try:
        data = yaml.safe_load(text)
        return {"ok": True, "data": data}
    except Exception:
        return {"ok": False, "data": None}

def quality_score_tool(coverage_line_pct: float = 0.0, violations: Optional[List[Dict[str, Any]]] = None) -> Dict[str, Any]:
    """
    Compute a 0–100 quality score from coverage percentage and violation severities.
    Returns: {"score": int}
    """
    score = int(max(0.0, min(100.0, float(coverage_line_pct or 0.0))))
    for v in (violations or []):
        sev = (v.get("severity") or "LOW").upper()
        score -= 5 if sev == "HIGH" else 2 if sev == "MEDIUM" else 1
    return {"score": max(0, min(score, 100))}