@ngocsangairvds/vsaf 3.2.13 → 3.2.15

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

@@ -1,213 +0,0 @@
-"""Standalone hierarchy publisher for Phase 106 system documentation."""
-
-from __future__ import annotations
-
-import hashlib
-import re
-import tempfile
-from dataclasses import dataclass
-from pathlib import Path
-
-from .confluence_publisher import ConfluencePublisher, SystemDocSyncPolicy
-from .system_doc_hierarchy_renderer import SystemDocHierarchyRenderer
-
-_HASH_MARKER_RE = re.compile(r"<!--\s*VDS:HIERARCHY:HASH:([a-fA-F0-9]{64})\s*-->")
-
-
-@dataclass(slots=True)
-class ChildPageSyncResult:
-    key: str
-    title: str
-    page_id: str
-    decision: str
-    reason: str
-    token_before: str | None
-    token_after: str | None
-    version_before: int | None = None
-    version_after: int | None = None
-    updated: bool = False
-    skipped: bool = False
-    dry_run: bool = False
-
-
-@dataclass(slots=True)
-class HierarchyDocSyncResult:
-    root_page_id: str
-    root_title: str
-    root_content_hash: str
-    child_results: list[ChildPageSyncResult]
-    decision: str
-    reason: str
-    live_data_populated: bool
-    dry_run: bool = False
-
-
-async def _sync_managed_page(
-    publisher: ConfluencePublisher,
-    *,
-    parent_id: str,
-    title: str,
-    body_html: str,
-    content_hash: str,
-    dry_run: bool,
-    key: str,
-) -> ChildPageSyncResult:
-    existing = await publisher._find_child_page(parent_id, title)
-    if existing is None or not existing.get("id"):
-        if dry_run:
-            return ChildPageSyncResult(
-                key=key,
-                title=title,
-                page_id="",
-                decision="dry-run",
-                reason="sync_policy_dry_run_create",
-                token_before=None,
-                token_after=content_hash,
-                skipped=True,
-                dry_run=True,
-            )
-        page_id = await publisher._ensure_hierarchy_node(parent_id=parent_id, title=title, body_html=body_html)
-        return ChildPageSyncResult(
-            key=key,
-            title=title,
-            page_id=page_id,
-            decision="created",
-            reason="page_created",
-            token_before=None,
-            token_after=content_hash,
-            version_after=1,
-            updated=True,
-        )
-
-    page_id = str(existing.get("id"))
-    page = await publisher._retry(
-        lambda: publisher.client.get_content_page(page_id, expand="body.storage,version"),
-        action="get_content_page",
-        page_id=page_id,
-    )
-    existing_body = publisher._extract_storage_body(page) or ""
-    token_before = extract_remote_hash(existing_body)
-    version_before = publisher._extract_version_number(page)
-    next_version = publisher._extract_version(page)
-
-    if token_before == content_hash:
-        return ChildPageSyncResult(
-            key=key,
-            title=title,
-            page_id=page_id,
-            decision="skipped",
-            reason="sync_policy_if_changed",
-            token_before=token_before,
-            token_after=token_before,
-            version_before=version_before,
-            version_after=version_before,
-            skipped=True,
-            dry_run=False,
-        )
-
-    if dry_run:
-        return ChildPageSyncResult(
-            key=key,
-            title=title,
-            page_id=page_id,
-            decision="dry-run",
-            reason="sync_policy_dry_run",
-            token_before=token_before,
-            token_after=content_hash,
-            version_before=version_before,
-            version_after=version_before,
-            skipped=True,
-            dry_run=True,
-        )
-
-    with tempfile.NamedTemporaryFile(mode="w", suffix=".html", delete=False, encoding="utf-8") as handle:
-        handle.write(body_html)
-        body_path = Path(handle.name)
-    try:
-        await publisher._retry(
-            lambda: publisher.client.update_page(page_id, title=title, body_file=body_path, version=next_version),
-            action="update_page",
-            page_id=page_id,
-            version=next_version,
-        )
-    finally:
-        body_path.unlink(missing_ok=True)
-
-    return ChildPageSyncResult(
-        key=key,
-        title=title,
-        page_id=page_id,
-        decision="updated",
-        reason="content_changed",
-        token_before=token_before,
-        token_after=content_hash,
-        version_before=version_before,
-        version_after=next_version,
-        updated=True,
-    )
-
-
-async def publish_hierarchy(
-    publisher: ConfluencePublisher,
-    *,
-    parent_page_id: str,
-    page_title: str,
-    project_storage_key: str | None = None,
-    state_dsn: str | None = None,
-    sync_policy: SystemDocSyncPolicy | str = SystemDocSyncPolicy.IF_CHANGED,
-    source_root: Path | str | None = None,
-    uv_project_path: str | None = None,
-) -> HierarchyDocSyncResult:
-    dry_run = str(sync_policy) == SystemDocSyncPolicy.DRY_RUN.value or str(sync_policy) == "dry-run"
-    resolved_source_root = Path(source_root).resolve() if source_root is not None else Path.cwd().resolve()
-    renderer = SystemDocHierarchyRenderer(
-        resolved_source_root,
-        project_name=project_storage_key or "CEP",
-        state_dsn=state_dsn,
-        uv_project_path=uv_project_path,
-    )
-    payload = renderer.render()
-
-    root_page_id = await publisher._ensure_hierarchy_node(
-        parent_id=parent_page_id,
-        title=page_title,
-        body_html=payload.root_page.body_html,
-    )
-
-    child_results: list[ChildPageSyncResult] = []
-    for key, child in payload.child_pages.items():
-        result = await _sync_managed_page(
-            publisher,
-            parent_id=root_page_id,
-            title=child.title,
-            body_html=child.body_html,
-            content_hash=child.content_hash,
-            dry_run=dry_run,
-            key=key,
-        )
-        child_results.append(result)
-
-    decision = "updated" if any(item.updated for item in child_results) else "skipped"
-    reason = "content_changed" if decision == "updated" else "sync_policy_if_changed"
-    return HierarchyDocSyncResult(
-        root_page_id=root_page_id,
-        root_title=page_title,
-        root_content_hash=payload.root_page.content_hash,
-        child_results=child_results,
-        decision=decision,
-        reason=reason,
-        live_data_populated=bool(
-            payload.live_data.corpus_metrics or payload.live_data.hierarchy_metrics or payload.live_data.report_metrics
-        ),
-        dry_run=dry_run,
-    )
-
-
-def extract_remote_hash(body_html: str) -> str | None:
-    match = _HASH_MARKER_RE.search(body_html)
-    return match.group(1) if match else None
-
-
-def compute_content_hash(body_html: str) -> str:
-    normalized = body_html.replace("\r\n", "\n").strip()
-    return hashlib.sha256(normalized.encode("utf-8")).hexdigest()

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

