@ngocsangairvds/vsaf 3.2.13 → 3.2.15

package/tools/vds-scripts/audit_orchestrator/src/vds_audit_orchestrator/reports/__init__.py

@@ -1,13 +0,0 @@
-"""Reports module for audit output generation."""
-
-from vds_audit_orchestrator.reports.excel_generator import ExcelReportGenerator
-from vds_audit_orchestrator.reports.gap_report import write_gap_report
-from vds_audit_orchestrator.reports.json_generator import JsonReportGenerator
-from vds_audit_orchestrator.reports.markdown_generator import MarkdownReportGenerator
-
-__all__ = [
-    "ExcelReportGenerator",
-    "JsonReportGenerator",
-    "MarkdownReportGenerator",
-    "write_gap_report",
-]

package/tools/vds-scripts/audit_orchestrator/src/vds_audit_orchestrator/reports/aggregation_report.py

@@ -1,86 +0,0 @@
-"""Aggregation report generator for multi-repo audits."""
-
-from __future__ import annotations
-
-from pathlib import Path
-from typing import TYPE_CHECKING
-
-from openpyxl import Workbook
-from openpyxl.styles import Alignment, Font, PatternFill
-from openpyxl.utils import get_column_letter
-
-if TYPE_CHECKING:
-    from vds_audit_orchestrator.engine.aggregator import AggregatedResult
-
-_HEADER_FILL = PatternFill(start_color="2F5597", end_color="2F5597", fill_type="solid")
-_HEADER_FONT = Font(bold=True, color="FFFFFF")
-_HEADER_ALIGNMENT = Alignment(horizontal="center", vertical="center", wrap_text=True)
-
-
-def _apply_header(ws, headers: list[str]) -> None:
-    for col, header in enumerate(headers, 1):
-        cell = ws.cell(row=1, column=col, value=header)
-        cell.fill = _HEADER_FILL
-        cell.font = _HEADER_FONT
-        cell.alignment = _HEADER_ALIGNMENT
-        ws.column_dimensions[get_column_letter(col)].width = max(16, len(header) + 2)
-
-
-def write_aggregation_report(result: AggregatedResult, output_path: Path) -> None:
-    """Write organization-level aggregation report to Excel."""
-    wb = Workbook()
-    ws_summary = wb.active
-    if ws_summary is None:
-        ws_summary = wb.create_sheet("Summary")
-    else:
-        ws_summary.title = "Summary"
-    ws_common = wb.create_sheet("Common Gaps")
-
-    summary_headers = [
-        "Repository",
-        "Score",
-        "Maturity",
-        "Critical",
-        "High",
-        "Medium",
-        "Low",
-        "Aligned",
-    ]
-    _apply_header(ws_summary, summary_headers)
-
-    row = 2
-    for repo in result.repositories:
-        ws_summary.cell(row=row, column=1, value=repo.repository)
-        ws_summary.cell(row=row, column=2, value=repo.overall_score)
-        ws_summary.cell(row=row, column=3, value=repo.maturity_level)
-        ws_summary.cell(row=row, column=4, value=repo.critical_count)
-        ws_summary.cell(row=row, column=5, value=repo.high_count)
-        ws_summary.cell(row=row, column=6, value=repo.medium_count)
-        ws_summary.cell(row=row, column=7, value=repo.low_count)
-        ws_summary.cell(row=row, column=8, value=repo.aligned_count)
-        row += 1
-
-    ws_summary.cell(row=row + 1, column=1, value="Average Score")
-    ws_summary.cell(row=row + 1, column=2, value=result.avg_score)
-    ws_summary.cell(row=row + 2, column=1, value="Min Score")
-    ws_summary.cell(row=row + 2, column=2, value=result.min_score)
-    ws_summary.cell(row=row + 3, column=1, value="Max Score")
-    ws_summary.cell(row=row + 3, column=2, value=result.max_score)
-
-    common_headers = ["Category", "Description", "Severity", "Occurrences", "Affected Repos"]
-    _apply_header(ws_common, common_headers)
-
-    row = 2
-    for gap in result.common_gaps:
-        ws_common.cell(row=row, column=1, value=gap.get("category"))
-        ws_common.cell(row=row, column=2, value=gap.get("description"))
-        ws_common.cell(row=row, column=3, value=gap.get("severity"))
-        ws_common.cell(row=row, column=4, value=gap.get("occurrence_count"))
-        ws_common.cell(row=row, column=5, value=", ".join(gap.get("affected_repos", [])))
-        row += 1
-
-    if row == 2:
-        ws_common.cell(row=2, column=1, value="No common gaps detected")
-
-    output_path.parent.mkdir(parents=True, exist_ok=True)
-    wb.save(output_path)

