@ngocsangairvds/vsaf 4.1.7 → 4.1.9

package/skills/vds-skill/vds-scripts/confluence_orchestrator/src/confluence_orchestrator/orchestration.py

@@ -1,166 +0,0 @@
-"""Batch polling and webhook management utilities for Confluence Server/DC."""
-
-from __future__ import annotations
-
-import builtins
-import time
-from collections.abc import Iterable, Iterator, Sequence
-from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Any
-
-if TYPE_CHECKING:
-    from .http import ConfluenceClient
-
-
-@dataclass(slots=True)
-class BatchMetrics:
-    """Execution metrics captured during a batch scan."""
-
-    scanned: int = 0
-    pages_processed: int = 0
-    requests: int = 0
-    started_at: float = field(default_factory=time.time)
-    finished_at: float | None = None
-
-    def mark_request(self) -> None:
-        self.requests += 1
-
-    def mark_processed(self, count: int) -> None:
-        self.pages_processed += count
-
-    def mark_finished(self) -> None:
-        self.finished_at = time.time()
-
-    @property
-    def duration_seconds(self) -> float | None:
-        if self.finished_at is None:
-            return None
-        return round(self.finished_at - self.started_at, 3)
-
-
-class BatchRunner:
-    """Polling utilities for change detection using REST v1 CQL queries."""
-
-    def __init__(
-        self,
-        http_client: ConfluenceClient,
-        *,
-        expand: Sequence[str] | None = None,
-    ) -> None:
-        self._http = http_client
-        self._expand = expand
-        self._last_metrics: BatchMetrics | None = None
-
-    def scan(
-        self,
-        cql: str,
-        *,
-        limit: int = 25,
-        max_results: int | None = None,
-        start: int = 0,
-        expand: Sequence[str] | None = None,
-    ) -> Iterator[dict[str, Any]]:
-        """Yield individual content results for the given CQL query."""
-
-        metrics = BatchMetrics()
-        self._last_metrics = metrics
-        applied_expand = expand if expand is not None else self._expand
-        fetched = 0
-        current_start = start
-
-        while True:
-            remaining = None if max_results is None else max_results - fetched
-            page_limit = limit if remaining is None else min(limit, remaining)
-            params = {
-                "cql": cql,
-                "limit": page_limit,
-                "start": current_start,
-            }
-            if applied_expand:
-                params["expand"] = ",".join(applied_expand)
-
-            metrics.mark_request()
-            # Use SDK's cql method instead of raw request
-            payload = self._http.search_cql(cql, limit=page_limit, expand=applied_expand, start=current_start)
-            results = payload.get("results", [])
-            count = len(results)
-            if not results:
-                break
-            metrics.mark_processed(count)
-            metrics.scanned += count
-            for item in results:
-                fetched += 1
-                yield item
-
-            current_start = payload.get("start", current_start) + count
-            if max_results is not None and fetched >= max_results:
-                break
-
-        metrics.mark_finished()
-        self._last_metrics = metrics
-
-    def snapshot(
-        self,
-        cql: str,
-        *,
-        limit: int = 25,
-        max_results: int | None = None,
-        expand: Sequence[str] | None = None,
-    ) -> dict[str, Any]:
-        """Return an aggregated snapshot for reporting pipelines."""
-
-        results: list[dict[str, Any]] = []
-        for item in self.scan(cql, limit=limit, max_results=max_results, expand=expand):
-            results.append(item)
-        return {
-            "cql": cql,
-            "limit": limit,
-            "maxResults": max_results,
-            "count": len(results),
-            "results": results,
-        }
-
-    @property
-    def last_metrics(self) -> BatchMetrics | None:
-        return self._last_metrics
-
-
-class WebhookClient:
-    """Manage Confluence Server/DC webhooks via REST v1."""
-
-    _BASE_PATH = "/rest/webhooks/1.0/webhook"
-
-    def __init__(self, http_client: ConfluenceClient) -> None:
-        self._http = http_client
-
-    def create(
-        self,
-        *,
-        name: str,
-        url: str,
-        events: Iterable[str],
-        active: bool = True,
-        filters: dict[str, Any] | None = None,
-    ) -> dict[str, Any]:
-        payload = {
-            "name": name,
-            "url": url,
-            "events": list(events),
-            "excludeBody": False,
-            "active": active,
-        }
-        if filters:
-            payload["filters"] = filters
-        response = self._http.request("POST", self._BASE_PATH, json=payload)
-        return response.json()
-
-    def list(self) -> builtins.list[dict[str, Any]]:
-        response = self._http.request("GET", self._BASE_PATH)
-        payload = response.json()
-        return payload if isinstance(payload, list) else payload.get("results", [])
-
-    def delete(self, webhook_id: str) -> None:
-        self._http.request("DELETE", f"{self._BASE_PATH}/{webhook_id}")
-
-
-__all__ = ["BatchMetrics", "BatchRunner", "WebhookClient"]