@@ -1,152 +0,0 @@
-"""Live data collection for Phase 106 system documentation hierarchy."""
-
-from __future__ import annotations
-
-import json
-import subprocess
-from dataclasses import dataclass, field
-from pathlib import Path
-from typing import Any
-
-from vds_audit_orchestrator.cli_impl import _resolve_project_key, _resolve_state_dsn_from_env
-from vds_audit_orchestrator.doctor_cmds import _collect_hierarchy_status_doctor_payload
-from vds_audit_orchestrator.report_cmds import _filter_latest_per_repo, _load_run_history
-from vds_audit_orchestrator.state.store import PostgresStateStore
-
-
-@dataclass(slots=True)
-class LiveDataCache:
-    corpus_metrics: dict[str, Any] = field(default_factory=dict)
-    hierarchy_metrics: dict[str, Any] = field(default_factory=dict)
-    report_metrics: dict[str, Any] = field(default_factory=dict)
-    warnings: list[str] = field(default_factory=list)
-
-
-class LiveDataInjector:
-    """Collect live metrics for hierarchy pages with in-process first, subprocess fallback second."""
-
-    def __init__(
-        self,
-        *,
-        project_name: str = "CEP",
-        state_dsn: str | None = None,
-        uv_project_path: str | None = None,
-    ) -> None:
-        self.project_name = project_name
-        self.state_dsn = state_dsn or _resolve_state_dsn_from_env()
-        self.uv_project_path = uv_project_path or str(Path(__file__).resolve().parents[3])
-        self._cache: LiveDataCache | None = None
-
-    def collect(self) -> LiveDataCache:
-        if self._cache is not None:
-            return self._cache
-
-        cache = LiveDataCache()
-        cache.corpus_metrics = self._collect_corpus_metrics(cache)
-        cache.hierarchy_metrics = self._collect_hierarchy_metrics(cache)
-        cache.report_metrics = self._collect_report_metrics(cache)
-        self._cache = cache
-        return cache
-
-    def _resolve_project_key(self, cache: LiveDataCache) -> str:
-        if not self.state_dsn:
-            cache.warnings.append("state_dsn_unavailable")
-            return self.project_name
-        try:
-            return _resolve_project_key(project_identifier=self.project_name, state_dsn=self.state_dsn)
-        except Exception:
-            cache.warnings.append("project_key_resolution_failed")
-            return self.project_name
-
-    def _collect_corpus_metrics(self, cache: LiveDataCache) -> dict[str, Any]:
-        if self.state_dsn:
-            try:
-                project_key = self._resolve_project_key(cache)
-                store = PostgresStateStore(self.state_dsn)
-                try:
-                    project_id = store.resolve_project_id(project_key)
-                    result = store.corpus_status_diagnostics(project_key=project_key, project_id=project_id)
-                    return {"status": "ok", **result}
-                finally:
-                    store.close()
-            except Exception:
-                cache.warnings.append("corpus_inprocess_failed")
-        return self._subprocess_collect(cache, ["doctor", "corpus-status", "--project", self.project_name])
-
-    def _collect_hierarchy_metrics(self, cache: LiveDataCache) -> dict[str, Any]:
-        if self.state_dsn:
-            try:
-                project_key = self._resolve_project_key(cache)
-                return _collect_hierarchy_status_doctor_payload(
-                    state_dsn=self.state_dsn,
-                    project=project_key,
-                    sample_limit=5,
-                )
-            except Exception:
-                cache.warnings.append("hierarchy_inprocess_failed")
-        return self._subprocess_collect(cache, ["doctor", "hierarchy-status", "--project", self.project_name])
-
-    def _collect_report_metrics(self, cache: LiveDataCache) -> dict[str, Any]:
-        try:
-            project_key = self._resolve_project_key(cache)
-            entries = _load_run_history(project_key)
-            if entries:
-                latest = _filter_latest_per_repo(entries)
-                scores = [
-                    float(summary.get("overall_score"))
-                    for entry in latest
-                    if isinstance((summary := entry.get("summary") or {}), dict)
-                    and summary.get("overall_score") is not None
-                ]
-                avg_score = round(sum(scores) / len(scores), 2) if scores else None
-                return {
-                    "status": "ok",
-                    "project": project_key,
-                    "count": len(entries),
-                    "latest_count": len(latest),
-                    "average_score": avg_score,
-                    "entries": latest,
-                }
-        except Exception:
-            cache.warnings.append("report_inprocess_failed")
-        return self._subprocess_collect(cache, ["report", "list", "--project", self.project_name, "--latest-only"])
-
-    def _subprocess_collect(self, cache: LiveDataCache, args: list[str]) -> dict[str, Any]:
-        command = [
-            "uv",
-            "run",
-            "--project",
-            self.uv_project_path,
-            "vds-audit",
-            "--json-only",
-            *args,
-        ]
-        if self.state_dsn:
-            command.extend(["--state-dsn", self.state_dsn])
-        try:
-            result = subprocess.run(command, capture_output=True, text=True, timeout=30, check=False)
-            if result.returncode != 0:
-                cache.warnings.append(f"subprocess_failed:{' '.join(args)}")
-                return {"status": "error", "error": result.stderr.strip() or result.stdout.strip()}
-            payload = json.loads(result.stdout or "{}")
-            if isinstance(payload, dict):
-                return payload
-        except Exception as exc:
-            cache.warnings.append(f"subprocess_exception:{type(exc).__name__}")
-            return {"status": "error", "error": str(exc)}
-        return {"status": "error", "error": "invalid_subprocess_payload"}
-
-    @staticmethod
-    def summarize_for_root(cache: LiveDataCache) -> dict[str, str]:
-        corpus = cache.corpus_metrics if isinstance(cache.corpus_metrics, dict) else {}
-        hierarchy = cache.hierarchy_metrics if isinstance(cache.hierarchy_metrics, dict) else {}
-        report = cache.report_metrics if isinstance(cache.report_metrics, dict) else {}
-        hierarchy_inner = hierarchy.get("hierarchy") if isinstance(hierarchy.get("hierarchy"), dict) else {}
-        return {
-            "repositories": str(hierarchy_inner.get("repo_count", 0)),
-            "confluence_pages": str(corpus.get("total_documents", 0)),
-            "corpus_chunks": str(corpus.get("total_chunks", 0)),
-            "audit_runs": str(report.get("count", 0)),
-            "overall_score": str(report.get("average_score", "—")),
-            "health_status": str(corpus.get("health_status", "unknown")),
-        }

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

