@ngocsangairvds/vsaf 3.2.14 → 3.2.16

package/tools/vds-scripts/links_orchestrator/src/vds_links_orchestrator/validator.py

@@ -1,244 +0,0 @@
-"""Validation helpers for documentation links."""
-
-from __future__ import annotations
-
-import json
-import re
-from pathlib import Path
-from urllib.parse import unquote
-
-MARKDOWN_LINK_PATTERN = re.compile(r"\[([^\]]*)\]\(([^)]+)\)")
-REFERENCE_LINK_PATTERN = re.compile(r"\[([^\]]*)\]:\s*([^\s]+)")
-TARGET_STATE_LINK_PATTERN = re.compile(r"!?\[[^\]]*\]\(([^)]+)\)")
-
-ALLOWED_EXTENSIONS = {".md", ".pdf", ".puml", ".plantuml", ".png", ".svg", ".mmd"}
-
-
-def extract_links_from_file(file_path: Path) -> list[tuple[str, str, int]]:
-    """Extract markdown and reference links from a file."""
-    links: list[tuple[str, str, int]] = []
-
-    try:
-        content = file_path.read_text(encoding="utf-8")
-    except Exception:
-        content = file_path.read_text(encoding="utf-8", errors="ignore")
-
-    for line_num, line in enumerate(content.split("\n"), 1):
-        for match in re.finditer(MARKDOWN_LINK_PATTERN, line):
-            text, url = match.groups()
-            links.append((text, url, line_num))
-        for match in re.finditer(REFERENCE_LINK_PATTERN, line):
-            text, url = match.groups()
-            links.append((text, url, line_num))
-
-    return links
-
-
-def categorize_link(url: str) -> str:
-    """Categorize a link as internal, external, email, or anchor."""
-    clean_url = url.split("#")[0]
-
-    if not clean_url:
-        return "anchor"
-    if clean_url.startswith(("http://", "https://")):
-        return "external"
-    if clean_url.startswith("mailto:"):
-        return "email"
-    return "internal"
-
-
-def validate_internal_link(url: str, source_file: Path, docs_root: Path) -> dict:
-    """Validate an internal link against the docs root."""
-    clean_url = url.split("#")[0]
-    if not clean_url:
-        return {"valid": True, "type": "anchor", "message": "Anchor link"}
-
-    if clean_url.startswith("/"):
-        target_path = docs_root / clean_url.lstrip("/")
-    else:
-        target_path = source_file.parent / clean_url
-
-    try:
-        target_path = target_path.resolve()
-    except Exception as exc:  # pragma: no cover - defensive
-        return {
-            "valid": False,
-            "type": "internal",
-            "message": f"Path resolution error: {exc}",
-        }
-
-    if target_path.exists():
-        return {"valid": True, "type": "internal", "message": "File exists"}
-
-    return {
-        "valid": False,
-        "type": "internal",
-        "message": f"File not found: {target_path}",
-    }
-
-
-def validate_links_in_file(file_path: Path, docs_root: Path) -> dict:
-    """Validate links in a single file."""
-    links = extract_links_from_file(file_path)
-    results = {
-        "file": str(file_path.relative_to(docs_root)),
-        "total_links": len(links),
-        "internal_links": 0,
-        "external_links": 0,
-        "valid_internal": 0,
-        "broken_internal": 0,
-        "link_results": [],
-    }
-
-    for text, url, line_num in links:
-        link_type = categorize_link(url)
-        if link_type in {"internal", "anchor"}:
-            results["internal_links"] += 1
-            validation = validate_internal_link(url, file_path, docs_root)
-            if validation["valid"]:
-                results["valid_internal"] += 1
-            else:
-                results["broken_internal"] += 1
-        elif link_type == "external":
-            results["external_links"] += 1
-            validation = {
-                "valid": True,
-                "type": "external",
-                "message": "External link (not validated)",
-            }
-        elif link_type == "email":
-            validation = {"valid": True, "type": "email", "message": "Email link"}
-        else:
-            validation = {
-                "valid": False,
-                "type": "unknown",
-                "message": "Unknown link type",
-            }
-
-        results["link_results"].append(
-            {
-                "text": text,
-                "url": url,
-                "line": line_num,
-                "type": link_type,
-                "valid": validation["valid"],
-                "message": validation["message"],
-            }
-        )
-
-    return results
-
-
-def validate_link_integrity(docs_root: Path, max_files: int = 50) -> dict:
-    """Validate link integrity across documentation (internal links only)."""
-    if not docs_root.exists():
-        return {"error": "Documentation root not found"}
-
-    md_files = list(docs_root.rglob("*.md"))[:max_files]
-
-    all_results: list[dict] = []
-    total_links = 0
-    total_internal = 0
-    total_external = 0
-    valid_internal = 0
-    broken_internal = 0
-
-    for md_file in md_files:
-        file_results = validate_links_in_file(md_file, docs_root)
-        all_results.append(file_results)
-
-        total_links += file_results["total_links"]
-        total_internal += file_results["internal_links"]
-        total_external += file_results["external_links"]
-        valid_internal += file_results["valid_internal"]
-        broken_internal += file_results["broken_internal"]
-
-    internal_success_rate = (
-        (valid_internal / total_internal * 100.0) if total_internal > 0 else 100.0
-    )
-
-    report = {
-        "total_files": len(md_files),
-        "total_links": total_links,
-        "internal_links": total_internal,
-        "external_links": total_external,
-        "valid_internal": valid_internal,
-        "broken_internal": broken_internal,
-        "internal_success_rate": internal_success_rate,
-        "file_results": all_results,
-        "broken_internal_summary": [],
-    }
-
-    for file_result in all_results:
-        for link in file_result["link_results"]:
-            if link["type"] in {"internal", "anchor"} and not link["valid"]:
-                report["broken_internal_summary"].append(
-                    {
-                        "file": file_result["file"],
-                        "line": link["line"],
-                        "url": link["url"],
-                        "message": link["message"],
-                    }
-                )
-
-    return report
-
-
-def validate_target_state_links(root: Path) -> dict:
-    """Validate target-state documentation links."""
-    root = root.resolve()
-    md_files = sorted([p for p in root.rglob("*.md") if p.is_file()])
-    errors: list[str] = []
-
-    for file_path in md_files:
-        text = file_path.read_text(encoding="utf-8", errors="ignore")
-        for raw in TARGET_STATE_LINK_PATTERN.findall(text):
-            link = raw.strip()
-            if not link:
-                continue
-            if " " in link and not link.startswith("http"):
-                link = link.split(" ")[0]
-            link = unquote(link)
-
-            if link.startswith(("#", "http://", "https://", "mailto:")):
-                continue
-            if "://" in link:
-                continue
-            if link.startswith(("ac:", "ri:")):
-                continue
-            if "{" in link or "}" in link:
-                continue
-
-            link = link.split("#", 1)[0]
-            if not link or link.startswith("data:"):
-                continue
-            if link.endswith("/"):
-                continue
-
-            suffix = Path(link).suffix.lower()
-            if suffix and suffix not in ALLOWED_EXTENSIONS:
-                continue
-            if not suffix:
-                continue
-
-            target = (file_path.parent / link).resolve()
-            try:
-                target.relative_to(root)
-            except ValueError:
-                continue
-
-            if not target.exists():
-                errors.append(f"{file_path.relative_to(root)} -> {raw}")
-
-    return {
-        "root": str(root),
-        "files_scanned": len(md_files),
-        "error_count": len(errors),
-        "errors": errors,
-    }
-
-
-def write_report(report_path: Path, payload: dict) -> None:
-    """Write JSON report to disk."""
-    report_path.parent.mkdir(parents=True, exist_ok=True)
-    report_path.write_text(json.dumps(payload, indent=2))

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

