@ngocsangairvds/vsaf 3.2.14 → 3.2.15

package/tools/vds-scripts/brd_orchestrator/README.md

@@ -1,29 +0,0 @@
-# BRD Coverage Orchestrator
-
-Validates Business Requirements Document (BRD) coverage across VDS Insurance documentation.
-
-## Usage
-
-```bash
-# Default validation (writes report to scripts/brd_coverage_report.json)
-./scripts/worktree_uv.sh run --project vds_cli vds-cli brd -- validate
-
-# Custom docs root + report path
-./scripts/worktree_uv.sh run --project vds_cli vds-cli brd -- validate \
-  --root WHO-project/insurance-document \
-  --report /tmp/brd_coverage_report.json \
-  --min-coverage 100
-```
-
-## Output
-
-The report includes:
-- coverage percentage and missing sections
-- covered sections
-- file-level BRD references
-- high-priority service mappings
-
-## Notes
-
-- Default docs root prefers `VDS_INSURANCE_DOCS_ROOT`, then `WHO-project/insurance-document`, then the first `*-project/insurance-document` match.
-- Report path defaults to `WHO-project/vds-scripts/scripts/brd_coverage_report.json`.

package/tools/vds-scripts/brd_orchestrator/pyproject.toml

@@ -1,63 +0,0 @@
-[project]
-name = "vds-brd-orchestrator"
-version = "0.1.0"
-description = "VDS BRD coverage validation orchestrator"
-requires-python = ">=3.11"
-dependencies = [
-    "vds-cli-common",
-    "typer>=0.24.1",
-    "rich>=14.3.3",
-]
-
-[project.scripts]
-vds-brd = "vds_brd_orchestrator.cli:app"
-
-[build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
-
-[tool.hatch.build.targets.wheel]
-packages = ["src/vds_brd_orchestrator"]
-
-[dependency-groups]
-dev = [
-    "pytest>=9.0.2",
-    "pytest-cov>=5.0.0",
-    "ruff>=0.14.11",
-]
-[tool.uv]
-package = true
-
-[tool.uv.sources]
-vds-cli-common = { workspace = true }
-
-[tool.ruff]
-line-length = 100
-target-version = "py311"
-
-[tool.ruff.lint]
-select = [
-    "E",
-    "W",
-    "F",
-    "I",
-    "B",
-    "C4",
-    "UP",
-    "ARG",
-    "SIM",
-]
-ignore = [
-    "E501",
-    "B008",
-]
-
-[tool.ruff.lint.isort]
-known-first-party = ["vds_brd_orchestrator", "vds_cli_common"]
-
-[tool.pytest.ini_options]
-testpaths = ["tests"]
-python_files = ["test_*.py"]
-python_functions = ["test_*"]
-addopts = "-v --tb=short"
-pythonpath = ["src"]

package/tools/vds-scripts/brd_orchestrator/src/vds_brd_orchestrator/__init__.py

@@ -1,17 +0,0 @@
-"""VDS BRD Orchestrator - BRD coverage validation for VDS."""
-
-from vds_brd_orchestrator.validator import (
-    HIGH_PRIORITY_SERVICES,
-    REQUIRED_BRD_SECTIONS,
-    validate_brd_coverage,
-    write_report,
-)
-
-__all__ = [
-    "HIGH_PRIORITY_SERVICES",
-    "REQUIRED_BRD_SECTIONS",
-    "validate_brd_coverage",
-    "write_report",
-]
-
-__version__ = "0.1.0"

package/tools/vds-scripts/brd_orchestrator/src/vds_brd_orchestrator/cli.py

@@ -1,187 +0,0 @@
-"""CLI for BRD coverage validation using Typer."""
-
-from __future__ import annotations
-
-import os
-from pathlib import Path
-from typing import Annotated
-
-import typer
-
-from vds_brd_orchestrator.validator import validate_brd_coverage, write_report
-from vds_cli_common import (
-    CLIContext,
-    ErrorHandler,
-    ExitCodes,
-    OutputManager,
-    create_version_callback,
-)
-
-APP_NAME = "vds-brd-orchestrator"
-VALID_COMMANDS = ["validate"]
-
-app = typer.Typer(
-    name="vds-brd",
-    help="BRD coverage validation for VDS documentation",
-    rich_markup_mode="rich",
-    invoke_without_command=True,
-    no_args_is_help=False,
-)
-
-version_callback = create_version_callback(APP_NAME)
-
-
-def _scripts_root() -> Path:
-    """Return the vds-scripts root directory."""
-    return Path(__file__).resolve().parents[3]
-
-
-def _default_docs_root() -> Path:
-    """Return default documentation root."""
-    override = os.environ.get("VDS_INSURANCE_DOCS_ROOT")
-    if override:
-        return Path(override).expanduser()
-
-    root = _scripts_root().parents[1]
-    preferred = root / "WHO-project" / "insurance-document"
-    if preferred.exists():
-        return preferred
-
-    matches = sorted(root.glob("*-project/insurance-document"))
-    if matches:
-        return matches[0]
-
-    return preferred
-
-
-def _default_report_path() -> Path:
-    """Return default BRD coverage report path."""
-    return _scripts_root() / "scripts" / "brd_coverage_report.json"
-
-
-def _get_state(ctx: typer.Context) -> tuple[CLIContext, OutputManager, ErrorHandler]:
-    if not isinstance(ctx.obj, dict):
-        cli_ctx = CLIContext()
-        output = OutputManager(cli_ctx)
-        error_handler = ErrorHandler(output, valid_commands=VALID_COMMANDS)
-        return cli_ctx, output, error_handler
-    return ctx.obj["cli_ctx"], ctx.obj["output"], ctx.obj["error_handler"]
-
-
-@app.callback(invoke_without_command=True)
-def callback(
-    ctx: typer.Context,
-    _version: Annotated[
-        bool,
-        typer.Option(
-            "--version",
-            "-V",
-            callback=version_callback,
-            is_eager=True,
-            help="Show version and exit",
-        ),
-    ] = False,
-    json_only: Annotated[
-        bool,
-        typer.Option(
-            "--json-only",
-            "-j",
-            help="Output clean JSON only",
-        ),
-    ] = False,
-    quiet: Annotated[
-        bool,
-        typer.Option(
-            "--quiet",
-            "-q",
-            help="Suppress non-essential output",
-        ),
-    ] = False,
-) -> None:
-    cli_ctx = CLIContext.from_options(json_only=json_only, quiet=quiet)
-    output = OutputManager(cli_ctx)
-    error_handler = ErrorHandler(output, valid_commands=VALID_COMMANDS)
-    ctx.obj = {"cli_ctx": cli_ctx, "output": output, "error_handler": error_handler}
-
-    if ctx.invoked_subcommand is None:
-        output.ctx.console.print(ctx.get_help())
-        raise typer.Exit(ExitCodes.SUCCESS)
-
-
-@app.command()
-def validate(
-    ctx: typer.Context,
-    root: Annotated[
-        Path | None,
-        typer.Option(
-            "--root",
-            "-r",
-            help="Documentation root to scan",
-        ),
-    ] = None,
-    report: Annotated[
-        Path | None,
-        typer.Option(
-            "--report",
-            help="Write JSON report to file",
-        ),
-    ] = None,
-    min_coverage: Annotated[
-        float,
-        typer.Option(
-            "--min-coverage",
-            help="Minimum required coverage percentage (default 100)",
-        ),
-    ] = 100.0,
-) -> None:
-    """Validate BRD coverage across documentation.
-
-    \b
-    Examples:
-        vds-brd validate
-        vds-brd validate --root path/to/docs --report brd_coverage_report.json
-    """
-    cli_ctx, output, _error_handler = _get_state(ctx)
-
-    docs_root = (root or _default_docs_root()).resolve()
-    if not docs_root.exists():
-        output.output_error(
-            "Documentation root does not exist",
-            hint=f"Check --root path: {docs_root}",
-        )
-        raise typer.Exit(ExitCodes.NOT_FOUND_ERROR)
-
-    report_data = validate_brd_coverage(docs_root)
-    if "error" in report_data:
-        output.output_error(report_data["error"])
-        raise typer.Exit(ExitCodes.GENERAL_ERROR)
-
-    report_path = (report or _default_report_path()).resolve()
-    try:
-        write_report(report_path, report_data)
-    except Exception as exc:  # pragma: no cover - defensive
-        output.output_error(
-            "Failed to write report",
-            details={"path": str(report_path), "error": str(exc)},
-        )
-        raise typer.Exit(ExitCodes.GENERAL_ERROR) from exc
-
-    if cli_ctx.json_only:
-        output.output_json(report_data)
-    elif not cli_ctx.quiet:
-        output.ctx.console.print("BRD Coverage Validation")
-        output.ctx.console.print(f"Docs root: {docs_root}")
-        output.ctx.console.print(f"Coverage: {report_data['coverage_percentage']:.1f}%")
-        output.ctx.console.print(f"Covered sections: {report_data['total_covered']}")
-        output.ctx.console.print(f"Missing sections: {len(report_data['missing_sections'])}")
-        output.ctx.console.print(f"Report: {report_path}")
-
-    if report_data["coverage_percentage"] < min_coverage:
-        output.output_error(
-            "BRD coverage below required threshold",
-            details={
-                "coverage": report_data["coverage_percentage"],
-                "minimum": min_coverage,
-            },
-        )
-        raise typer.Exit(ExitCodes.VALIDATION_ERROR)

package/tools/vds-scripts/brd_orchestrator/src/vds_brd_orchestrator/validator.py

@@ -1,121 +0,0 @@
-"""BRD coverage validation logic."""
-
-from __future__ import annotations
-
-import json
-import re
-from datetime import datetime
-from pathlib import Path
-
-REQUIRED_BRD_SECTIONS = [
-    "3.1",
-    "3.2",
-    "3.3",
-    "3.4",
-    "3.5",
-    "4.1",
-    "4.2",
-    "4.3",
-    "4.4",
-    "4.5",
-    "4.6",
-    "4.7",
-    "4.8",
-    "4.9",
-    "4.10",
-    "4.11",
-]
-
-HIGH_PRIORITY_SERVICES = {
-    "insurance-policy-business": ["3.4", "4.5"],
-    "insurance-proposal-business": ["3.3.5", "3.3.6", "3.3.7", "3.3.8"],
-    "insurance-claim-business": ["3.5", "4.6"],
-    "insurance-customer-business": ["3.1", "3.2", "4.4"],
-    "insurance-product-catalog": ["4.3", "4.3.1"],
-    "insurance-rating-engine": ["3.3.5", "4.3.3"],
-    "insurance-renewal-process": ["3.4.2", "3.4.3", "3.4.4"],
-}
-
-BRD_PATTERN = re.compile(r"BRD.*?([34]\.\d+(?:\.\d+)*)", re.IGNORECASE)
-
-
-def find_brd_references_in_file(file_path: Path) -> set[str]:
-    """Find BRD section references in a file."""
-    try:
-        content = file_path.read_text(encoding="utf-8")
-    except Exception:
-        content = file_path.read_text(encoding="utf-8", errors="ignore")
-
-    return set(BRD_PATTERN.findall(content))
-
-
-def scan_documentation_for_brd_refs(docs_root: Path) -> dict[str, set[str]]:
-    """Scan markdown files for BRD references."""
-    coverage: dict[str, set[str]] = {}
-
-    for md_file in docs_root.rglob("*.md"):
-        if not md_file.is_file():
-            continue
-        refs = find_brd_references_in_file(md_file)
-        if refs:
-            coverage[str(md_file.relative_to(docs_root))] = refs
-
-    return coverage
-
-
-def _covered_sections(found_sections: set[str], required_sections: list[str]) -> set[str]:
-    covered: set[str] = set()
-    for found in found_sections:
-        for required in required_sections:
-            if found.startswith(required):
-                covered.add(required)
-    return covered
-
-
-def _coverage_status(coverage: float) -> str:
-    if coverage >= 100.0:
-        return "EXCELLENT"
-    if coverage >= 80.0:
-        return "GOOD"
-    return "POOR"
-
-
-def validate_brd_coverage(
-    docs_root: Path,
-    required_sections: list[str] | None = None,
-) -> dict[str, object]:
-    """Validate BRD coverage completeness."""
-    if not docs_root.exists():
-        return {"error": f"Documentation root not found: {docs_root}"}
-
-    required = required_sections or list(REQUIRED_BRD_SECTIONS)
-    brd_coverage = scan_documentation_for_brd_refs(docs_root)
-
-    found_sections: set[str] = set()
-    for file_refs in brd_coverage.values():
-        found_sections.update(file_refs)
-
-    covered_sections = _covered_sections(found_sections, required)
-    missing_sections = set(required) - covered_sections
-
-    total_required = len(required)
-    total_covered = len(covered_sections)
-    coverage_percentage = (total_covered / total_required * 100.0) if total_required else 100.0
-
-    return {
-        "total_required": total_required,
-        "total_covered": total_covered,
-        "coverage_percentage": coverage_percentage,
-        "covered_sections": sorted(covered_sections),
-        "missing_sections": sorted(missing_sections),
-        "found_references": {path: sorted(refs) for path, refs in brd_coverage.items()},
-        "high_priority_services": HIGH_PRIORITY_SERVICES,
-        "validation_timestamp": datetime.now().isoformat(),
-        "status": _coverage_status(coverage_percentage),
-    }
-
-
-def write_report(report_path: Path, report: dict[str, object]) -> None:
-    """Write JSON report to disk."""
-    report_path.parent.mkdir(parents=True, exist_ok=True)
-    report_path.write_text(json.dumps(report, indent=2), encoding="utf-8")

package/tools/vds-scripts/brd_orchestrator/tests/test_cli.py

@@ -1,62 +0,0 @@
-from __future__ import annotations
-
-from pathlib import Path
-
-from typer.testing import CliRunner
-
-from vds_brd_orchestrator.cli import app
-from vds_brd_orchestrator.validator import REQUIRED_BRD_SECTIONS
-from vds_cli_common import ExitCodes
-
-
-def _write(path: Path, content: str) -> None:
-    path.write_text(content, encoding="utf-8")
-
-
-def test_cli_failure_on_missing_sections(tmp_path: Path) -> None:
-    docs_root = tmp_path / "docs"
-    docs_root.mkdir()
-    _write(docs_root / "doc.md", "BRD 3.1\n")
-    report = tmp_path / "report.json"
-
-    runner = CliRunner()
-    result = runner.invoke(
-        app,
-        [
-            "validate",
-            "--root",
-            str(docs_root),
-            "--report",
-            str(report),
-            "--min-coverage",
-            "100",
-        ],
-    )
-
-    assert report.exists()
-    assert result.exit_code == ExitCodes.VALIDATION_ERROR
-
-
-def test_cli_success(tmp_path: Path) -> None:
-    docs_root = tmp_path / "docs"
-    docs_root.mkdir()
-    content = "\n".join(f"BRD {section}" for section in REQUIRED_BRD_SECTIONS)
-    _write(docs_root / "doc.md", content)
-    report = tmp_path / "report.json"
-
-    runner = CliRunner()
-    result = runner.invoke(
-        app,
-        ["--json-only", "validate", "--root", str(docs_root), "--report", str(report)],
-    )
-
-    assert report.exists()
-    assert result.exit_code == ExitCodes.SUCCESS
-
-
-def test_cli_help() -> None:
-    runner = CliRunner()
-    result = runner.invoke(app, [])
-
-    assert result.exit_code == ExitCodes.SUCCESS
-    assert "Usage" in result.stdout

package/tools/vds-scripts/brd_orchestrator/tests/test_validator.py

@@ -1,33 +0,0 @@
-from __future__ import annotations
-
-from pathlib import Path
-
-from vds_brd_orchestrator.validator import REQUIRED_BRD_SECTIONS, validate_brd_coverage
-
-
-def _write(path: Path, content: str) -> None:
-    path.write_text(content, encoding="utf-8")
-
-
-def test_validate_brd_coverage_missing_sections(tmp_path: Path) -> None:
-    docs_root = tmp_path / "docs"
-    docs_root.mkdir()
-    _write(docs_root / "doc.md", "BRD 3.1\n")
-
-    report = validate_brd_coverage(docs_root)
-    assert report["total_required"] == len(REQUIRED_BRD_SECTIONS)
-    assert report["total_covered"] == 1
-    assert "3.1" in report["covered_sections"]
-    assert "3.2" in report["missing_sections"]
-
-
-def test_validate_brd_coverage_all_sections(tmp_path: Path) -> None:
-    docs_root = tmp_path / "docs"
-    docs_root.mkdir()
-
-    content = "\n".join(f"BRD {section}" for section in REQUIRED_BRD_SECTIONS)
-    _write(docs_root / "doc.md", content)
-
-    report = validate_brd_coverage(docs_root)
-    assert report["total_covered"] == len(REQUIRED_BRD_SECTIONS)
-    assert report["missing_sections"] == []

package/tools/vds-scripts/circular_dependency_orchestrator/README.md

@@ -1,30 +0,0 @@
-# VDS Circular Dependency Orchestrator
-
-Routed CLI package for manifest-first circular dependency analysis across multi-repository VDS projects.
-
-Current status:
-- exposes working `analyze` and `report` commands;
-- discovers Maven `pom.xml` and standalone `package.json` manifests;
-- normalizes internal and external dependency edges at repository and artifact scope;
-- emits JSON-first output with cycle paths, evidence refs, summary metrics, and deterministic `exit_code` values;
-- supports preset-aware selection for `PAR` and `INSURANCE` style scans;
-- is compatible with future promotion into broader project-topology or audit workflows.
-
-Current limits:
-- manifest-first only; no runtime/service-call loop analysis;
-- frontend support is standalone `package.json`-level, not full workspace graph analysis;
-- worktree `.venv` importability may depend on local editable-install `.pth` flags in this environment.
-
-Example commands:
-
-```bash
-./scripts/worktree_uv.sh run --project vds_cli vds-cli circular-dependency --json-only analyze --project-root /path/to/project --scope full-project
-./scripts/worktree_uv.sh run --project vds_cli vds-cli circular-dependency --json-only analyze --project-root /path/to/PAR-project --scope full-project --preset PAR
-./scripts/worktree_uv.sh run --project vds_cli vds-cli circular-dependency report --input result.json
-```
-
-Deterministic exit codes:
-- `0`: no cycle detected
-- `1`: command/runtime error
-- `2`: confirmed cycle detected
-- `3`: evidence gap or partial analysis

package/tools/vds-scripts/circular_dependency_orchestrator/pyproject.toml

@@ -1,43 +0,0 @@
-[project]
-name = "vds-circular-dependency-orchestrator"
-version = "0.1.0"
-description = "Baseline CLI surface for circular dependency analysis across multi-repository VDS projects"
-readme = "README.md"
-requires-python = ">=3.14"
-dependencies = [
-    "typer>=0.24.1",
-    "rich>=14.3.3",
-    "structlog>=25.5.0",
-]
-
-[project.scripts]
-vds-circular-dependency = "vds_circular_dependency_orchestrator.cli:app"
-
-[build-system]
-requires = ["hatchling>=1.20.0"]
-build-backend = "hatchling.build"
-
-[tool.hatch.build.targets.wheel]
-packages = ["src/vds_circular_dependency_orchestrator"]
-
-[tool.hatch.build.targets.sdist]
-include = ["src/vds_circular_dependency_orchestrator", "pyproject.toml", "README.md"]
-
-[dependency-groups]
-dev = [
-    "pytest>=9.0.2",
-    "ruff>=0.15.1",
-]
-
-[tool.ruff]
-line-length = 120
-target-version = "py311"
-
-[tool.ruff.lint]
-select = ["E", "F", "I", "W", "B", "C4", "UP"]
-ignore = ["E501", "B008"]
-
-[tool.ruff.format]
-quote-style = "double"
-indent-style = "space"
-line-ending = "auto"

package/tools/vds-scripts/circular_dependency_orchestrator/src/vds_circular_dependency_orchestrator/__init__.py

@@ -1,16 +0,0 @@
-"""VDS circular dependency orchestrator."""
-
-from __future__ import annotations
-
-__version__ = "0.1.0"
-
-
-def __getattr__(name: str) -> object:
-    if name == "app":
-        from vds_circular_dependency_orchestrator.cli import app
-
-        return app
-    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
-
-
-__all__ = ["__version__", "app"]