autopkg-wrapper 2026.2.6__py3-none-any.whl → 2026.2.9__py3-none-any.whl

autopkg_wrapper/utils/report_processor.py

@@ -4,11 +4,11 @@ import os
 import plistlib
 import re
 import zipfile
-from typing import Dict, List, Optional, Tuple
+from pathlib import Path
 
 
-def find_report_dirs(base_path: str) -> List[str]:
-    dirs: List[str] = []
+def find_report_dirs(base_path: str) -> list[str]:
+    dirs: list[str] = []
     if not os.path.exists(base_path):
         return dirs
     for root, subdirs, _files in os.walk(base_path):
@@ -28,9 +28,9 @@ def find_report_dirs(base_path: str) -> List[str]:
     return sorted(dirs)
 
 
-def parse_json_file(path: str) -> Dict:
+def parse_json_file(path: str) -> dict:
     try:
-        with open(path, "r", encoding="utf-8") as f:
+        with open(path, encoding="utf-8") as f:
             return json.load(f)
     except Exception:
         return {}
@@ -46,10 +46,46 @@ def _infer_recipe_name_from_filename(path: str) -> str:
     return base
 
 
-def parse_text_file(path: str) -> Dict[str, List]:
-    uploads: List[Dict] = []
-    policies: List[Dict] = []
-    errors: List[str] = []
+def _resolve_recipe_name(name: str, recipe_link_map: dict[str, str] | None) -> str:
+    if not recipe_link_map:
+        return name
+    if name in recipe_link_map:
+        return name
+    candidates = [
+        recipe_name
+        for recipe_name in recipe_link_map
+        if recipe_name.startswith(f"{name}.")
+    ]
+    if len(candidates) == 1:
+        return candidates[0]
+    return name
+
+
+def _build_recipe_link_map(
+    repo_path: str | None, repo_url: str | None, repo_branch: str | None
+) -> dict[str, str]:
+    if not repo_path or not repo_url or not repo_branch:
+        return {}
+    repo_root = Path(repo_path)
+    if not repo_root.exists():
+        return {}
+
+    recipe_link_map: dict[str, str] = {}
+    for path in repo_root.rglob("*.recipe*"):
+        if not path.is_file():
+            continue
+        rel = path.relative_to(repo_root).as_posix()
+        recipe_base = path.name
+        recipe_name = recipe_base.split(".recipe", 1)[0]
+        if recipe_name not in recipe_link_map:
+            recipe_link_map[recipe_name] = f"{repo_url}/blob/{repo_branch}/{rel}"
+    return recipe_link_map
+
+
+def parse_text_file(path: str) -> dict[str, list]:
+    uploads: list[dict] = []
+    policies: list[dict] = []
+    errors: list[str] = []
 
     re_error = re.compile(r"ERROR[:\s-]+(.+)", re.IGNORECASE)
     re_upload = re.compile(
@@ -59,7 +95,7 @@ def parse_text_file(path: str) -> Dict[str, List]:
     re_policy = re.compile(r"Policy (created|updated):\s*(?P<name>.+)", re.IGNORECASE)
 
     try:
-        with open(path, "r", encoding="utf-8", errors="ignore") as f:
+        with open(path, encoding="utf-8", errors="ignore") as f:
             for line in f:
                 m_err = re_error.search(line)
                 if m_err:
@@ -91,13 +127,15 @@ def parse_text_file(path: str) -> Dict[str, List]:
     return {"uploads": uploads, "policies": policies, "errors": errors}
 
 
-def parse_plist_file(path: str) -> Dict[str, List]:
-    uploads: List[Dict] = []
-    policies: List[Dict] = []
-    errors: List[str] = []
-    upload_rows: List[Dict] = []
-    policy_rows: List[Dict] = []
-    error_rows: List[Dict] = []
+def parse_plist_file(
+    path: str, *, recipe_link_map: dict[str, str] | None = None
+) -> dict[str, list]:
+    uploads: list[dict] = []
+    policies: list[dict] = []
+    errors: list[str] = []
+    upload_rows: list[dict] = []
+    policy_rows: list[dict] = []
+    error_rows: list[dict] = []
 
     try:
         with open(path, "rb") as f:
@@ -117,10 +155,16 @@ def parse_plist_file(path: str) -> Dict[str, List]:
     sr = plist.get("summary_results", {}) or {}
 
     recipe_name = _infer_recipe_name_from_filename(path)
-    recipe_identifier: Optional[str] = None
+    if recipe_link_map:
+        recipe_name = _resolve_recipe_name(recipe_name, recipe_link_map)
+    recipe_identifier: str | None = None
+    recipe_link = (recipe_link_map or {}).get(recipe_name)
+
+    handled_keys: set[str] = set()
 
     jpu = sr.get("jamfpackageuploader_summary_result")
     if isinstance(jpu, dict):
+        handled_keys.add("jamfpackageuploader_summary_result")
         rows = jpu.get("data_rows") or []
         for row in rows:
             name = (row.get("name") or row.get("pkg_display_name") or "-").strip()
@@ -140,12 +184,38 @@ def parse_plist_file(path: str) -> Dict[str, List]:
                 {
                     "recipe_name": recipe_name,
                     "recipe_identifier": recipe_identifier or "-",
+                    "recipe_url": recipe_link,
                     "package": pkg_name,
                     "version": version or "-",
                 }
             )
 