@@ -1,101 +0,0 @@
-"""Helper for building Confluence Storage Format macros."""
-
-from html import escape
-
-
-class ConfluenceMacroBuilder:
-    """Builder for Confluence Storage Format macros."""
-
-    @staticmethod
-    def status_macro(title: str, color: str, subtle: bool = False) -> str:
-        """Build a Status macro.
-
-        Args:
-            title: The text to display inside the lozenge.
-            color: One of 'Grey', 'Red', 'Yellow', 'Green', 'Blue'.
-            subtle: If True, uses lighter background with colored text.
-        """
-        valid_colors = {"Grey", "Red", "Yellow", "Green", "Blue"}
-        if color not in valid_colors:
-            color = "Grey"
-
-        params = [
-            f'<ac:parameter ac:name="colour">{color}</ac:parameter>',
-            f'<ac:parameter ac:name="title">{escape(title)}</ac:parameter>',
-        ]
-
-        if subtle:
-            params.append('<ac:parameter ac:name="subtle">true</ac:parameter>')
-
-        return '<ac:structured-macro ac:name="status">' + "".join(params) + "</ac:structured-macro>"
-
-    @staticmethod
-    def expand_macro(title: str, body: str) -> str:
-        """Build an Expand macro with a rich text body.
-
-        Args:
-            title: The title of the collapsible section.
-            body: The HTML content inside the section.
-        """
-        return (
-            '<ac:structured-macro ac:name="expand">'
-            f'<ac:parameter ac:name="title">{escape(title)}</ac:parameter>'
-            "<ac:rich-text-body>"
-            f"{body}"
-            "</ac:rich-text-body>"
-            "</ac:structured-macro>"
-        )
-
-    @staticmethod
-    def page_properties_macro(body: str) -> str:
-        """Build a Page Properties (details) macro.
-
-        Args:
-            body: The HTML content (usually a table) with properties.
-        """
-        return (
-            '<ac:structured-macro ac:name="details">'
-            "<ac:rich-text-body>"
-            f"{body}"
-            "</ac:rich-text-body>"
-            "</ac:structured-macro>"
-        )
-
-    @staticmethod
-    def link_to_page(title: str, space_key: str | None = None) -> str:
-        """Build a link to a Confluence page."""
-        space_attr = f' ri:space-key="{escape(space_key)}"' if space_key else ""
-        return f'<ac:link><ri:page ri:content-title="{escape(title)}"{space_attr}/></ac:link>'
-
-    @staticmethod
-    def link_to_attachment(filename: str) -> str:
-        """Build a link to an attachment on the current page."""
-        return f'<ac:link><ri:attachment ri:filename="{escape(filename)}"/></ac:link>'
-
-    @staticmethod
-    def info_macro(*, title: str, body: str, icon: str = "info") -> str:
-        """Build a Confluence Info/Note/Warning/Tip panel macro.
-
-        Args:
-            title: The panel title.
-            body: The HTML content inside the panel.
-            icon: One of 'info', 'note', 'warning', 'tip', 'check'.
-                  Maps to the Confluence macro name.
-        """
-        # Map icon hints to Confluence macro names
-        macro_map = {
-            "info": "info",
-            "note": "note",
-            "warning": "warning",
-            "tip": "tip",
-            "check": "tip",  # 'check' renders as green tip panel
-        }
-        macro_name = macro_map.get(icon, "info")
-        return (
-            f'<ac:structured-macro ac:name="{macro_name}">'
-            f'<ac:parameter ac:name="title">{escape(title)}</ac:parameter>'
-            "<ac:rich-text-body>"
-            f"{body}"
-            "</ac:rich-text-body>"
-            "</ac:structured-macro>"
-        )

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