package/skills/vds-skill/vds-scripts/confluence_orchestrator/src/confluence_orchestrator/protocols.py

@@ -1,61 +0,0 @@
-from __future__ import annotations
-
-from typing import Any, Protocol, runtime_checkable
-
-
-@runtime_checkable
-class ConfluenceClientProtocol(Protocol):
-    """Canonical Confluence client protocol for audit-facing operations."""
-
-    async def get_page(self, page_id: str, *, expand: str | None = None) -> dict[str, Any] | None: ...
-    async def search_cql(self, cql: str, limit: int = 25, start: int = 0) -> list[dict[str, Any]]: ...
-    async def create_page(
-        self,
-        *,
-        space_key: str,
-        title: str,
-        body_file: Any,
-        parent_id: str | None = None,
-    ) -> dict[str, Any]: ...
-    async def update_page(
-        self,
-        page_id: str,
-        *,
-        title: str | None = None,
-        body: str | None = None,
-        body_file: Any | None = None,
-        version: int | None = None,
-        parent_id: str | None = None,
-    ) -> dict[str, Any]: ...
-    async def list_child_pages(self, page_id: str) -> list[dict[str, Any]]: ...
-    async def create_or_update_page(
-        self,
-        *,
-        space_key: str,
-        title: str,
-        body_file: Any,
-        parent_id: str | None = None,
-    ) -> dict[str, Any]: ...
-    async def upload_attachment(self, *, page_id: str, file_path: Any) -> dict[str, Any]: ...
-    async def delete_page(self, page_id: str) -> None: ...
-    async def move_page(
-        self,
-        page_id: str,
-        target_title: str,
-        position: str = "append",
-        *,
-        space_key: str | None = None,
-    ) -> dict[str, Any]: ...
-    async def get_page_conditional(
-        self,
-        page_id: str,
-        *,
-        etag: str | None = None,
-        last_modified: Any | None = None,
-        cached_version: int | str | None = None,
-        expand: str | None = None,
-    ) -> tuple[bool, dict[str, Any] | None]: ...
-    async def resolve_tiny_url(self, tiny_id: str) -> str | None: ...
-
-
-__all__ = ["ConfluenceClientProtocol"]

package/skills/vds-skill/vds-scripts/confluence_orchestrator/src/confluence_orchestrator/reporting.py

@@ -1,78 +0,0 @@
-"""Run reporting utilities for the Confluence orchestrator."""
-
-from __future__ import annotations
-
-import json
-from dataclasses import dataclass
-from datetime import UTC, datetime
-from pathlib import Path
-
-TIMESTAMP_FMT = "%Y-%m-%dT%H-%M-%SZ"
-
-
-@dataclass(slots=True)
-class RunSummary:
-    command: str
-    args: list[str]
-    server: str
-    exit_code: int
-    duration_ms: int
-    started_at: datetime
-    finished_at: datetime
-
-    @property
-    def success(self) -> bool:
-        return self.exit_code == 0
-
-
-def _ensure_directory(base: Path, timestamp: datetime) -> Path:
-    day_dir = base / str(timestamp.year) / f"{timestamp.month:02d}" / f"{timestamp.day:02d}"
-    day_dir.mkdir(parents=True, exist_ok=True)
-    return day_dir
-
-
-def write_reports(
-    summary: RunSummary,
-    *,
-    base_dir: Path,
-    include_markdown: bool = True,
-) -> Path:
-    """Persist JSON (and optional Markdown) reports and return JSON path."""
-
-    timestamp = summary.finished_at.astimezone(UTC)
-    directory = _ensure_directory(base_dir, timestamp)
-    slug = f"{timestamp.strftime(TIMESTAMP_FMT)}_{summary.command}"
-
-    json_path = directory / f"{slug}.json"
-    json_payload = {
-        "command": summary.command,
-        "args": summary.args,
-        "server": summary.server,
-        "exit_code": summary.exit_code,
-        "duration_ms": summary.duration_ms,
-        "started_at": summary.started_at.astimezone(UTC).isoformat().replace("+00:00", "Z"),
-        "finished_at": summary.finished_at.astimezone(UTC).isoformat().replace("+00:00", "Z"),
-        "success": summary.success,
-    }
-    json_path.write_text(json.dumps(json_payload, indent=2, sort_keys=True))
-
-    if include_markdown:
-        md_path = directory / f"{slug}.md"
-        status = "✅ Success" if summary.success else "❌ Failure"
-        md_lines = [
-            f"# Confluence Run Report — {summary.command}",
-            "",
-            f"- **Status**: {status} (exit code {summary.exit_code})",
-            f"- **Server**: {summary.server}",
-            f"- **Duration**: {summary.duration_ms} ms",
-            f"- **Started**: {json_payload['started_at']}",
-            f"- **Finished**: {json_payload['finished_at']}",
-        ]
-        if summary.args:
-            md_lines.append(f"- **Arguments**: {' '.join(summary.args)}")
-        md_path.write_text("\n".join(md_lines) + "\n")
-
-    return json_path
-
-
-__all__ = ["RunSummary", "write_reports"]