+    jpol = sr.get("jamfpolicyuploader_summary_result")
+    if isinstance(jpol, dict):
+        handled_keys.add("jamfpolicyuploader_summary_result")
+        rows = jpol.get("data_rows") or []
+        for row in rows:
+            name = (
+                row.get("policy")
+                or row.get("policy_name")
+                or row.get("name")
+                or row.get("title")
+            )
+            if not name:
+                continue
+            policies.append({"name": str(name).strip(), "action": "-"})
+            policy_rows.append(
+                {
+                    "recipe_name": recipe_name,
+                    "recipe_identifier": recipe_identifier or "-",
+                    "recipe_url": recipe_link,
+                    "policy": str(name).strip(),
+                }
+            )
+
     for key, block in sr.items():
+        if key in handled_keys:
+            continue
         if not isinstance(block, dict):
             continue
         hdr = [h.lower() for h in (block.get("header") or [])]
@@ -171,6 +241,7 @@ def parse_plist_file(path: str) -> Dict[str, List]:
                         {
                             "recipe_name": recipe_name,
                             "recipe_identifier": recipe_identifier or "-",
+                            "recipe_url": recipe_link,
                             "policy": str(name).strip(),
                         }
                     )
@@ -200,7 +271,11 @@ def parse_plist_file(path: str) -> Dict[str, List]:
     }
 
 
-def aggregate_reports(base_path: str) -> Dict:
+def aggregate_reports(
+    base_path: str,
+    *,
+    recipe_link_map: dict[str, str] | None = None,
+) -> dict:
     summary = {
         "uploads": [],
         "policies": [],
@@ -219,7 +294,7 @@ def aggregate_reports(base_path: str) -> Dict:
                 ext = os.path.splitext(fn)[1].lower()
 
                 if ext == ".plist":
-                    data = parse_plist_file(p)
+                    data = parse_plist_file(p, recipe_link_map=recipe_link_map)
                     summary["uploads"] += data.get("uploads", [])
                     summary["policies"] += data.get("policies", [])
                     summary["errors"] += data.get("errors", [])
@@ -270,8 +345,8 @@ def aggregate_reports(base_path: str) -> Dict:
 
 
 def _aggregate_for_display(
-    summary: Dict,
-) -> Tuple[Dict[str, set], Dict[str, set], Dict[str, int]]:
+    summary: dict,
+) -> tuple[dict[str, set], dict[str, set], dict[str, int]]:
     uploads = summary.get("uploads", [])
     policies = summary.get("policies", [])
     errors = summary.get("errors", [])