@@ -1,154 +0,0 @@
-"""Markdown to Confluence storage converter.
-
-Uses markdown-it-py for robust conversion if available, falling back to
-a simple implementation if not.
-"""
-
-from __future__ import annotations
-
-import re
-from html import escape
-
-from structlog import get_logger
-
-logger = get_logger(__name__)
-
-try:
-    from markdown_it import MarkdownIt
-
-    _MarkdownIt: type[MarkdownIt] | None = MarkdownIt  # Store for type checker
-    _markdown_it_available = True
-except ImportError:
-    _MarkdownIt = None
-    _markdown_it_available = False
-
-
-def to_storage(markdown_text: str) -> str:
-    """Convert Markdown to Confluence storage HTML."""
-    if _markdown_it_available and _MarkdownIt is not None:
-        try:
-            # Use commonmark configuration
-            md = _MarkdownIt("commonmark", {"breaks": True, "html": True})
-            return md.render(markdown_text)
-        except Exception as e:
-            logger.warning("markdown_it_conversion_failed", error=str(e))
-            # Fall back to simple converter
-
-    return _simple_to_storage(markdown_text)
-
-
-def _simple_to_storage(markdown_text: str) -> str:
-    """Convert Markdown to a simple Confluence storage HTML subset (fallback)."""
-    lines = markdown_text.splitlines()
-    out: list[str] = []
-    in_code = False
-    in_list = False
-
-    def close_list() -> None:
-        nonlocal in_list
-        if in_list:
-            out.append("</ul>")
-            in_list = False
-
-    def render_inline(text: str) -> str:
-        if "`" not in text:
-            return escape(text)
-        parts = re.split(r"(`[^`]+`)", text)
-        rendered: list[str] = []
-        for part in parts:
-            if part.startswith("`") and part.endswith("`") and len(part) >= 2:
-                code = part[1:-1]
-                rendered.append(f"<code>{escape(code)}</code>")
-            else:
-                rendered.append(escape(part))
-        return "".join(rendered)
-
-    def is_table_separator(line: str) -> bool:
-        return bool(re.match(r"^\s*\|?(\s*:?-+:?\s*\|)+\s*:?-+:?\s*\|?\s*$", line))
-
-    def split_table_row(line: str) -> list[str]:
-        stripped = line.strip()
-        if stripped.startswith("|"):
-            stripped = stripped[1:]
-        if stripped.endswith("|"):
-            stripped = stripped[:-1]
-        return [cell.strip() for cell in stripped.split("|")]
-
-    i = 0
-    while i < len(lines):
-        line = lines[i]
-        stripped = line.rstrip()
-        if stripped.startswith("```"):
-            if in_list:
-                close_list()
-            if not in_code:
-                out.append("<pre><code>")
-                in_code = True
-            else:
-                out.append("</code></pre>")
-                in_code = False
-            i += 1
-            continue
-
-        if in_code:
-            out.append(escape(stripped))
-            i += 1
-            continue
-
-        if i + 1 < len(lines) and "|" in stripped and is_table_separator(lines[i + 1]):
-            close_list()
-            header_cells = split_table_row(stripped)
-            body_rows: list[list[str]] = []
-            i += 2
-            while i < len(lines):
-                row_line = lines[i].rstrip()
-                if not row_line.strip() or "|" not in row_line:
-                    break
-                body_rows.append(split_table_row(row_line))
-                i += 1
-            out.append("<table>")
-            out.append("<thead><tr>")
-            for cell in header_cells:
-                out.append(f"<th>{render_inline(cell)}</th>")
-            out.append("</tr></thead>")
-            out.append("<tbody>")
-            for row in body_rows:
-                out.append("<tr>")
-                for cell in row:
-                    out.append(f"<td>{render_inline(cell)}</td>")
-                out.append("</tr>")
-            out.append("</tbody></table>")
-            continue
-
-        if not stripped:
-            close_list()
-            i += 1
-            continue
-
-        if stripped.startswith("#"):
-            close_list()
-            level = len(stripped) - len(stripped.lstrip("#"))
-            level = min(max(level, 1), 6)
-            text = stripped[level:].strip()
-            out.append(f"<h{level}>{render_inline(text)}</h{level}>")
-            i += 1
-            continue
-
-        if stripped.startswith("- "):
-            if not in_list:
-                out.append("<ul>")
-                in_list = True
-            item = stripped[2:].strip()
-            out.append(f"<li>{render_inline(item)}</li>")
-            i += 1
-            continue
-
-        close_list()
-        out.append(f"<p>{render_inline(stripped)}</p>")
-        i += 1
-
-    if in_code:
-        out.append("</code></pre>")
-    close_list()
-
-    return "\n".join(out)