@ngocsangairvds/vsaf 3.2.14 → 3.2.15

package/tools/vds-scripts/audit_orchestrator/src/vds_audit_orchestrator/publishers/priority_renderer.py

@@ -1,133 +0,0 @@
-"""Renderer for the Priority Actions section.
-
-Phase 144Q: Bitbucket link resolution (TSK-144Q.2), field sanitization (TSK-144Q.3).
-"""
-
-from html import escape
-from typing import TYPE_CHECKING, Any
-
-from vds_audit_orchestrator.models.checklist import AuditChecklist, RowStatus
-from vds_audit_orchestrator.publishers._field_sanitizer import sanitize_row_field
-from vds_audit_orchestrator.publishers.macro_builder import ConfluenceMacroBuilder
-
-if TYPE_CHECKING:
-    from vds_audit_orchestrator.publishers.bitbucket_link_resolver import BitbucketLinkResolver
-
-
-class PriorityActionsRenderer:
-    """Renders the Priority Actions section for Confluence."""
-
-    def __init__(self, *, bitbucket_link_resolver: BitbucketLinkResolver | None = None) -> None:
-        """Initialize renderer with optional Bitbucket link resolver.
-
-        Args:
-            bitbucket_link_resolver: Optional resolver for converting local code paths
-                to Bitbucket browse URLs. If None, paths are rendered as plain text.
-        """
-        self._bitbucket_link_resolver = bitbucket_link_resolver
-
-    def render(self, checklist: AuditChecklist, limit: int = 10) -> str:
-        """Render the priority actions table.
-
-        Filters for actionable items (FAIL, PARTIAL, ERROR), sorts by severity/weight,
-        and returns a Confluence HTML table.
-        """
-        # 1. Use checklist model ranking as primary source, then include ERROR rows.
-        rows = checklist.get_top_findings(limit=max(limit * 2, limit), include_partial=True)
-        error_rows = [r for r in checklist.rows if r.status == RowStatus.ERROR]
-        if error_rows:
-            rows.extend(error_rows)
-            deduped = []
-            seen: set[str] = set()
-            for row in rows:
-                row_key = row.row_id or str(row.row_index)
-                if row_key in seen:
-                    continue
-                deduped.append(row)
-                seen.add(row_key)
-            rows = deduped
-
-        if not rows:
-            return ""
-
-        # 2. Sort rows
-        rows.sort(key=self._priority_sort_key)
-
-        # 3. Apply limit
-        rows = rows[:limit]
-
-        # 4. Build Table
-        headers = ["Mức độ", "Hành động khuyến nghị", "Nỗ lực", "Tham khảo", "Trọng số"]
-        thead_cells = "".join(f"<th>{h}</th>" for h in headers)
-        thead = f"<thead><tr>{thead_cells}</tr></thead>"
-
-        tbody_rows = []
-        for row in rows:
-            severity = getattr(row, "severity", None)
-            effort = getattr(row, "effort", None)
-            recommendation = getattr(row, "recommendation", None)
-
-            severity_macro = self._build_severity_macro(severity)
-
-            # TSK-144Q.3: sanitize action_text BEFORE escape
-            raw_action = row.finding or row.reason or ""
-            action_text = sanitize_row_field(raw_action)
-            if len(action_text) > 200:
-                action_text = action_text[:200] + "..."
-
-            effort_str = effort or "-"
-
-            # TSK-144Q.2: resolve recommendation to Bitbucket URL if applicable
-            reference_html = "-"
-            if recommendation:
-                if recommendation.startswith(("http://", "https://")):
-                    reference_html = f'<a href="{escape(recommendation)}">Link</a>'
-                else:
-                    resolved_url = (
-                        self._bitbucket_link_resolver.resolve(recommendation) if self._bitbucket_link_resolver else None
-                    )
-                    if resolved_url:
-                        reference_html = f'<a href="{escape(resolved_url)}">{escape(recommendation)}</a>'
-                    else:
-                        reference_html = escape(recommendation)
-
-            cells = [
-                f"<td>{severity_macro}</td>",
-                f"<td>{escape(action_text)}</td>",
-                f"<td>{escape(effort_str)}</td>",
-                f"<td>{reference_html}</td>",
-                f"<td>{row.weight_adjusted}</td>",
-            ]
-            tbody_rows.append(f"<tr>{''.join(cells)}</tr>")
-
-        return f"<h2>Hành động ưu tiên</h2><table>{thead}<tbody>{''.join(tbody_rows)}</tbody></table>"
-
-    def _priority_sort_key(self, row: Any) -> tuple[int, int, float]:
-        """Sort key for priority actions."""
-        sev = (getattr(row, "severity", None) or "").upper()
-        severity_map = {
-            "CRITICAL": 0,
-            "HIGH": 1,
-            "MEDIUM": 2,
-            "LOW": 3,
-            "INFO": 4,
-        }
-        severity_rank = severity_map.get(sev, 5)
-        weight_rank = -1 * (row.weight_adjusted or 0)
-        score_rank = row.score_percent
-        return (severity_rank, weight_rank, score_rank)
-
-    def _build_severity_macro(self, severity: str | None) -> str:
-        """Build Confluence Status macro for severity."""
-        sev = (severity or "").upper()
-
-        if sev == "CRITICAL":
-            return ConfluenceMacroBuilder.status_macro("CRITICAL", "Red", subtle=False)
-        elif sev == "HIGH":
-            return ConfluenceMacroBuilder.status_macro("HIGH", "Red", subtle=True)
-        elif sev == "MEDIUM":
-            return ConfluenceMacroBuilder.status_macro("MEDIUM", "Yellow", subtle=True)
-        elif sev == "LOW":
-            return ConfluenceMacroBuilder.status_macro("LOW", "Blue", subtle=True)
-
-        return ConfluenceMacroBuilder.status_macro(sev or "INFO", "Grey", subtle=True)