@@ -1,128 +0,0 @@
-from __future__ import annotations
-
-import json
-from pathlib import Path
-
-from typer.testing import CliRunner
-
-from vds_links_orchestrator import cli as links_cli
-from vds_links_orchestrator.cli import app
-
-
-def _write(path: Path, content: str) -> None:
-    path.write_text(content, encoding="utf-8")
-
-
-def test_cli_target_state_success(tmp_path: Path) -> None:
-    root = tmp_path / "target-state"
-    root.mkdir()
-    _write(root / "asset.md", "# asset\n")
-    _write(root / "doc.md", "[ok](asset.md)\n")
-    runner = CliRunner()
-    result = runner.invoke(app, ["validate", "--mode", "target-state", "--root", str(root)])
-    assert result.exit_code == 0
-
-
-def test_cli_docs_report_and_failure(tmp_path: Path) -> None:
-    docs_root = tmp_path / "docs"
-    docs_root.mkdir()
-    _write(docs_root / "index.md", "[missing](missing.md)\n")
-    report = tmp_path / "report.json"
-    runner = CliRunner()
-    result = runner.invoke(
-        app,
-        [
-            "--json-only",
-            "validate",
-            "--mode",
-            "docs",
-            "--root",
-            str(docs_root),
-            "--max-files",
-            "5",
-            "--report",
-            str(report),
-        ],
-    )
-
-    assert report.exists()
-    assert json.loads(result.stdout)["broken_internal"] == 1
-    assert result.exit_code == 1
-
-
-def test_cli_help_without_command() -> None:
-    runner = CliRunner()
-    result = runner.invoke(app, [])
-
-    assert result.exit_code == 0
-    assert "Usage:" in result.stdout
-
-
-def test_cli_invalid_mode(tmp_path: Path) -> None:
-    root = tmp_path / "root"
-    root.mkdir()
-    runner = CliRunner()
-    result = runner.invoke(app, ["validate", "--mode", "unknown", "--root", str(root)])
-
-    assert result.exit_code == 2
-
-
-def test_cli_target_state_missing_root(tmp_path: Path) -> None:
-    missing_root = tmp_path / "missing-root"
-    runner = CliRunner()
-    result = runner.invoke(app, ["validate", "--mode", "target-state", "--root", str(missing_root)])
-
-    assert result.exit_code == 6
-
-
-def test_cli_target_state_reports_errors(tmp_path: Path) -> None:
-    root = tmp_path / "target-state"
-    root.mkdir()
-    _write(root / "doc.md", "[missing](missing.md)\n")
-    report = tmp_path / "target_report.json"
-    runner = CliRunner()
-    result = runner.invoke(
-        app,
-        [
-            "validate",
-            "--mode",
-            "target-state",
-            "--root",
-            str(root),
-            "--report",
-            str(report),
-        ],
-    )
-
-    assert report.exists()
-    assert result.exit_code == 1
-
-
-def test_cli_docs_output_and_failure(tmp_path: Path) -> None:
-    docs_root = tmp_path / "docs"
-    docs_root.mkdir()
-    _write(docs_root / "doc.md", "[missing](missing.md)\n")
-    runner = CliRunner()
-    result = runner.invoke(app, ["validate", "--mode", "docs", "--root", str(docs_root)])
-
-    assert result.exit_code == 1
-
-
-def test_cli_docs_missing_root(tmp_path: Path) -> None:
-    missing_root = tmp_path / "missing-docs"
-    runner = CliRunner()
-    result = runner.invoke(app, ["validate", "--mode", "docs", "--root", str(missing_root)])
-
-    assert result.exit_code == 6
-
-
-def test_default_docs_root_prefers_who_project(monkeypatch, tmp_path: Path) -> None:
-    workspace = tmp_path / "workspace"
-    docs_root = workspace / "WHO-project" / "insurance-document"
-    docs_root.mkdir(parents=True)
-    scripts_root = workspace / "WHO-project" / "vds-scripts"
-    scripts_root.mkdir(parents=True)
-
-    monkeypatch.setattr(links_cli, "_scripts_root", lambda: scripts_root)
-
-    assert links_cli._default_docs_root() == docs_root

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