package/skills/vds-skill/vds-scripts/confluence_orchestrator/src/confluence_orchestrator/tree.py

@@ -1,122 +0,0 @@
-"""Confluence page tree traversal and export utilities."""
-
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Any
-
-import structlog
-
-if TYPE_CHECKING:
-    from .http import ConfluenceClient
-
-
-@dataclass
-class TreeNode:
-    """Represents a Confluence page in the tree."""
-
-    page_id: str
-    title: str
-    space_key: str
-    url: str
-    children: list[TreeNode] = field(default_factory=list)
-    attachments: list[dict[str, Any]] = field(default_factory=list)
-    body: str | None = None
-
-    def to_dict(self) -> dict[str, Any]:
-        """Convert tree node to dictionary."""
-        return {
-            "id": self.page_id,
-            "title": self.title,
-            "space": self.space_key,
-            "url": self.url,
-            "body": self.body,
-            "attachments": self.attachments,
-            "children": [child.to_dict() for child in self.children],
-        }
-
-
-class TreeExporter:
-    """Recursively fetch Confluence page tree."""
-
-    def __init__(self, client: ConfluenceClient) -> None:
-        self._client = client
-        self._log = structlog.get_logger(__name__)
-
-    def build_tree(
-        self,
-        root_id: str,
-        *,
-        depth: int = -1,
-        include_content: bool = False,
-        include_attachments: bool = False,
-    ) -> TreeNode:
-        """
-        Recursively build a tree of pages.
-
-        Args:
-            root_id: The root page ID to start from.
-            depth: How deep to recurse. -1 for infinite, 0 for just root.
-            include_content: Whether to fetch page body (storage format).
-            include_attachments: Whether to fetch attachment metadata.
-        """
-        self._log.info("fetching_page", page_id=root_id)
-
-        # Prepare expand fields
-        expand = ["space"]
-        if include_content:
-            expand.append("body.storage")
-
-        # Fetch page details
-        page = self._client.get_page(root_id, expand=expand)
-        title = page.get("title", "Unknown")
-        space_key = page.get("space", {}).get("key", "Unknown")
-        links = page.get("_links", {})
-        base_url = links.get("base", "")
-        web_ui = links.get("webui", "")
-        full_url = f"{base_url}{web_ui}" if base_url and web_ui else web_ui
-
-        body = None
-        if include_content:
-            body = page.get("body", {}).get("storage", {}).get("value")
-
-        attachments = []
-        if include_attachments:
-            try:
-                # This fetches metadata, not content
-                attachments = self._client.get_attachments(root_id)
-            except Exception as e:
-                self._log.warning("failed_fetching_attachments", page_id=root_id, error=str(e))
-
-        node = TreeNode(
-            page_id=root_id,
-            title=title,
-            space_key=space_key,
-            url=full_url,
-            children=[],
-            attachments=attachments,
-            body=body,
-        )
-
-        # Recurse if depth allows
-        if depth != 0:
-            try:
-                # Fetch immediate children summaries
-                children_summaries = self._client.get_child_pages(root_id)
-
-                next_depth = depth - 1 if depth > 0 else -1
-
-                for child_summary in children_summaries:
-                    child_id = child_summary.get("id")
-                    if child_id:
-                        child_node = self.build_tree(
-                            child_id,
-                            depth=next_depth,
-                            include_content=include_content,
-                            include_attachments=include_attachments,
-                        )
-                        node.children.append(child_node)
-            except Exception as e:
-                self._log.warning("failed_fetching_children", page_id=root_id, error=str(e))
-
-        return node