package/tools/vds-scripts/audit_orchestrator/src/vds_audit_orchestrator/reports/checklist_generator.py

@@ -1,425 +0,0 @@
-"""Checklist Generator for Phase 18 (TSK-180).
-
-Generates strict AuditChecklist artifacts from templates and agent results.
-Ensures 1:1 row mapping and produces localized Excel outputs.
-"""
-
-from __future__ import annotations
-
-import hashlib
-from pathlib import Path
-from typing import Any
-
-from openpyxl import Workbook
-from openpyxl.styles import Alignment, Border, Font, PatternFill, Side
-from openpyxl.utils import get_column_letter
-from structlog import get_logger
-
-from vds_audit_orchestrator.agents.base import AgentResult
-from vds_audit_orchestrator.models.checklist import (
-    AuditChecklist,
-    EvidenceAnchor,
-    RowEvaluation,
-    RowProvenance,
-    RowStatus,
-    ScoreBreakdown,
-)
-from vds_audit_orchestrator.models.findings import CheckFinding
-from vds_audit_orchestrator.models.template import AuditTemplate
-
-logger = get_logger()
-
-# Header definitions for Excel export (Vietnamese)
-EXCEL_HEADERS = [
-    ("STT", 5),
-    ("Quy tắc", 15),
-    ("Tiêu chí chính", 20),
-    ("Tiêu chí con", 40),
-    ("Trọng số", 10),
-    ("Điểm (1-5)", 10),
-    ("Điểm (%)", 10),
-    ("Trạng thái", 12),
-    ("Lý do", 40),
-    ("Phát hiện", 40),
-    ("Minh chứng", 30),
-    ("Kiến nghị", 30),
-]
-
-
-class ChecklistGenerator:
-    """Generates canonical audit checklists from results."""
-
-    def generate(
-        self,
-        template: AuditTemplate,
-        results: list[AgentResult],
-        repo_name: str,
-        repo_ref: str | None = None,
-        llm_mode: str = "selective",
-    ) -> AuditChecklist:
-        """Generate AuditChecklist from template and results."""
-        # Index findings by check_id for O(1) lookup
-        findings_map: dict[str, CheckFinding] = {}
-        for res in results:
-            for finding_data in res.findings:
-                # Handle both dict and object
-                if isinstance(finding_data, dict):
-                    try:
-                        parsed_finding = CheckFinding(**finding_data)
-                    except Exception:
-                        continue  # Skip malformed findings
-                else:
-                    parsed_finding = finding_data
-                findings_map[parsed_finding.check_id] = parsed_finding
-
-        # Create rows preserving template order (Strict 1:1)
-        rows: list[RowEvaluation] = []
-
-        row_idx = 0
-        for section in template.sections:
-            for check in section.checks:
-                row_idx += 1
-                finding = findings_map.get(check.id)
-
-                rows.append(self._create_row(row_idx, check, finding, section.id, template))
-
-        # Build checklist
-        evidence_content = "".join(str(r.evidence_refs) for r in rows)
-        evidence_hash = hashlib.sha256(evidence_content.encode()).hexdigest()[:16]
-
-        # Calculate template hash
-        template_dump = template.model_dump_json()
-        template_hash = hashlib.sha256(template_dump.encode()).hexdigest()[:16]
-
-        return AuditChecklist(
-            template_name=template.name,
-            template_version=template.version,
-            template_hash=template_hash,
-            template_row_count=len(rows),
-            repository=repo_name,
-            repository_ref=repo_ref,
-            row_llm_mode=llm_mode,
-            evidence_hash=evidence_hash,
-            rows=rows,
-        )
-
-    def export_excel(self, checklist: AuditChecklist, output_path: Path) -> Path:
-        """Export checklist to Excel with strict formatting."""
-        wb = Workbook()
-        ws = wb.active
-        if ws is None:
-            ws = wb.create_sheet("Audit Checklist")
-        else:
-            ws.title = "Audit Checklist"
-
-        # Styles
-        header_font = Font(bold=True, color="FFFFFF")
-        header_fill = PatternFill(start_color="4F81BD", end_color="4F81BD", fill_type="solid")
-        border = Border(
-            left=Side(style="thin"),
-            right=Side(style="thin"),
-            top=Side(style="thin"),
-            bottom=Side(style="thin"),
-        )
-        wrap_text = Alignment(wrap_text=True, vertical="top")
-
-        # Write Headers
-        for col_idx, (header, width) in enumerate(EXCEL_HEADERS, 1):
-            cell = ws.cell(row=1, column=col_idx, value=header)
-            cell.font = header_font
-            cell.fill = header_fill
-            cell.alignment = Alignment(horizontal="center", vertical="center")
-            cell.border = border
-            ws.column_dimensions[get_column_letter(col_idx)].width = width
-
-        # Write Rows
-        for r_idx, row in enumerate(checklist.rows, 2):
-            self._write_excel_row(ws, r_idx, row, border, wrap_text)
-
-        output_path.parent.mkdir(parents=True, exist_ok=True)
-        wb.save(output_path)
-        return output_path
-
-    def _create_row(
-        self,
-        index: int,
-        check: Any,
-        finding: CheckFinding | None,
-        section_id: str,
-        template: AuditTemplate,
-    ) -> RowEvaluation:
-        """Create a single RowEvaluation from check and finding."""
-        # Defaults for missing finding
-        status = RowStatus.NA
-        score_breakdown = ScoreBreakdown(raw_score=0.0, final_score=0.0)
-        reason = "Chưa được đánh giá"
-        finding_text = "Không có dữ liệu"
-        evidence_refs = []
-        provenance = RowProvenance(
-            row_llm_mode="off",
-            template_hash="unknown",
-            evidence_hash="unknown",
-            protocol="system",
-            model="deterministic",
-        )
-
-        if finding:
-            # Map finding to row
-            score_val = finding.score_percentage
-            status = RowStatus.from_score(score_val)
-
-            score_breakdown = ScoreBreakdown.compute(
-                raw_score=score_val,
-                confidence=finding.confidence or 1.0,
-            )
-
-            reason = finding.message or "Đã kiểm tra"
-            finding_text = finding.details.get("summary", "") if finding.details else ""
-
-            # Map evidence
-            if finding.evidence:
-                for ev in finding.evidence:
-                    evidence_refs.append(
-                        EvidenceAnchor(
-                            ref_type="text",
-                            ref_value=str(ev)[:100] + "..." if len(str(ev)) > 100 else str(ev),
-                        )
-                    )
-
-            # Map provenance if available in metadata
-            if finding.metadata and "provenance" in finding.metadata:
-                prov_data = finding.metadata["provenance"]
-                # Filter out unknown fields if strict mode
-                provenance = RowProvenance(**prov_data)
-            else:
-                provenance = RowProvenance(
-                    row_llm_mode="selective",
-                    template_hash="derived",
-                    evidence_hash="derived",
-                    protocol="audit-agent",
-                    model="unknown",
-                )
-
-        row = RowEvaluation(
-            row_id=f"{check.id}:row_{index}",
-            row_index=index,
-            check_id=check.id,
-            section_id=section_id,
-            requirement_text=check.description,
-            requirement_category=section_id,  # Simplification
-            weight_raw=check.weight or 0.0,
-            weight_adjusted=check.weight if template.strict_weights else (check.weight or 0.0),
-            status=status,
-            score_breakdown=score_breakdown,
-            reason=reason,
-            finding=finding_text,
-            evidence_refs=evidence_refs,
-            provenance=provenance,
-        )
-
-        # Calculate 1-5 score
-        row.score_1_5 = row.compute_score_1_5()
-        return row
-
-    def _write_excel_row(self, ws: Any, row_idx: int, row: RowEvaluation, border: Any, wrap: Any) -> None:
-        """Write a single row to Excel worksheet."""
-        vals = [
-            row.row_index,
-            row.section_id,  # Quy tắc (using section_id as proxy)
-            row.requirement_category,  # Tiêu chí chính
-            row.requirement_text,  # Tiêu chí con
-            f"{row.weight_adjusted:.1f}",
-            row.score_1_5,
-            f"{row.score_percent:.1f}",
-            row.status_vietnamese,
-            row.reason,
-            row.finding,
-            self._format_evidence_refs(row.evidence_refs),  # Format dual anchors
-            row.recommendation or "",
-        ]
-
-        for c_idx, val in enumerate(vals, 1):
-            cell = ws.cell(row=row_idx, column=c_idx, value=val)
-            cell.border = border
-            cell.alignment = wrap
-
-            # Add hyperlinks for Evidence column (index 11)
-            if c_idx == 11 and row.evidence_refs:
-                # Find first URL anchor for the main hyperlink
-                url_anchor = next((a for a in row.evidence_refs if a.ref_type == "url"), None)
-                if url_anchor and url_anchor.ref_value.startswith("http"):
-                    cell.hyperlink = url_anchor.ref_value
-                    cell.font = Font(color="0563C1", underline="single")
-
-            # Color code status
-            if c_idx == 8:  # Trạng thái
-                if row.status == RowStatus.PASS:
-                    cell.fill = PatternFill(start_color="C6EFCE", end_color="C6EFCE", fill_type="solid")  # Green
-                    cell.font = Font(color="006100")
-                elif row.status == RowStatus.FAIL:
-                    cell.fill = PatternFill(start_color="FFC7CE", end_color="FFC7CE", fill_type="solid")  # Red
-                    cell.font = Font(color="9C0006")
-                elif row.status == RowStatus.PARTIAL:
-                    cell.fill = PatternFill(start_color="FFEB9C", end_color="FFEB9C", fill_type="solid")  # Yellow
-                    cell.font = Font(color="9C6500")
-
-    def _format_evidence_refs(self, anchors: list[EvidenceAnchor]) -> str:
-        """Format evidence anchors for output.
-
-        Groups by type: URLs first, then code paths, then other.
-        Emits dual anchors (docs + code) when available.
-        """
-        lines = []
-
-        # Group anchors by type
-        url_anchors = [a for a in anchors if a.ref_type == "url"]
-        code_anchors = [a for a in anchors if a.ref_type == "code_path"]
-        other_anchors = [a for a in anchors if a.ref_type not in ("url", "code_path")]
-
-        # Format URLs (Confluence links)
-        for anchor in url_anchors:
-            lines.append(f"📄 {anchor.ref_value}")
-
-        # Format code paths
-        for anchor in code_anchors:
-            lines.append(f"💻 {anchor.ref_value}")
-
-        # Format other refs
-        for anchor in other_anchors:
-            lines.append(f"{anchor.ref_type}: {anchor.ref_value}")
-
-        return "\n".join(lines) if lines else ""
-
-
-def write_audit_checklist_artifacts(
-    workflow_result: dict[str, Any],
-    report_dir: Path,
-    thread_id: str,
-    include_markdown: bool = False,
-) -> dict[str, Path]:
-    """Generate checklist artifacts from workflow result dict.
-
-    This acts as the bridge between LangGraph output and the strict Checklist Generator.
-
-    Emits both canonical and thread-specific artifacts:
-    - Canonical: `audit-checklist.json`, `audit-checklist.xlsx`, optionally `audit-checklist.md`
-    - Thread-specific (for debugging/provenance): `audit_checklist_{thread_id}.json`, etc.
-
-    Returns:
-        Dict mapping artifact type to path (e.g., {"json": ..., "xlsx": ..., "md": ...})
-    """
-    logger.info("generating_checklist_artifacts", thread_id=thread_id)
-    artifacts: dict[str, Path] = {}
-
-    # 1. Extract Template
-    template_data = workflow_result.get("template")
-    if not template_data:
-        logger.warning("template_not_found_in_result")
-        return artifacts
-
-    try:
-        template = AuditTemplate(**template_data) if isinstance(template_data, dict) else template_data
-    except Exception as e:
-        logger.exception("template_restoration_failed", error=str(e))
-        return artifacts
-
-    # 2. Extract Results
-    results_data = workflow_result.get("results", [])
-    results: list[AgentResult] = []
-    for r_data in results_data:
-        try:
-            if isinstance(r_data, dict):
-                results.append(AgentResult(**r_data))
-            else:
-                results.append(r_data)
-        except Exception:
-            pass
-
-    repo_name = workflow_result.get("repository", "unknown")
-
-    # 3. Generate Checklist
-    generator = ChecklistGenerator()
-    checklist = generator.generate(template, results, repo_name)
-
-    # 4. Write Canonical Artifacts (primary names)
-    canonical_json_path = report_dir / "audit-checklist.json"
-    canonical_json_path.write_text(checklist.model_dump_json(indent=2), encoding="utf-8")
-    artifacts["json"] = canonical_json_path
-
-    canonical_xlsx_path = report_dir / "audit-checklist.xlsx"
-    generator.export_excel(checklist, canonical_xlsx_path)
-    artifacts["xlsx"] = canonical_xlsx_path
-
-    # 5. Write Thread-Specific Artifacts (for debugging/provenance)
-    thread_json_path = report_dir / f"audit_checklist_{thread_id}.json"
-    thread_json_path.write_text(checklist.model_dump_json(indent=2), encoding="utf-8")
-
-    thread_xlsx_path = report_dir / f"audit_checklist_{thread_id}.xlsx"
-    generator.export_excel(checklist, thread_xlsx_path)
-
-    # 6. Optionally write Markdown
-    if include_markdown:
-        md_content = _generate_checklist_markdown(checklist)
-        canonical_md_path = report_dir / "audit-checklist.md"
-        canonical_md_path.write_text(md_content, encoding="utf-8")
-        artifacts["md"] = canonical_md_path
-
-        thread_md_path = report_dir / f"audit_checklist_{thread_id}.md"
-        thread_md_path.write_text(md_content, encoding="utf-8")
-
-    logger.info(
-        "checklist_artifacts_generated",
-        canonical_json=str(canonical_json_path),
-        canonical_xlsx=str(canonical_xlsx_path),
-        thread_json=str(thread_json_path),
-        thread_xlsx=str(thread_xlsx_path),
-    )
-
-    return artifacts
-
-
-def _generate_checklist_markdown(checklist: AuditChecklist) -> str:
-    """Generate Markdown summary of the checklist."""
-    lines = [
-        f"# Audit Checklist: {checklist.repository or 'Unknown'}",
-        "",
-        f"**Template**: {checklist.template_name} v{checklist.template_version}",
-        f"**Generated**: {checklist.generated_at.isoformat() if checklist.generated_at else 'N/A'}",
-        f"**Total Rows**: {checklist.total_rows}",
-        f"**Overall Score**: {checklist.overall_score:.1f}%",
-        f"**LLM Mode**: {checklist.row_llm_mode}",
-        "",
-        "## Summary",
-        "",
-        "| Status | Count |",
-        "|--------|-------|",
-        f"| ✅ Pass | {checklist.pass_count} |",
-        f"| ⚠️ Partial | {checklist.partial_count} |",
-        f"| ❌ Fail | {checklist.fail_count} |",
-        f"| ⬜ N/A | {checklist.na_count} |",
-        f"| ⚠️ Error | {checklist.error_count} |",
-        "",
-        "## Row Details",
-        "",
-    ]
-
-    for row in checklist.rows:
-        status_emoji = {
-            RowStatus.PASS: "✅",
-            RowStatus.PARTIAL: "⚠️",
-            RowStatus.FAIL: "❌",
-            RowStatus.NA: "⬜",
-            RowStatus.ERROR: "❗",
-        }.get(row.status, "❓")
-
-        lines.append(f"### {row.row_index}. {row.check_id}")
-        lines.append("")
-        lines.append(f"**Status**: {status_emoji} {row.status_vietnamese}")
-        lines.append(f"**Score**: {row.score_percent:.1f}% ({row.score_1_5}/5)")
-        lines.append(f"**Requirement**: {row.requirement_text[:200]}{'...' if len(row.requirement_text) > 200 else ''}")
-        lines.append(f"**Reason**: {row.reason}")
-        if row.finding:
-            lines.append(f"**Finding**: {row.finding[:300]}{'...' if len(row.finding) > 300 else ''}")
-        lines.append("")
-
-    return "\n".join(lines)