@danmoisan/drm-copilot-mcp 0.0.5 → 1.0.0

package/resources/scripts/dev_tools/validate_policy_audit_artifact.py

@@ -1,448 +0,0 @@
-"""Validate policy-audit orchestration review artifacts.
-
-Purpose:
-    Hold the policy-audit specific parsing helpers and substantive validation
-    checks so the review-artifact validator stays cohesive and below the
-    repository file-size limit.
-
-Usage:
-    Import ``validate_policy_audit_text`` from this module when a caller needs
-    only policy-audit validation, or through
-    ``scripts.dev_tools.validate_orchestration_artifacts`` for the stable CLI
-    entrypoint contract.
-
-Flow:
-    1. Parse the coverage table, checklist lines, and per-language comparison
-       bullets from the policy-audit document.
-    2. Reject placeholder, malformed, or non-numeric coverage evidence when the
-       repository policy requires explicit percentages.
-    3. Return a list of contract violations for the caller to surface.
-
-Invariants / Constraints:
-    - Placeholder markers are treated as failures.
-    - Coverage rows must retain numeric evidence unless the field is marked N/A.
-    - The public validator functions return lists of error strings and do not
-      print or mutate files.
-
-Side Effects:
-    None.
-"""
-
-from __future__ import annotations
-
-import re
-
-COVERAGE_PERCENT_RE = re.compile(r"\b\d+(?:\.\d+)?%")
-POLICY_AUDIT_REQUIRED_HEADINGS = (
-    "## Executive Summary",
-    "## 1. General Unit Test Policy Compliance",
-    "## 2. General Code Change Policy Compliance",
-    "## 3. Language-Specific Code Change Policy Compliance",
-    "## 4. Language-Specific Unit Test Policy Compliance",
-    "## 5. Test Coverage Detail",
-    "## 6. Test Execution Metrics",
-    "## 7. Code Quality Checks",
-    "## 8. Gaps and Exceptions",
-    "## 9. Summary of Changes",
-    "## 10. Compliance Verdict",
-    "## Appendix A: Test Inventory",
-    "## Appendix B: Toolchain Commands Reference",
-)
-POLICY_AUDIT_REQUIRED_CHECKLIST_LABELS = (
-    "TypeScript baseline coverage artifact:",
-    "TypeScript post-change coverage artifact:",
-    "PowerShell baseline coverage artifact:",
-    "PowerShell post-change coverage artifact:",
-    "Per-language comparison summary:",
-)
-POLICY_AUDIT_COMPARISON_HEADING = "### 1.2.1 Per-Language Coverage Comparison"
-PLACEHOLDER_MARKERS = (
-    "[n]",
-    "[path",
-    "[artifact",
-    "[section reference",
-    "[language]",
-    "tbd",
-    "unverified",
-    "missing",
-)
-
-
-def _has_numeric_coverage(value: str) -> bool:
-    """Return True when a coverage field contains a numeric percentage.
-
-    Purpose:
-        Identify whether a coverage field satisfies the policy requirement for
-        explicit numeric evidence.
-
-    Args:
-        value (str): Raw coverage field text extracted from an audit artifact.
-
-    Returns:
-        bool: True when the value contains at least one percentage token.
-
-    Raises:
-        None.
-
-    Side Effects:
-        None.
-    """
-
-    return COVERAGE_PERCENT_RE.search(value) is not None
-
-
-def _is_na_value(value: str) -> bool:
-    """Return True when an audit field explicitly records not-applicable.
-
-    Purpose:
-        Allow the validator to distinguish missing numeric evidence from fields
-        that are intentionally marked not applicable.
-
-    Args:
-        value (str): Raw field text to inspect.
-
-    Returns:
-        bool: True when the value begins with an N/A marker.
-
-    Raises:
-        None.
-
-    Side Effects:
-        None.
-    """
-
-    return value.strip().lower().startswith("n/a")
-
-
-def _has_placeholder_marker(value: str) -> bool:
-    """Return True when a field still contains template placeholder text.
-
-    Purpose:
-        Fail closed when a review artifact still includes unfinished template or
-        draft markers.
-
-    Args:
-        value (str): Raw field text to inspect.
-
-    Returns:
-        bool: True when the field includes a known placeholder marker.
-
-    Raises:
-        None.
-
-    Side Effects:
-        None.
-    """
-
-    lowered = value.lower()
-    return any(marker in lowered for marker in PLACEHOLDER_MARKERS)
-
-
-def _extract_policy_audit_coverage_rows(text: str) -> list[dict[str, str]]:
-    """Parse the policy-audit coverage table into named row dictionaries.
-
-    Purpose:
-        Normalize coverage table rows so later validation checks can reason
-        about baseline, post-change, and new-code evidence by language.
-
-    Args:
-        text (str): Full policy-audit artifact text.
-
-    Returns:
-        list[dict[str, str]]: Parsed coverage rows keyed by canonical column
-        names.
-
-    Raises:
-        None.
-
-    Side Effects:
-        None.
-    """
-
-    rows: list[dict[str, str]] = []
-
-    # Interpret only the seven-column coverage table rows and ignore headers or
-    # separator rows.
-    for line in text.splitlines():
-        if not line.startswith("|"):
-            continue
-        cells = [cell.strip() for cell in line.split("|")[1:-1]]
-        if len(cells) != 7:
-            continue
-        language = cells[0]
-        if language in {"Language", "----------"} or not language:
-            continue
-        if set(language) == {"-"}:
-            continue
-        rows.append(
-            {
-                "Language": language,
-                "Files Changed": cells[1],
-                "Tests": cells[2],
-                "Test Result": cells[3],
-                "Baseline Coverage": cells[4],
-                "Post-Change Coverage": cells[5],
-                "New Code Coverage": cells[6],
-            }
-        )
-
-    return rows
-
-
-def _find_policy_audit_checklist_line(text: str, label: str) -> str | None:
-    """Return the checklist line containing a required label.
-
-    Purpose:
-        Locate required evidence checklist entries without assuming a fixed line
-        number or surrounding context.
-
-    Args:
-        text (str): Full policy-audit artifact text.
-        label (str): Required checklist label to locate.
-
-    Returns:
-        str | None: The matching checklist line, if present.
-
-    Raises:
-        None.
-
-    Side Effects:
-        None.
-    """
-
-    # Search only checklist bullets because the same label text may appear in
-    # narrative prose elsewhere in the document.
-    for line in text.splitlines():
-        stripped = line.strip()
-        if stripped.startswith("- ") and label in stripped:
-            return stripped
-    return None
-
-
-def _extract_policy_audit_comparison_lines(text: str) -> dict[str, str]:
-    """Return per-language comparison lines keyed by normalized language name.
-
-    Purpose:
-        Capture the explicit comparison bullets under the per-language coverage
-        section so downstream checks can verify each language summary is present.
-
-    Args:
-        text (str): Full policy-audit artifact text.
-
-    Returns:
-        dict[str, str]: Mapping of lowercase language name to the matching
-        comparison bullet.
-
-    Raises:
-        None.
-
-    Side Effects:
-        None.
-    """
-
-    in_section = False
-    comparison_lines: dict[str, str] = {}
-
-    # Limit parsing to the per-language coverage section so unrelated bullets do
-    # not satisfy the evidence checks accidentally.
-    for line in text.splitlines():
-        stripped = line.strip()
-        if stripped == POLICY_AUDIT_COMPARISON_HEADING:
-            in_section = True
-            continue
-        if in_section and stripped.startswith("### "):
-            break
-        if not in_section or not stripped.startswith("- "):
-            continue
-        language, separator, _ = stripped[2:].partition(":")
-        if not separator:
-            continue
-        comparison_lines[language.strip().lower()] = stripped
-
-    return comparison_lines
-
-
-def _comparison_line_has_labelled_percentage(line: str, label: str) -> bool:
-    """Return True when the comparison line includes a labelled percentage.
-
-    Purpose:
-        Verify that each comparison bullet records numeric evidence after the
-        expected label, rather than narrative text alone.
-
-    Args:
-        line (str): Comparison bullet text.
-        label (str): Required label to anchor the percentage search.
-
-    Returns:
-        bool: True when the labelled numeric evidence is present.
-
-    Raises:
-        None.
-
-    Side Effects:
-        None.
-    """
-
-    pattern = re.compile(rf"{re.escape(label)}.*?\d+(?:\.\d+)?%")
-    return pattern.search(line) is not None
-
-
-def validate_policy_audit_substantive_requirements(text: str) -> list[str]:
-    """Validate policy-audit evidence requirements beyond headings.
-
-    Purpose:
-        Enforce the numeric coverage and evidence checklist requirements that
-        turn the review template into an auditable artifact.
-
-    Args:
-        text (str): Full policy-audit artifact text.
-
-    Returns:
-        list[str]: Validation errors describing each missing or malformed
-        evidence element.
-
-    Raises:
-        None.
-
-    Side Effects:
-        None.
-    """
-
-    errors: list[str] = []
-
-    # Require every checklist line to exist and remain free of unresolved
-    # placeholders before the audit can report a passing verdict.
-    for label in POLICY_AUDIT_REQUIRED_CHECKLIST_LABELS:
-        line = _find_policy_audit_checklist_line(text, label)
-        if line is None:
-            errors.append(f"Policy audit missing required checklist line: {label}")
-            continue
-        if _has_placeholder_marker(line):
-            errors.append(
-                f"Policy audit checklist line still contains placeholder text: {label}"
-            )
-
-    coverage_rows = _extract_policy_audit_coverage_rows(text)
-    if not coverage_rows:
-        errors.append("Policy audit missing coverage metrics table rows.")
-
-    if POLICY_AUDIT_COMPARISON_HEADING not in text:
-        errors.append(
-            "Policy audit missing required heading: "
-            f"{POLICY_AUDIT_COMPARISON_HEADING}"
-        )
-
-    comparison_lines = _extract_policy_audit_comparison_lines(text)
-
-    # Validate each language row against the comparison summary so baseline,
-    # post-change, and changed-code evidence remain synchronized.
-    for row in coverage_rows:
-        language = row["Language"]
-        baseline = row["Baseline Coverage"]
-        post_change = row["Post-Change Coverage"]
-        new_code = row["New Code Coverage"]
-        requires_coverage_comparison = any(
-            not _is_na_value(value) for value in (baseline, post_change, new_code)
-        )
-
-        if not _is_na_value(baseline) and not _has_numeric_coverage(baseline):
-            errors.append(
-                f"Policy audit missing numeric baseline coverage for {language}."
-            )
-        if not _is_na_value(post_change) and not _has_numeric_coverage(post_change):
-            errors.append(
-                f"Policy audit missing numeric post-change coverage for {language}."
-            )
-        if not _is_na_value(new_code) and not _has_numeric_coverage(new_code):
-            errors.append(
-                "Policy audit missing numeric new/changed-code coverage for "
-                f"{language}."
-            )
-
-        if not requires_coverage_comparison:
-            continue
-
-        comparison_line = comparison_lines.get(language.lower())
-        if comparison_line is None:
-            errors.append(
-                f"Policy audit missing per-language comparison line for {language}."
-            )
-            continue
-
-        if not _comparison_line_has_labelled_percentage(comparison_line, "Baseline:"):
-            errors.append(
-                f"Policy audit comparison line missing numeric baseline for {language}."
-            )
-        if not _comparison_line_has_labelled_percentage(
-            comparison_line, "Post-change:"
-        ):
-            errors.append(
-                "Policy audit comparison line missing numeric post-change "
-                f"coverage for {language}."
-            )
-        if "Change:" not in comparison_line:
-            errors.append(
-                "Policy audit comparison line missing explicit change text for "
-                f"{language}."
-            )
-        if (
-            re.search(
-                r"Disposition:\s*(PASS|FAIL|N/A|INCOMPLETE|BLOCKED)",
-                comparison_line,
-            )
-            is None
-        ):
-            errors.append(
-                f"Policy audit comparison line missing disposition for {language}."
-            )
-        if not _is_na_value(new_code) and not _comparison_line_has_labelled_percentage(
-            comparison_line, "New/changed-code coverage:"
-        ):
-            errors.append(
-                "Policy audit comparison line missing numeric new/changed-code "
-                f"coverage for {language}."
-            )
-        if "Evidence:" not in comparison_line:
-            errors.append(
-                "Policy audit comparison line missing evidence reference for "
-                f"{language}."
-            )
-        elif _has_placeholder_marker(comparison_line):
-            errors.append(
-                "Policy audit comparison line still contains placeholder text for "
-                f"{language}."
-            )
-
-    return errors
-
-
-def validate_policy_audit_text(text: str) -> list[str]:
-    """Validate template-derived policy-audit structure.
-
-    Purpose:
-        Enforce the required policy-audit headings and substantive evidence
-        checks for repository review artifacts.
-
-    Args:
-        text (str): Full policy-audit artifact text.
-
-    Returns:
-        list[str]: Validation errors for missing headings or evidence.
-
-    Raises:
-        None.
-
-    Side Effects:
-        None.
-    """
-
-    errors: list[str] = []
-    if "Template Usage Instructions" in text:
-        errors.append("Policy audit still contains the template instruction block.")
-    if "[Component Name]" in text:
-        errors.append("Policy audit still contains placeholder component text.")
-    for heading in POLICY_AUDIT_REQUIRED_HEADINGS:
-        if heading not in text:
-            errors.append(f"Policy audit missing required heading: {heading}")
-    errors.extend(validate_policy_audit_substantive_requirements(text))
-    return errors