@@ -1,76 +0,0 @@
-from __future__ import annotations
-
-import json
-from pathlib import Path
-
-from vds_links_orchestrator.validator import (
-    validate_link_integrity,
-    validate_target_state_links,
-    write_report,
-)
-
-
-def _write(path: Path, content: str) -> None:
-    path.write_text(content, encoding="utf-8")
-
-
-def test_validate_link_integrity_counts(tmp_path: Path) -> None:
-    docs_root = tmp_path / "docs"
-    docs_root.mkdir()
-    file_a = docs_root / "a.md"
-    file_b = docs_root / "b.md"
-
-    _write(file_a, "[b](b.md)\n[ext](https://example.com)\n")
-    _write(file_b, "[missing](missing.md)\n")
-
-    report = validate_link_integrity(docs_root, max_files=10)
-
-    assert report["total_files"] == 2
-    assert report["total_links"] == 3
-    assert report["internal_links"] == 2
-    assert report["external_links"] == 1
-    assert report["valid_internal"] == 1
-    assert report["broken_internal"] == 1
-    assert len(report["broken_internal_summary"]) == 1
-    assert report["broken_internal_summary"][0]["file"] == "b.md"
-
-
-def test_validate_target_state_links_skip_and_missing(tmp_path: Path) -> None:
-    root = tmp_path / "target-state"
-    root.mkdir()
-    asset = root / "asset.pdf"
-    _write(asset, "stub")
-
-    doc = root / "doc.md"
-    _write(
-        doc,
-        "\n".join(
-            [
-                "[ok](asset.pdf)",
-                "[missing](missing.md)",
-                "[anchor](#section)",
-                "[external](https://example.com)",
-                "[mail](mailto:test@example.com)",
-                "[badext](file.xls)",
-                "[noext](README)",
-                "[confluence](ac:link)",
-                "[data](data:image/png;base64,abc)",
-            ]
-        )
-        + "\n",
-    )
-
-    result = validate_target_state_links(root)
-
-    assert result["files_scanned"] == 1
-    assert result["error_count"] == 1
-    assert result["errors"] == ["doc.md -> missing.md"]
-
-
-def test_write_report(tmp_path: Path) -> None:
-    report_path = tmp_path / "report.json"
-    payload = {"status": "ok"}
-
-    write_report(report_path, payload)
-
-    assert json.loads(report_path.read_text(encoding="utf-8")) == payload

package/tools/vds-scripts/lsp_orchestrator/.dockerignore

@@ -1,69 +0,0 @@
-# Python cache
-__pycache__/
-*.py[cod]
-*$py.class
-*.so
-.Python
-
-# Virtual environments
-.venv/
-venv/
-ENV/
-env/
-
-# Testing
-.pytest_cache/
-.coverage
-htmlcov/
-.tox/
-.nox/
-
-# Build artifacts
-build/
-dist/
-*.egg-info/
-.eggs/
-*.egg
-
-# IDE
-.vscode/
-.idea/
-*.swp
-*.swo
-*~
-
-# OS
-.DS_Store
-Thumbs.db
-
-# Documentation
-docs/
-*.md
-!README.md
-
-# Git
-.git/
-.gitignore
-.gitattributes
-
-# CI/CD
-.github/
-.gitlab-ci.yml
-.travis.yml
-azure-pipelines.yml
-
-# Docker
-Dockerfile
-docker-compose.yml
-.dockerignore
-
-# VDS cache (will be mounted as volume)
-.vds-lsp/
-
-# Logs
-*.log
-
-# Temporary files
-.tmp/
-tmp/
-temp/