package/tools/vds-scripts/audit_orchestrator/src/vds_audit_orchestrator/publishers/project_aggregate_renderer.py

@@ -1,423 +0,0 @@
-"""Confluence full-page renderer for project-level readiness aggregation (Phase 85 WP-85.5).
-
-TSK-850.22: ProjectAggregateRenderer
-
-Phase 113: Project-scope artifact integration (FR-113.6, TSK-113.8).
-
-Renders a standalone Confluence storage format page for a
-ProjectReadinessReport with cross-repo comparison, severity matrix,
-forecast, recommendations, and project artifacts.
-"""
-
-from __future__ import annotations
-
-from html import escape
-from typing import cast
-
-from vds_audit_orchestrator.models.readiness import (
-    ClassificationTier,
-    ProjectArtifactReference,
-    ProjectReadinessReport,
-    ProjectReadinessReportWithArtifacts,
-    SeverityLevel,
-)
-from vds_audit_orchestrator.publishers.macro_builder import ConfluenceMacroBuilder
-
-# Reuse tier/severity mappings from the section renderer
-_TIER_MACRO_MAP: dict[ClassificationTier, tuple[str, str, bool]] = {
-    ClassificationTier.commercially_ready: ("San sang thuong mai", "Green", False),
-    ClassificationTier.internally_ready: ("San sang noi bo", "Blue", True),
-    ClassificationTier.in_progress: ("Dang trien khai", "Yellow", False),
-    ClassificationTier.not_ready: ("Chua san sang", "Red", False),
-}
-
-_SEVERITY_MACRO_MAP: dict[SeverityLevel, tuple[str, str, bool]] = {
-    SeverityLevel.P0_CRITICAL: ("P0 - Nghiem trong", "Red", False),
-    SeverityLevel.P1_HIGH: ("P1 - Cao", "Red", True),
-    SeverityLevel.P2_MEDIUM: ("P2 - Trung binh", "Yellow", True),
-}
-
-_EMPTY_PLACEHOLDER = "<p><em>(Khong co muc nao)</em></p>"
-
-
-class ProjectAggregateRenderer:
-    """Renders a full Confluence page for a ProjectReadinessReport."""
-
-    def render_page(self, report: ProjectReadinessReport) -> str:
-        """Render complete Confluence storage format HTML page.
-
-        Sections:
-        1. Info macro panel (project metadata)
-        2. Cross-repo comparison table
-        3. Cross-repo severity matrix
-        4. Project-scope artifacts (Phase 113, TSK-113.8)
-        5. Consolidated improvement forecast
-        6. Project recommendations
-
-        Phase 113: If report is ProjectReadinessReportWithArtifacts, includes
-        project topology, dependency graph, and cycle report artifacts.
-        """
-        sections = [
-            self._render_info_panel(report),
-            self._render_data_quality_banner(report),
-            self._render_cross_repo_table(report),
-            self._render_severity_matrix(report),
-            self._render_project_artifacts(report),  # Phase 113
-            self._render_forecast(report),
-            self._render_recommendations(report),
-        ]
-        return "\n".join(sections)
-
-    # ------------------------------------------------------------------
-    # 1. Info macro panel
-    # ------------------------------------------------------------------
-
-    def _render_info_panel(self, report: ProjectReadinessReport) -> str:
-        summary = report.executive_summary
-        tier = summary.classification
-        label, color, subtle = _TIER_MACRO_MAP.get(tier, (str(tier.value), "Grey", True))
-        badge = ConfluenceMacroBuilder.status_macro(label, color, subtle=subtle)
-
-        body_lines = [
-            f"<p><strong>Du an:</strong> {escape(report.project_name)}</p>",
-            f"<p><strong>Ngay danh gia:</strong> {escape(str(report.assessment_date))}</p>",
-            f"<p><strong>Phan loai:</strong> {badge}</p>",
-            f"<p><strong>Diem tong:</strong> {summary.readiness_score_pct:.1f}%</p>",
-            f"<p><strong>Do tin cay:</strong> {summary.confidence} ({summary.confidence_pct:.0f}%)</p>",
-            f"<p>{escape(summary.general_assessment)}</p>",
-        ]
-        body_html = "\n".join(body_lines)
-
-        info_macro = (
-            '<ac:structured-macro ac:name="info">'
-            "<ac:rich-text-body>"
-            f"{body_html}"
-            "</ac:rich-text-body>"
-            "</ac:structured-macro>"
-        )
-        return info_macro
-
-    def _render_data_quality_banner(self, report: ProjectReadinessReport) -> str:
-        notes = [str(item).strip() for item in report.data_quality_notes if str(item).strip()]
-        if report.synthesis_status == "complete" and not notes:
-            return ""
-
-        title = "Ket qua tam thoi" if report.synthesis_status != "complete" else "Luu y chat luong du lieu"
-        paragraphs = "".join(f"<p>{escape(note)}</p>" for note in notes) or "<p>Du lieu tong hop chua hoan tat.</p>"
-        return (
-            '<ac:structured-macro ac:name="warning">'
-            f'<ac:parameter ac:name="title">{escape(title)}</ac:parameter>'
-            "<ac:rich-text-body>"
-            f"{paragraphs}"
-            "</ac:rich-text-body>"
-            "</ac:structured-macro>"
-        )
-
-    # ------------------------------------------------------------------
-    # 2. Cross-repo comparison table
-    # ------------------------------------------------------------------
-
-    def _render_cross_repo_table(self, report: ProjectReadinessReport) -> str:
-        if not report.repo_readiness:
-            return f"<h2>So sanh giua cac repository</h2>\n{_EMPTY_PLACEHOLDER}"
-
-        headers = ["Ten repository", "Diem (%)", "Phan loai", "Van de hang dau"]
-        thead_cells = "".join(f"<th>{h}</th>" for h in headers)
-        thead = f"<thead><tr>{thead_cells}</tr></thead>"
-
-        tbody_rows: list[str] = []
-        for repo in report.repo_readiness:
-            tier = repo.classification
-            label, color, subtle = _TIER_MACRO_MAP.get(tier, (str(tier.value), "Grey", True))
-            tier_macro = ConfluenceMacroBuilder.status_macro(label, color, subtle=subtle)
-
-            # Repo name as ac:link
-            repo_link = ConfluenceMacroBuilder.link_to_page(repo.name)
-
-            issues_text = "; ".join(repo.top_issues) if repo.top_issues else ""
-
-            cells = [
-                f"<td>{repo_link}</td>",
-                f"<td>{repo.score:.1f}</td>",
-                f"<td>{tier_macro}</td>",
-                f"<td>{escape(issues_text)}</td>",
-            ]
-            tbody_rows.append(f"<tr>{''.join(cells)}</tr>")
-
-        table = f"<table>{thead}<tbody>{''.join(tbody_rows)}</tbody></table>"
-        return f"<h2>So sanh giua cac repository</h2>\n{table}"
-
-    # ------------------------------------------------------------------
-    # 3. Cross-repo severity matrix
-    # ------------------------------------------------------------------
-
-    def _render_severity_matrix(self, report: ProjectReadinessReport) -> str:
-        if not report.cross_repo_severity_matrix:
-            return f"<h2>Ma tran nghiem trong</h2>\n{_EMPTY_PLACEHOLDER}"
-
-        headers = ["Danh muc", "Tieu chi phu", "Muc do", "Van de chinh", "Hau qua"]
-        thead_cells = "".join(f"<th>{h}</th>" for h in headers)
-        thead = f"<thead><tr>{thead_cells}</tr></thead>"
-
-        tbody_rows: list[str] = []
-        for entry in report.cross_repo_severity_matrix:
-            sev_label, sev_color, sev_subtle = _SEVERITY_MACRO_MAP.get(
-                entry.severity, (entry.severity.value, "Grey", True)
-            )
-            sev_macro = ConfluenceMacroBuilder.status_macro(sev_label, sev_color, subtle=sev_subtle)
-
-            cells = [
-                f"<td>{escape(entry.category)}</td>",
-                f"<td>{escape(entry.sub_criterion)}</td>",
-                f"<td>{sev_macro}</td>",
-                f"<td>{escape(entry.key_issue)}</td>",
-                f"<td>{escape(entry.consequence)}</td>",
-            ]
-            tbody_rows.append(f"<tr>{''.join(cells)}</tr>")
-
-        table = f"<table>{thead}<tbody>{''.join(tbody_rows)}</tbody></table>"
-        return f"<h2>Ma tran nghiem trong</h2>\n{table}"
-
-    # ------------------------------------------------------------------
-    # 4. Project-scope artifacts (Phase 113, TSK-113.8, FR-113.6)
-    # ------------------------------------------------------------------
-
-    def _render_project_artifacts(self, report: ProjectReadinessReport) -> str:
-        """Render project-level artifacts generated during project-scope execution.
-
-        Phase 113 (TSK-113.8): Surfaces project topology, dependency graph,
-        and cycle report artifacts with user-facing links/titles.
-
-        FR-113.6 AC-113.6.1: Project-scope artifacts included in outputs.
-        FR-113.6 AC-113.6.2: User-facing evidence with artifact names/links.
-        """
-        # Check if report has Phase 113 artifact extensions
-        if not isinstance(report, ProjectReadinessReportWithArtifacts):
-            return ""
-
-        artifacts_report = cast("ProjectReadinessReportWithArtifacts", report)
-
-        # Collect all artifacts
-        all_artifacts: list[ProjectArtifactReference] = []
-        if artifacts_report.project_topology_artifact:
-            all_artifacts.append(artifacts_report.project_topology_artifact)
-        if artifacts_report.dependency_graph_artifact:
-            all_artifacts.append(artifacts_report.dependency_graph_artifact)
-        if artifacts_report.cycle_report_artifact:
-            all_artifacts.append(artifacts_report.cycle_report_artifact)
-        all_artifacts.extend(artifacts_report.other_artifacts)
-
-        if not all_artifacts:
-            return ""
-
-        # Render artifacts section
-        parts: list[str] = ["<h2>Artifacts Project-Level</h2>"]
-
-        for artifact in all_artifacts:
-            parts.append(self._render_single_artifact(artifact))
-
-        # Add cross-repo evidence summary if present
-        if artifacts_report.cross_repo_evidence:
-            parts.append(self._render_cross_repo_evidence_summary(artifacts_report))
-
-        # Add evidence classification notes
-        if artifacts_report.evidence_classification_notes:
-            parts.append(self._render_evidence_classification_notes(artifacts_report))
-
-        return "\n".join(parts)
-
-    def _render_single_artifact(self, artifact: ProjectArtifactReference) -> str:
-        """Render a single project artifact as an info panel with link.
-
-        Phase 113 (TSK-113.8): Human-facing artifact reference with internal
-        grounding IDs preserved for replay/verification.
-        """
-        # Build artifact display name
-        type_label = self._get_artifact_type_label(artifact.artifact_type)
-
-        # Build link - prefer artifact_url, otherwise show artifact_path
-        if artifact.artifact_url:
-            display_ref = f'<a href="{escape(artifact.artifact_url)}">{escape(artifact.artifact_type)}</a>'
-        else:
-            # For filesystem paths, use the filename as display
-            path_name = artifact.artifact_path.split("/")[-1]
-            display_ref = f"<code>{escape(path_name)}</code>"
-
-        # Authoritative badge
-        badge = (
-            ConfluenceMacroBuilder.status_macro("Authoritative", "Blue", subtle=True)
-            if artifact.is_authoritative
-            else ""
-        )
-
-        # Provenance info (for replay/verification)
-        provenance = artifact.provenance or {}
-        run_id = provenance.get("run_id", "")
-        thread_id = provenance.get("thread_id", "")
-        provenance_text = ""
-        if run_id or thread_id:
-            parts = []
-            if run_id:
-                parts.append(f"Run: {escape(str(run_id)[:20])}")
-            if thread_id:
-                parts.append(f"Thread: {escape(str(thread_id)[:20])}")
-            provenance_text = f"<p><em>{', '.join(parts)}</em></p>"
-
-        return (
-            '<ac:structured-macro ac:name="info">'
-            f'<ac:parameter ac:name="title">{escape(type_label)}</ac:parameter>'
-            "<ac:rich-text-body>"
-            f"<p><strong>Artifact:</strong> {display_ref} {badge}</p>"
-            f"{provenance_text}"
-            "</ac:rich-text-body>"
-            "</ac:structured-macro>"
-        )
-
-    def _render_cross_repo_evidence_summary(self, report: ProjectReadinessReportWithArtifacts) -> str:
-        """Render summary of cross-repo row evidence from project-scope execution.
-
-        Phase 113 (TSK-113.8): Shows which cross-repo rows were closed
-        authoritatively with project artifacts.
-        """
-        if not report.cross_repo_evidence:
-            return ""
-
-        parts: list[str] = ["<h3>Cross-Repo Row Evidence</h3>"]
-
-        for evidence in report.cross_repo_evidence:
-            status_color = {
-                "pass": "Green",
-                "partial": "Yellow",
-                "fail": "Red",
-                "preliminary": "Grey",
-            }.get(evidence.status.lower(), "Grey")
-
-            status_macro = ConfluenceMacroBuilder.status_macro(evidence.status.upper(), status_color, subtle=True)
-
-            # Show repo-local status if different
-            repo_local_note = ""
-            if evidence.repo_local_status and evidence.repo_local_status != evidence.status:
-                repo_local_note = f" (repo-local was {escape(evidence.repo_local_status.upper())})"
-
-            parts.append(
-                f"<p><strong>{escape(evidence.check_id)}:</strong> "
-                f"{escape(evidence.check_title)}{repo_local_note} - {status_macro}</p>"
-            )
-
-            # Show closure notes
-            if evidence.closure_notes:
-                parts.append(f"<p><em>{escape(evidence.closure_notes)}</em></p>")
-
-            # Show authoritative artifacts
-            if evidence.authoritative_artifacts:
-                artifact_links = []
-                for art in evidence.authoritative_artifacts:
-                    if art.artifact_url:
-                        artifact_links.append(f'<a href="{escape(art.artifact_url)}">{escape(art.artifact_type)}</a>')
-                    else:
-                        artifact_links.append(f"<code>{escape(art.artifact_type)}</code>")
-                parts.append(f"<p><strong>Authoritative artifacts:</strong> {', '.join(artifact_links)}</p>")
-
-            # Show cross-repo findings
-            if evidence.cross_repo_findings:
-                parts.append("<ul>")
-                for finding in evidence.cross_repo_findings:
-                    parts.append(f"<li>{escape(finding)}</li>")
-                parts.append("</ul>")
-
-        return "\n".join(parts)
-
-    def _render_evidence_classification_notes(self, report: ProjectReadinessReportWithArtifacts) -> str:
-        """Render notes distinguishing authoritative vs preliminary evidence.
-
-        Phase 113 (FR-113.6 AC-113.6.3): Workflow summaries and retrieval trace
-        distinguish repo-local preliminary evidence from authoritative closure.
-        """
-        if not report.evidence_classification_notes:
-            return ""
-
-        parts: list[str] = [
-            '<ac:structured-macro ac:name="note">'
-            '<ac:parameter ac:name="title">Evidence Classification</ac:parameter>'
-            "<ac:rich-text-body>"
-        ]
-
-        for note in report.evidence_classification_notes:
-            parts.append(f"<p>{escape(note)}</p>")
-
-        parts.append("</ac:rich-text-body></ac:structured-macro>")
-        return "\n".join(parts)
-
-    @staticmethod
-    def _get_artifact_type_label(artifact_type: str) -> str:
-        """Get human-readable label for artifact type."""
-        labels = {
-            "topology": "Project Topology",
-            "dependency_graph": "Dependency Graph",
-            "cycle_report": "Cycle Detection Report",
-            "project_topology": "Project Topology",
-            "project-dependency-graph": "Dependency Graph",
-            "project-cycle-report": "Cycle Report",
-        }
-        return labels.get(artifact_type.lower(), artifact_type)
-
-    # ------------------------------------------------------------------
-    # 5. Consolidated forecast
-    # ------------------------------------------------------------------
-
-    def _render_forecast(self, report: ProjectReadinessReport) -> str:
-        if not report.improvement_forecast:
-            return f"<h2>Du bao tong hop</h2>\n{_EMPTY_PLACEHOLDER}"
-
-        headers = ["Uu tien", "Nhom hanh dong", "No luc", "Tang diem", "Diem du bao"]
-        thead_cells = "".join(f"<th>{h}</th>" for h in headers)
-        thead = f"<thead><tr>{thead_cells}</tr></thead>"
-
-        tbody_rows: list[str] = []
-        for idx, entry in enumerate(report.improvement_forecast, 1):
-            cells = [
-                f"<td>{idx}</td>",
-                f"<td>{escape(entry.action_group)}</td>",
-                f"<td>{escape(entry.estimated_effort)}</td>",
-                f"<td>+{entry.expected_score_increase_pct:.1f}%</td>",
-                f"<td>{entry.projected_score_after_pct:.1f}%</td>",
-            ]
-            tbody_rows.append(f"<tr>{''.join(cells)}</tr>")
-
-        table = f"<table>{thead}<tbody>{''.join(tbody_rows)}</tbody></table>"
-        return f"<h2>Du bao tong hop</h2>\n{table}"
-
-    # ------------------------------------------------------------------
-    # 5. Project recommendations
-    # ------------------------------------------------------------------
-
-    def _render_recommendations(self, report: ProjectReadinessReport) -> str:
-        parts: list[str] = ["<h2>Khuyen nghi du an</h2>"]
-
-        parts.append("<h3>Khuyen nghi ngan han</h3>")
-        if report.short_term_recommendations:
-            for idx, item in enumerate(report.short_term_recommendations, 1):
-                parts.append(
-                    f"<p>{idx}. <strong>{escape(item.category)}</strong>: "
-                    f"{escape(item.action)} "
-                    f"({escape(item.timeframe)})"
-                    f"{' - ' + escape(item.score_impact) if item.score_impact else ''}"
-                    f"</p>"
-                )
-        else:
-            parts.append(_EMPTY_PLACEHOLDER)
-
-        parts.append("<h3>Khuyen nghi dai han</h3>")
-        if report.long_term_recommendations:
-            for idx, item in enumerate(report.long_term_recommendations, 1):
-                parts.append(
-                    f"<p>{idx}. <strong>{escape(item.category)}</strong>: "
-                    f"{escape(item.action)} "
-                    f"({escape(item.timeframe)})"
-                    f"{' - ' + escape(item.score_impact) if item.score_impact else ''}"
-                    f"</p>"
-                )
-        else:
-            parts.append(_EMPTY_PLACEHOLDER)
-
-        return "\n".join(parts)