package/resources/templates/codex_native_converter.py

@@ -1,35 +0,0 @@
-"""Compatibility wrapper for the bundled Codex-native converter.
-
-Purpose:
-    Preserve an extension-side Python entry point that delegates converter
-    execution to the bundled ``dev_tools`` package published with the extension
-    resources.
-"""
-
-from __future__ import annotations
-
-import importlib
-import sys
-from pathlib import Path
-
-
-def _ensure_bundled_scripts_import_path() -> None:
-    """Prepend bundled `resources/scripts` directory to ``sys.path``."""
-
-    scripts_dir = Path(__file__).resolve().parent.parent / "scripts"
-    scripts_dir_str = str(scripts_dir)
-    if scripts_dir_str not in sys.path:
-        sys.path.insert(0, scripts_dir_str)
-
-
-def main() -> int:
-    """Execute the bundled Codex-native converter in-process."""
-
-    _ensure_bundled_scripts_import_path()
-    module = importlib.import_module("dev_tools.codex_native_converter.cli")
-    module.main()
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())

package/resources/templates/collect_commit_context.py

@@ -1,212 +0,0 @@
-"""Collect Git commit context for commit message generation.
-
-This script gathers staged changes and repository state information
-to provide context for generating conventional commit messages.
-"""
-
-from __future__ import annotations
-
-import argparse
-import shutil
-import subprocess
-import sys
-from pathlib import Path
-
-
-def run_git(args: list[str], allow_error: bool = False) -> str:
-    """Run a git command and return stdout.
-
-    Args:
-        args: Git subcommand and arguments (e.g., ["status", "-sb"])
-        allow_error: If True, return empty output on error instead of raising
-
-    Returns:
-        Git command stdout as string, stripped of whitespace
-
-    Raises:
-        FileNotFoundError: If git executable not found on PATH
-        subprocess.CalledProcessError: If git command fails and allow_error is False
-    """
-    # Validate git executable exists
-    git_exe = shutil.which("git")
-    if not git_exe:
-        raise FileNotFoundError("git executable not found on PATH")
-
-    try:
-        result = subprocess.run(  # noqa: S603 - static analysis can't verify runtime validation
-            [git_exe, *args],
-            capture_output=True,
-            text=True,
-            encoding="utf-8",
-            errors="replace",
-            check=not allow_error,
-        )
-        stdout = result.stdout or ""
-        return stdout.strip()
-    except subprocess.CalledProcessError as e:
-        if allow_error:
-            stdout = e.stdout or ""
-            return stdout.strip()
-        raise
-
-
-def collect_commit_context(output_path: Path) -> None:
-    """Collect commit context and write to output file."""
-    sections: list[str] = []
-
-    sections.append("Please generate a commit message based on the following content:")
-    sections.append("\n")
-
-    # Repository remotes
-    sections.append("===== Repository remotes =====")
-    sections.append("")
-    remotes = run_git(["remote", "-v"])
-    sections.append(remotes)
-    sections.append("")
-
-    # Current branch
-    sections.append("===== Current branch =====")
-    sections.append("")
-    branch = run_git(["rev-parse", "--abbrev-ref", "HEAD"])
-    sections.append(branch)
-    sections.append("")
-
-    # Upstream
-    sections.append("===== Upstream =====")
-    sections.append("")
-    upstream = run_git(
-        ["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{u}"], allow_error=True
-    )
-    sections.append(upstream if upstream else "(no upstream)")
-    sections.append("")
-
-    # Status (short)
-    sections.append("===== Status (short) =====")
-    sections.append("")
-    status = run_git(["status", "-sb"])
-    sections.append(status)
-    sections.append("")
-
-    # Staged files (name-status)
-    sections.append("===== Staged files (name-status) =====")
-    sections.append("")
-    staged = run_git(["diff", "--cached", "--name-status"], allow_error=True)
-    sections.append(staged if staged else "(no staged changes)")
-    sections.append("")
-
-    # Staged diff
-    sections.append("===== Staged diff =====")
-    sections.append("")
-    staged_diff = run_git(["diff", "--cached"], allow_error=True)
-    sections.append(staged_diff if staged_diff else "(no staged changes)")
-    sections.append("")
-
-    # Unstaged files (name-status)
-    sections.append("===== Unstaged files (name-status) =====")
-    sections.append("")
-    unstaged = run_git(["diff", "--name-status"], allow_error=True)
-    sections.append(unstaged if unstaged else "(no unstaged changes)")
-    sections.append("")
-
-    # Unstaged diff
-    sections.append("===== Unstaged diff =====")
-    sections.append("")
-    unstaged_diff = run_git(["diff"], allow_error=True)
-    sections.append(unstaged_diff if unstaged_diff else "(no unstaged changes)")
-    sections.append("")
-
-    # Untracked files
-    sections.append("===== Untracked files =====")
-    sections.append("")
-    untracked = run_git(
-        ["ls-files", "--others", "--exclude-standard"], allow_error=True
-    )
-    sections.append(untracked if untracked else "(no untracked files)")
-    sections.append("")
-
-    # Diff stat (combined)
-    sections.append("===== Diff stat (staged + unstaged) =====")
-    sections.append("")
-    diff_stat = run_git(["diff", "HEAD", "--stat"], allow_error=True)
-    sections.append(diff_stat if diff_stat else "(no changes)")
-    sections.append("")
-
-    # Changed Python files
-    sections.append("===== Changed Python files =====")
-    sections.append("")
-    all_changed = run_git(["diff", "HEAD", "--name-only"], allow_error=True)
-    py_files = (
-        [f for f in all_changed.split("\n") if f.endswith(".py")] if all_changed else []
-    )
-    sections.append("\n".join(py_files) if py_files else "(no Python files changed)")
-    sections.append("")
-
-    # Last commit (header only)
-    sections.append("===== Last commit (header only) =====")
-    sections.append("")
-    last_commit = run_git(
-        ["log", "-1", "--format=%H%n%aN <%aE>%n%aD%n%cN <%cE>%n%cD%n%s%n%b"],
-        allow_error=True,
-    )
-    if last_commit:
-        lines = last_commit.split("\n")
-        sections.append(f"commit {lines[0]}")
-        if len(lines) > 1:
-            sections.append(f"Author:     {lines[1]}")
-        if len(lines) > 2:
-            sections.append(f"AuthorDate: {lines[2]}")
-        if len(lines) > 3:
-            sections.append(f"Commit:     {lines[3]}")
-        if len(lines) > 4:
-            sections.append(f"CommitDate: {lines[4]}")
-        if len(lines) > 5:
-            sections.append("")
-            sections.append(f"    {lines[5]}")
-            for line in lines[6:]:
-                if line.strip():
-                    sections.append(f"    {line}")
-    else:
-        sections.append("(no previous commits)")
-    sections.append("")
-
-    # Change intent (editable section)
-    sections.append("===== Change intent (edit below) =====")
-    sections.append("- What/why summary:")
-    sections.append("- Breaking changes:")
-    sections.append("- Affected modules:")
-    sections.append("- Issue/PR refs:")
-    sections.append("")
-
-    # Write to output file
-    output_path.parent.mkdir(parents=True, exist_ok=True)
-    output_path.write_text("\n".join(sections), encoding="utf-8")
-    print(f"Commit context written to: {output_path}")
-
-
-def main(argv: list[str] | None = None) -> int:
-    """Main entry point."""
-    parser = argparse.ArgumentParser(
-        description="Collect Git commit context for commit message generation"
-    )
-    parser.add_argument(
-        "--output",
-        "-o",
-        type=Path,
-        default=Path("artifacts/commit_context.txt"),
-        help="Output file path (default: artifacts/commit_context.txt)",
-    )
-    args = parser.parse_args(argv)
-
-    try:
-        collect_commit_context(args.output)
-        return 0
-    except subprocess.CalledProcessError as e:
-        print(f"Git command failed: {e}", file=sys.stderr)
-        return 1
-    except Exception as e:
-        print(f"Error: {e}", file=sys.stderr)
-        return 1
-
-
-if __name__ == "__main__":
-    sys.exit(main())