@@ -281,11 +356,9 @@ def _aggregate_for_display(
             return False
         if n.lower() in {"apps", "packages", "pkg", "file", "37"}:
             return False
-        if not re.search(r"[A-Za-z]", n):
-            return False
-        return True
+        return re.search(r"[A-Za-z]", n) is not None
 
-    uploads_by_app: Dict[str, set] = {}
+    uploads_by_app: dict[str, set] = {}
     for u in uploads:
         if isinstance(u, dict):
             name = (u.get("name") or "-").strip()
@@ -297,7 +370,7 @@ def _aggregate_for_display(
             name = "-"
         uploads_by_app.setdefault(name, set()).add(ver)
 
-    policies_by_name: Dict[str, set] = {}
+    policies_by_name: dict[str, set] = {}
     for p in policies:
         if isinstance(p, dict):
             name = (p.get("name") or "-").strip()
@@ -307,7 +380,7 @@ def _aggregate_for_display(
             action = "-"
         policies_by_name.setdefault(name, set()).add(action)
 
-    error_categories: Dict[str, int] = {
+    error_categories: dict[str, int] = {
         "trust": 0,
         "signature": 0,
         "download": 0,
@@ -353,9 +426,9 @@ def _aggregate_for_display(
     return uploads_by_app, policies_by_name, error_categories
 
 
-def render_job_summary(summary: Dict, environment: str, run_date: str) -> str:
-    lines: List[str] = []
-    title_bits: List[str] = []
+def render_job_summary(summary: dict, environment: str, run_date: str) -> str:
+    lines: list[str] = []
+    title_bits: list[str] = []
     if environment:
         title_bits.append(environment)
     if run_date:
@@ -394,8 +467,13 @@ def render_job_summary(summary: Dict, environment: str, run_date: str) -> str:
             pkg = row.get("package", "-")
             pkg_url = row.get("package_url")
             pkg_cell = f"[{pkg}]({pkg_url})" if pkg_url else pkg
+            recipe_name = row.get("recipe_name", "-")
+            recipe_url = row.get("recipe_url")
+            recipe_cell = (
+                f"[{recipe_name}]({recipe_url})" if recipe_url else recipe_name
+            )
             lines.append(
-                f"| {row.get('recipe_name', '-')} | {row.get('recipe_identifier', '-')} | {pkg_cell} | {row.get('version', '-')} |"
+                f"| {recipe_cell} | {row.get('recipe_identifier', '-')} | {pkg_cell} | {row.get('version', '-')} |"
             )
         lines.append("")
     else:
@@ -410,8 +488,16 @@ def render_job_summary(summary: Dict, environment: str, run_date: str) -> str:
         for row in sorted(
             summary["policy_rows"], key=lambda r: str(r.get("recipe_name", "")).lower()
         ):
+            recipe_name = row.get("recipe_name", "-")
+            recipe_url = row.get("recipe_url")
+            recipe_cell = (
+                f"[{recipe_name}]({recipe_url})" if recipe_url else recipe_name
+            )
+            policy = row.get("policy", "-")
+            policy_url = row.get("policy_url")
+            policy_cell = f"[{policy}]({policy_url})" if policy_url else policy
             lines.append(
-                f"| {row.get('recipe_name', '-')} | {row.get('recipe_identifier', '-')} | {row.get('policy', '-')} |"
+                f"| {recipe_cell} | {row.get('recipe_identifier', '-')} | {policy_cell} |"
             )
         lines.append("")
 
@@ -435,15 +521,15 @@ def render_job_summary(summary: Dict, environment: str, run_date: str) -> str:
     return "\n".join(lines)
 
 
-def render_issue_body(summary: Dict, environment: str, run_date: str) -> str:
-    lines: List[str] = []
+def render_issue_body(summary: dict, environment: str, run_date: str) -> str:
+    lines: list[str] = []
     total_errors = len(summary.get("errors", []))
     _uploads_by_app, _policies_by_name, _error_categories = _aggregate_for_display(
         summary
     )
 
     prefix = "Autopkg run"
-    suffix_bits: List[str] = []
+    suffix_bits: list[str] = []
     if run_date:
         suffix_bits.append(f"on {run_date}")
     if environment:
@@ -523,10 +609,10 @@ def _normalize_host(url: str) -> str:
     return h.rstrip("/")
 
 
-def build_pkg_map(jss_url: str, client_id: str, client_secret: str) -> Dict[str, str]:
+def build_pkg_map(jss_url: str, client_id: str, client_secret: str) -> dict[str, str]:
     host = _normalize_host(jss_url)
     _ = host  # silence linters about unused var; kept for readability
-    pkg_map: Dict[str, str] = {}
+    pkg_map: dict[str, str] = {}
     try:
         from jamf_pro_sdk import (  # type: ignore
             ApiClientCredentialsProvider,
@@ -540,8 +626,8 @@ def build_pkg_map(jss_url: str, client_id: str, client_secret: str) -> Dict[str,
         packages = client.pro_api.get_packages_v1()
         for p in packages:
             try:
-                name = str(getattr(p, "packageName")).strip()
-                pid = str(getattr(p, "id")).strip()
+                name = str(p.packageName).strip()
+                pid = str(p.id).strip()
             except Exception as e:  # noqa: F841
                 # ignore objects that do not match expected shape
                 continue
@@ -555,35 +641,92 @@ def build_pkg_map(jss_url: str, client_id: str, client_secret: str) -> Dict[str,
     return pkg_map
 
 
-def enrich_upload_rows(upload_rows: List[Dict], pkg_map: Dict[str, str]) -> int:
+def build_policy_map(
+    jss_url: str, client_id: str, client_secret: str
+) -> dict[str, str]:
+    host = _normalize_host(jss_url)
+    _ = host  # silence linters about unused var; kept for readability
+    policy_map: dict[str, str] = {}
+    try:
+        from jamf_pro_sdk import (  # type: ignore
+            ApiClientCredentialsProvider,
+            JamfProClient,
+        )
+
+        client = JamfProClient(
+            _normalize_host(jss_url),
+            ApiClientCredentialsProvider(client_id, client_secret),
+        )
+        policies = client.pro_api.get_policies()
+        for p in policies:
+            try:
+                name = str(p.name).strip()
+                pid = str(p.id).strip()
+            except Exception:
+                continue
+            if not name or not pid:
+                continue
+            url = f"{jss_url}/policies.html?id={pid}"
+            if name not in policy_map:
+                policy_map[name] = url
+    except Exception:
+        return {}
+    return policy_map
+
+
+def enrich_upload_rows(upload_rows: list[dict], pkg_map: dict[str, str]) -> int:
     linked = 0
+    norm_map = {k.lower(): v for k, v in pkg_map.items()}
     for row in upload_rows:
         pkg_name = str(row.get("package") or "").strip()
-        url = pkg_map.get(pkg_name)
+        url = pkg_map.get(pkg_name) or norm_map.get(pkg_name.lower())
         if url:
             row["package_url"] = url
             linked += 1
     return linked
 
 
+def enrich_policy_rows(policy_rows: list[dict], policy_map: dict[str, str]) -> int:
+    linked = 0
+    norm_map = {k.lower(): v for k, v in policy_map.items()}
+    for row in policy_rows:
+        policy_name = str(row.get("policy") or "").strip()
+        url = policy_map.get(policy_name) or norm_map.get(policy_name.lower())
+        if url:
+            row["policy_url"] = url
+            linked += 1
+    return linked
+
+
 def enrich_upload_rows_with_jamf(
-    summary: Dict, jss_url: str, client_id: str, client_secret: str
-) -> Tuple[int, List[str]]:
+    summary: dict, jss_url: str, client_id: str, client_secret: str
+) -> tuple[int, list[str]]:
     pkg_map = build_pkg_map(jss_url, client_id, client_secret)
     linked = enrich_upload_rows(summary.get("upload_rows", []), pkg_map)
     return linked, sorted(set(pkg_map.keys()))
 
 
+def enrich_policy_rows_with_jamf(
+    summary: dict, jss_url: str, client_id: str, client_secret: str
+) -> tuple[int, list[str]]:
+    policy_map = build_policy_map(jss_url, client_id, client_secret)
+    linked = enrich_policy_rows(summary.get("policy_rows", []), policy_map)
+    return linked, sorted(set(policy_map.keys()))
+
+
 def process_reports(
     *,
-    zip_file: Optional[str],
+    zip_file: str | None,
     extract_dir: str,
-    reports_dir: Optional[str],
+    reports_dir: str | None,
     environment: str = "",
     run_date: str = "",
     out_dir: str,
     debug: bool,
     strict: bool,
+    repo_url: str | None = None,
+    repo_branch: str | None = None,
+    repo_path: str | None = None,
 ) -> int:
     os.makedirs(out_dir, exist_ok=True)
 
@@ -598,23 +741,38 @@ def process_reports(
     else:
         process_dir = reports_dir or extract_dir
 
-    summary = aggregate_reports(process_dir)
+    recipe_link_map = _build_recipe_link_map(repo_path, repo_url, repo_branch)
+    summary = aggregate_reports(process_dir, recipe_link_map=recipe_link_map)
 
     jss_url = os.environ.get("AUTOPKG_JSS_URL")
     jss_client_id = os.environ.get("AUTOPKG_CLIENT_ID")
     jss_client_secret = os.environ.get("AUTOPKG_CLIENT_SECRET")
     jamf_attempted = False
     jamf_linked = 0
-    jamf_keys: List[str] = []
+    jamf_keys: list[str] = []
+    jamf_policy_linked = 0
+    jamf_policy_keys: list[str] = []
     jamf_total = len(summary.get("upload_rows", []))
-    if jss_url and jss_client_id and jss_client_secret and jamf_total:
+    jamf_policy_total = len(summary.get("policy_rows", []))
+    if (
+        jss_url
+        and jss_client_id
+        and jss_client_secret
+        and (jamf_total or jamf_policy_total)
+    ):
         jamf_attempted = True
         try:
-            jamf_linked, jamf_keys = enrich_upload_rows_with_jamf(
-                summary, jss_url, jss_client_id, jss_client_secret
-            )
+            if jamf_total:
+                jamf_linked, jamf_keys = enrich_upload_rows_with_jamf(
+                    summary, jss_url, jss_client_id, jss_client_secret
+                )
+            if jamf_policy_total:
+                jamf_policy_linked, jamf_policy_keys = enrich_policy_rows_with_jamf(
+                    summary, jss_url, jss_client_id, jss_client_secret
+                )
         except Exception:
             jamf_linked = 0
+            jamf_policy_linked = 0
 
     job_md = render_job_summary(summary, environment, run_date)
     issue_md = None
@@ -636,20 +794,38 @@ def process_reports(
                 str(r.get("package") or "").strip()
                 for r in summary.get("upload_rows", [])
             ]
+            policy_names = [
+                str(r.get("policy") or "").strip()
+                for r in summary.get("policy_rows", [])
+            ]
             matched = [
                 r for r in summary.get("upload_rows", []) if r.get("package_url")
             ]
             unmatched = [
                 r for r in summary.get("upload_rows", []) if not r.get("package_url")
             ]
+            policy_matched = [
+                r for r in summary.get("policy_rows", []) if r.get("policy_url")
+            ]
+            policy_unmatched = [
+                r for r in summary.get("policy_rows", []) if not r.get("policy_url")
+            ]
             diag = {
                 "jss_url": jss_url or "",
                 "jamf_keys_count": len(jamf_keys),
                 "jamf_keys_sample": jamf_keys[:20],
+                "jamf_policy_keys_count": len(jamf_policy_keys),
+                "jamf_policy_keys_sample": jamf_policy_keys[:20],
                 "uploads_count": len(upload_pkg_names),
                 "matched_count": len(matched),
                 "unmatched_count": len(unmatched),
                 "unmatched_names": [r.get("package") for r in unmatched][:20],
+                "policies_count": len(policy_names),
+                "policy_matched_count": len(policy_matched),
+                "policy_unmatched_count": len(policy_unmatched),
+                "policy_unmatched_names": [r.get("policy") for r in policy_unmatched][
+                    :20
+                ],
             }
             with open(jamf_log_path, "w", encoding="utf-8") as jf:
                 json.dump(diag, jf, indent=2)
@@ -662,11 +838,13 @@ def process_reports(
         f"Errors file: {'errors_issue.md' if issue_md else 'none'}",
     ]
     if jamf_attempted:
-        status.append(f"Jamf links added: {jamf_linked}/{jamf_total}")
+        status.append(
+            f"Jamf links added: packages {jamf_linked}/{jamf_total}, policies {jamf_policy_linked}/{jamf_policy_total}"
+        )
         if jamf_log_path:
             status.append(f"Jamf lookup log: '{jamf_log_path}'")
     else:
-        status.append("Jamf links: skipped (missing env or no uploads)")
+        status.append("Jamf links: skipped (missing env or no uploads/policies)")
     logging.info(". ".join(status))
 
     if strict and summary.get("errors"):