`ffab688`

Validate generated HTML asset links

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 1 week ago

SHA: ffab6888cb582f29553ee3c5972bdb23b766fa74
Parents: 2c722c3
Tree: 039a614

4 changed files

Status	File	+	-
M	`src/loader/runtime/finalization.py`	48	13
M	`src/loader/runtime/safeguard_services.py`	87	9
M	`tests/test_finalization.py`	47	0
M	`tests/test_safeguard_services.py`	44	0

src/loader/runtime/finalization.pymodified

      lines = ["Repair focus:"]
      lines.extend(f"- {item}" for item in fixes)
 +    if quality_targets:
 +        lines.extend(_html_quality_repair_target_lines(quality_targets))
      primary_target = repair_targets[0] if repair_targets else None
      if primary_target is not None:
          expected_action = _repair_expected_action_line(
                  ),
                  "- Do not reread unrelated reference materials or restart discovery "
                  "while this concrete repair target is unresolved.",
 +                *(
 +                    [
 +                        "- After the concrete reference repair passes, continue with the "
 +                        "listed content-quality targets; do not declare completion while "
 +                        "any listed quality target remains.",
 +                        *_html_quality_repair_strategy_lines(),
 +                    ]
 +                    if quality_targets
 +                    else []
 +                ),
+             ]
+         )
      else:
      targets: list[VerificationQualityRepairTarget],
  ) -> str:
      lines = ["Repair focus:"]
 -    visible_targets = targets[:_MAX_HTML_QUALITY_REPAIR_TARGETS]
 -    for target in visible_targets:
 -        lines.append(f"- Improve `{target.artifact_path}`: {target.issue}.")
 -    hidden_count = len(targets) - len(visible_targets)
 -    if hidden_count > 0:
 -        lines.append(
 -            f"- {hidden_count} additional generated artifact(s) also failed quality; "
 -            "repair the listed targets first, then rerun verification for the next batch."
 -        )
 +    lines.extend(_html_quality_repair_target_lines(targets))
      primary = targets[0]
      lines.extend(
+         [
              f"- Immediate next step: edit `{primary.artifact_path}` with a substantial "
              "expansion or replacement that satisfies its listed quality issue.",
 -            "- If a target says thin content, add enough concrete prose to comfortably "
 -            "exceed the expected text-character floor; if it says insufficient "
 -            "structured content, add enough real sections, lists, code, tables, or "
 -            "other content blocks to exceed the block floor.",
 +            *_html_quality_repair_strategy_lines(),
              "- Repair every listed quality target in order before any final answer; "
              "do not stop after touching only the first file.",
              "- Update the listed generated artifacts directly; do not recreate the "
      return "\n".join(lines)
 +def _html_quality_repair_target_lines(
 +    targets: list[VerificationQualityRepairTarget],
 +) -> list[str]:
 +    lines: list[str] = []
 +    visible_targets = targets[:_MAX_HTML_QUALITY_REPAIR_TARGETS]
 +    for target in visible_targets:
 +        lines.append(f"- Improve `{target.artifact_path}`: {target.issue}.")
 +    hidden_count = len(targets) - len(visible_targets)
 +    if hidden_count > 0:
 +        lines.append(
 +            f"- {hidden_count} additional generated artifact(s) also failed quality; "
 +            "repair the listed targets first, then rerun verification for the next batch."
 +        )
 +    return lines
++
++
 +def _html_quality_repair_strategy_lines() -> list[str]:
 +    return [
 +        "- If a target says thin content, add enough concrete prose to comfortably "
 +        "exceed the expected text-character floor; if it says insufficient "
 +        "structured content, add enough real sections, lists, code, tables, or "
 +        "other content blocks to exceed the block floor.",
 +    ]
++
++
  def _build_verification_failure_recovery_nudge(
      dod: DefinitionOfDone,
      *,
                  " Use the existing artifact files already on disk as the source of truth: "
                  f"{preview}."
+             )
 +        quality_hint = ""
 +        if quality_targets:
 +            quality_hint = (
 +                f" Verification also identified {len(quality_targets)} generated "
 +                "artifact content-quality target(s); after the reference repair, "
 +                "continue with those quality targets and do not summarize completion "
 +                "while they remain."
 +            )
          return (
              "Verification already identified the concrete repair target. "
              "Do not restart discovery or reread unrelated references. "
              f"`{primary_target.failing_reference}`. "
              f"{expected_action[2:] if expected_action.startswith('- ') else expected_action}"
              f"{source_hint}"
 +            f"{quality_hint}"
+         )
      if quality_targets:
          primary_target = quality_targets[0]

src/loader/runtime/safeguard_services.pymodified

          if not html_declared_target_result.valid:
              return html_declared_target_result
 +        html_asset_result = self._validate_html_local_asset_links(
 +            str(file_path),
 +            str(content),
 +        )
 +        if not html_asset_result.valid:
 +            return html_asset_result
++
          html_root_coverage_result = self._validate_html_root_link_coverage(
              str(file_path),
              str(content),
          if not html_declared_target_result.valid:
              return html_declared_target_result
 +        html_asset_result = self._validate_html_local_asset_links(
 +            str(file_path),
 +            prospective_content,
 +        )
 +        if not html_asset_result.valid:
 +            return html_asset_result
++
          return ValidationResult(valid=True)
      def _validate_patch(self, arguments: dict) -> ValidationResult:
              "\n".join(added_fragments),
+         )
 +    def _validate_html_local_asset_links(
 +        self,
 +        file_path: str,
 +        content: str,
 +    ) -> ValidationResult:
 +        normalized = Path(file_path).expanduser()
 +        if normalized.suffix.lower() not in {".html", ".htm"}:
 +            return ValidationResult(valid=True)
++
 +        missing: list[str] = []
 +        for href, resolved in self._collect_local_href_targets(normalized, content):
 +            target = self._strip_local_href_target(href)
 +            if target is None:
 +                continue
 +            if self._is_local_html_link_target(target):
 +                continue
 +            if not Path(target).suffix:
 +                continue
 +            if resolved.exists():
 +                continue
 +            if href not in missing:
 +                missing.append(href)
++
 +        if not missing:
 +            return ValidationResult(valid=True)
++
 +        preview = ", ".join(missing[:3])
 +        if len(missing) > 3:
 +            preview += ", ..."
 +        return ValidationResult(
 +            valid=False,
 +            reason="HTML local asset references do not exist",
 +            suggestion=(
 +                "Use only existing local assets for non-HTML href values. "
 +                f"Missing local asset href(s): {preview}. Remove the asset link, "
 +                "create the referenced asset first, inline the styling/content, or point "
 +                "the href at an existing local file."
 +            ),
 +            severity="error",
 +        )
++
      def _validate_numbered_sibling_conflict(self, file_path: str) -> ValidationResult:
          path = Path(file_path).expanduser()
          if path.exists() or not path.suffix or not path.parent.exists():
          self,
          file_path: Path,
          content: str,
 +    ) -> list[tuple[str, Path]]:
 +        targets: list[tuple[str, Path]] = []
 +        seen: set[str] = set()
 +        for href, resolved in self._collect_local_href_targets(file_path, content):
 +            target_text = self._strip_local_href_target(href)
 +            if target_text is None or not self._is_local_html_link_target(target_text):
 +                continue
 +            key = f"{target_text}::{resolved}"
 +            if key in seen:
 +                continue
 +            seen.add(key)
 +            targets.append((href, resolved))
 +        return targets
++
 +    def _collect_local_href_targets(
 +        self,
 +        file_path: Path,
 +        content: str,
      ) -> list[tuple[str, Path]]:
          pattern = re.compile(r'href\s*=\s*["\']([^"\']+)["\']', re.IGNORECASE)
          targets: list[tuple[str, Path]] = []
          seen: set[str] = set()
          for href in pattern.findall(content):
 -            target_text = href.strip()
 -            if not self._is_local_html_link_target(target_text):
 +            target_text = self._strip_local_href_target(href)
 +            if target_text is None:
                  continue
              resolved = (file_path.parent / target_text).resolve(strict=False)
 -            key = f"{target_text}::{resolved}"
 +            key = f"{href}::{resolved}"
              if key in seen:
                  continue
              seen.add(key)
 -            targets.append((target_text, resolved))
 +            targets.append((href, resolved))
          return targets
      def _collect_declared_html_targets(
      @staticmethod
      def _is_local_html_link_target(href: str) -> bool:
 +        normalized = PreActionValidator._strip_local_href_target(href)
 +        return bool(normalized and normalized.lower().endswith((".html", ".htm")))
++
 +    @staticmethod
 +    def _strip_local_href_target(href: str) -> str | None:
          target = href.strip()
          if not target:
 -            return False
 +            return None
          if target.startswith(("#", "mailto:", "tel:", "javascript:")):
 -            return False
 +            return None
          if "://" in target:
 -            return False
 -        normalized = target.split("#", 1)[0].split("?", 1)[0].strip().lower()
 -        return normalized.endswith(".html")
 +            return None
 +        normalized = target.split("#", 1)[0].split("?", 1)[0].strip()
 +        return normalized or None
      def _suggest_existing_html_targets(self, root: Path, missing: list[str]) -> list[str]:
          available_by_directory: dict[Path, list[str]] = {}

tests/test_finalization.pymodified

      assert str(chapter_paths[-1].resolve(strict=False)) in repair.allowed_paths
 +def test_verification_repair_guidance_keeps_quality_targets_with_link_repairs(
 +    temp_dir: Path,
 +) -> None:
 +    guide = temp_dir / "guides" / "nginx"
 +    chapters = guide / "chapters"
 +    chapters.mkdir(parents=True)
 +    broken_asset_page = chapters / "07-performance.html"
 +    thin_page = chapters / "06-security.html"
 +    broken_asset_page.write_text('<link rel="stylesheet" href="../styles.css">\n')
 +    thin_page.write_text("<h1>Security</h1>\n")
 +    dod = create_definition_of_done("Create an equally thorough HTML guide.")
 +    dod.evidence = [
 +        VerificationEvidence(
 +            command="links",
 +            passed=False,
 +            output=(
 +                "Missing local HTML links:\n"
 +                f"{broken_asset_page}:../styles.css -> {guide / 'styles.css'}\n"
 +            ),
 +        ),
 +        VerificationEvidence(
 +            command="quality",
 +            passed=False,
 +            output=(
 +                "HTML guide content quality issues:\n"
 +                f"{thin_page}: thin content (1348 text chars, expected at least 1758)\n"
 +            ),
 +        ),
 +    ]
++
 +    guidance = _build_verification_repair_guidance(
 +        dod,
 +        project_root=temp_dir,
 +    )
 +    repair = extract_active_repair_context(
 +        [Message(role=Role.USER, content=guidance)]
 +    )
++
 +    assert f"Fix the broken local reference `../styles.css` in `{broken_asset_page}`" in guidance
 +    assert f"Improve `{thin_page}`: thin content" in guidance
 +    assert "continue with the listed content-quality targets" in guidance
 +    assert "do not declare completion while any listed quality target remains" in guidance
 +    assert repair is not None
 +    assert repair.artifact_path == str(broken_asset_page.resolve(strict=False))
 +    assert str(thin_page.resolve(strict=False)) in repair.allowed_paths
++
++
  @pytest.mark.asyncio
  async def test_turn_finalizer_records_skipped_verification_observation(
      temp_dir: Path,

tests/test_safeguard_services.pymodified

      assert "coming soon" in result.suggestion
 +def test_pre_action_validator_blocks_missing_local_html_asset_href(tmp_path: Path) -> None:
 +    validator = PreActionValidator()
 +    page = tmp_path / "guide" / "chapters" / "07-performance.html"
++
 +    result = validator.validate(
 +        "write",
 +        {
 +            "file_path": str(page),
 +            "content": (
 +                '<html><head><link rel="stylesheet" href="../styles.css"></head>'
 +                "<body><h1>Performance</h1><p>Concrete content.</p></body></html>"
 +            ),
 +        },
 +    )
++
 +    assert result.valid is False
 +    assert result.reason == "HTML local asset references do not exist"
 +    assert "../styles.css" in result.suggestion
 +    assert "create the referenced asset first" in result.suggestion
++
++
 +def test_pre_action_validator_allows_existing_local_html_asset_href(
 +    tmp_path: Path,
 +) -> None:
 +    validator = PreActionValidator()
 +    guide = tmp_path / "guide"
 +    chapters = guide / "chapters"
 +    chapters.mkdir(parents=True)
 +    (guide / "styles.css").write_text("body { color: #222; }\n")
++
 +    result = validator.validate(
 +        "write",
 +        {
 +            "file_path": str(chapters / "07-performance.html"),
 +            "content": (
 +                '<html><head><link rel="stylesheet" href="../styles.css"></head>'
 +                "<body><h1>Performance</h1><p>Concrete content.</p></body></html>"
 +            ),
 +        },
 +    )
++
 +    assert result.valid is True
++
++
  def test_pre_action_validator_blocks_shell_text_rewrite_for_html_target() -> None:
      validator = PreActionValidator()