claude-dev-env 1.17.5 → 1.19.0

package/hooks/blocking/prompt_workflow_validate.py

@@ -1,218 +0,0 @@
-#!/usr/bin/env python3
-"""Shared prompt-workflow validator callable from tests, CLI, and the Stop hook.
-
-Public API
-----------
-validate_prompt_workflow(assistant_message, user_context="")
-    Returns a ``ValidationResult`` with allowed/blocked status and reasons.
-
-CLI
----
-    python prompt_workflow_validate.py path/to/draft.md
-    cat draft.md | python prompt_workflow_validate.py
-
-Exit codes match hook conventions: 0 allowed, 2 blocked.
-"""
-
-from __future__ import annotations
-
-import sys
-from dataclasses import dataclass, field
-from pathlib import Path
-
-from prompt_workflow_gate_core import (
-    find_ambiguous_scope_terms,
-    find_negative_keywords_in_fenced_xml,
-    has_checklist_container,
-    has_debug_intent,
-    has_internal_object_leak,
-    is_prompt_workflow_response,
-    missing_checklist_rows,
-    missing_context_control_signals,
-    missing_required_xml_sections,
-    missing_scope_anchors,
-)
-
-@dataclass(frozen=True)
-class ValidationReason:
-    code: str
-    message: str
-
-
-@dataclass(frozen=True)
-class ValidationResult:
-    allowed: bool
-    reasons: tuple[ValidationReason, ...] = field(default_factory=tuple)
-
-    @property
-    def reason_messages(self) -> list[str]:
-        return [each_reason.message for each_reason in self.reasons]
-
-    @property
-    def reason_codes(self) -> list[str]:
-        return [each_reason.code for each_reason in self.reasons]
-
-
-def _blocked(code: str, message: str) -> ValidationResult:
-    return ValidationResult(
-        allowed=False,
-        reasons=(ValidationReason(code=code, message=message),),
-    )
-
-
-def _check_internal_leak(
-    assistant_message: str,
-    debug_requested: bool,
-) -> ValidationResult | None:
-    if not has_internal_object_leak(assistant_message) or debug_requested:
-        return None
-    return _blocked(
-        code="internal_object_leak",
-        message=(
-            "Raw internal refinement object leakage detected. "
-            "Return sanitized user-facing output unless explicit debug intent is present."
-        ),
-    )
-
-
-def _check_required_sections(assistant_message: str) -> ValidationResult | None:
-    missing_sections = missing_required_xml_sections(assistant_message)
-    if not missing_sections:
-        return None
-    return _blocked(
-        code="missing_xml_sections",
-        message=(
-            "Fenced XML artifact missing required sections: "
-            + ", ".join(missing_sections)
-        ),
-    )
-
-
-def _check_checklist_rows(assistant_message: str) -> ValidationResult | None:
-    if not has_checklist_container(assistant_message):
-        return None
-    missing_rows = missing_checklist_rows(assistant_message)
-    if not missing_rows:
-        return None
-    return _blocked(
-        code="missing_checklist_rows",
-        message=("Deterministic checklist rows missing: " + ", ".join(missing_rows)),
-    )
-
-
-def _check_scope_anchors(assistant_message: str) -> ValidationResult | None:
-    missing_anchors = missing_scope_anchors(assistant_message)
-    if not missing_anchors:
-        return None
-    return _blocked(
-        code="missing_scope_anchors",
-        message=("Required scope anchors missing: " + ", ".join(missing_anchors)),
-    )
-
-
-def _check_context_signals(assistant_message: str) -> ValidationResult | None:
-    missing_signals = missing_context_control_signals(assistant_message)
-    if not missing_signals:
-        return None
-    return _blocked(
-        code="missing_context_signals",
-        message=(
-            "Runtime context-control preamble missing. "
-            "Include the two required lines from prompt-workflow-context-controls "
-            "(minimal instruction layer and on-demand skill loading)."
-        ),
-    )
-
-
-def _check_ambiguous_scope(assistant_message: str) -> ValidationResult | None:
-    ambiguous_terms = find_ambiguous_scope_terms(assistant_message)
-    if not ambiguous_terms:
-        return None
-    return _blocked(
-        code="ambiguous_scope",
-        message=("Ambiguous scope phrasing detected: " + ", ".join(ambiguous_terms)),
-    )
-
-
-def _check_negative_keywords(assistant_message: str) -> ValidationResult | None:
-    violations = find_negative_keywords_in_fenced_xml(assistant_message)
-    if not violations:
-        return None
-    violation_descriptions = [
-        f"  line {each_violation['line_number']}: "
-        f'"{each_violation["keyword"]}" in: {each_violation["line_text"]}'
-        for each_violation in violations
-    ]
-    return _blocked(
-        code="negative_keywords_in_artifact",
-        message=(
-            "Banned negative keywords found inside fenced XML artifact. "
-            "Rephrase as positive directives (what TO do, not what to avoid):\n"
-            + "\n".join(violation_descriptions)
-        ),
-    )
-
-
-def validate_prompt_workflow(
-    assistant_message: str,
-    user_context: str = "",
-) -> ValidationResult:
-    """Run all prompt-workflow gates on *assistant_message*.
-
-    Returns ``ValidationResult.allowed == True`` when every gate passes.
-    The first failing gate short-circuits and its reason is returned.
-    """
-    allowed_result = ValidationResult(allowed=True)
-
-    if not assistant_message.strip():
-        return allowed_result
-
-    debug_requested = has_debug_intent(user_context)
-
-    leak_result = _check_internal_leak(assistant_message, debug_requested)
-    if leak_result is not None:
-        return leak_result
-
-    if not is_prompt_workflow_response(assistant_message):
-        return allowed_result
-
-    workflow_checks = (
-        _check_required_sections,
-        _check_checklist_rows,
-        _check_scope_anchors,
-        _check_context_signals,
-        _check_ambiguous_scope,
-        _check_negative_keywords,
-    )
-    for each_check in workflow_checks:
-        gate_result = each_check(assistant_message)
-        if gate_result is not None:
-            return gate_result
-
-    return allowed_result
-
-
-def main() -> None:
-    blocked_exit_code: int = 2
-    allowed_exit_code: int = 0
-
-    if len(sys.argv) > 1:
-        file_path = Path(sys.argv[1])
-        assistant_text = file_path.read_text(encoding="utf-8")
-    elif not sys.stdin.isatty():
-        assistant_text = sys.stdin.read()
-    else:
-        sys.stderr.write("Usage: prompt_workflow_validate.py [path/to/draft.md]\n")
-        sys.stderr.write("       cat draft.md | prompt_workflow_validate.py\n")
-        sys.exit(blocked_exit_code)
-
-    validation_result = validate_prompt_workflow(assistant_text)
-    if validation_result.allowed:
-        sys.exit(allowed_exit_code)
-    for each_reason in validation_result.reasons:
-        sys.stderr.write(f"[{each_reason.code}] {each_reason.message}\n")
-    sys.exit(blocked_exit_code)
-
-
-if __name__ == "__main__":
-    main()

package/hooks/blocking/test_prompt_workflow_clipboard.py

@@ -1,54 +0,0 @@
-"""Tests for prompt_workflow_clipboard."""
-
-from __future__ import annotations
-
-import pytest
-
-from prompt_workflow_clipboard import copy_text_to_system_clipboard
-
-
-def test_empty_text_returns_false() -> None:
-    assert copy_text_to_system_clipboard("") is False
-    assert copy_text_to_system_clipboard("   \n") is False
-
-
-def test_respects_skip_env(monkeypatch: pytest.MonkeyPatch) -> None:
-    monkeypatch.setenv("PROMPT_WORKFLOW_SKIP_CLIPBOARD", "1")
-    assert copy_text_to_system_clipboard("hello") is False
-
-
-@pytest.mark.parametrize(
-    "flag_value",
-    ("1", "true", "YES", "on"),
-)
-def test_skip_env_variants(monkeypatch: pytest.MonkeyPatch, flag_value: str) -> None:
-    monkeypatch.setenv("PROMPT_WORKFLOW_SKIP_CLIPBOARD", flag_value)
-    assert copy_text_to_system_clipboard("payload") is False
-
-
-def test_prefers_tkinter_when_it_succeeds(monkeypatch: pytest.MonkeyPatch) -> None:
-    monkeypatch.delenv("PROMPT_WORKFLOW_SKIP_CLIPBOARD", raising=False)
-    monkeypatch.setattr(
-        "prompt_workflow_clipboard._copy_via_tkinter",
-        lambda t: True,
-    )
-
-    def _fail_pyperclip(_t: str) -> bool:
-        raise AssertionError("pyperclip must run only when tkinter fails")
-
-    monkeypatch.setattr("prompt_workflow_clipboard._copy_via_pyperclip", _fail_pyperclip)
-    assert copy_text_to_system_clipboard("hello") is True
-
-
-def test_falls_back_to_pyperclip(monkeypatch: pytest.MonkeyPatch) -> None:
-    monkeypatch.delenv("PROMPT_WORKFLOW_SKIP_CLIPBOARD", raising=False)
-    monkeypatch.setattr("prompt_workflow_clipboard._copy_via_tkinter", lambda t: False)
-    monkeypatch.setattr("prompt_workflow_clipboard._copy_via_pyperclip", lambda t: True)
-    assert copy_text_to_system_clipboard("hello") is True
-
-
-def test_returns_false_when_both_backends_fail(monkeypatch: pytest.MonkeyPatch) -> None:
-    monkeypatch.delenv("PROMPT_WORKFLOW_SKIP_CLIPBOARD", raising=False)
-    monkeypatch.setattr("prompt_workflow_clipboard._copy_via_tkinter", lambda t: False)
-    monkeypatch.setattr("prompt_workflow_clipboard._copy_via_pyperclip", lambda t: False)
-    assert copy_text_to_system_clipboard("hello") is False

package/hooks/blocking/test_prompt_workflow_gate_core.py

@@ -1,195 +0,0 @@
-"""Unit tests for shared prompt workflow gate logic."""
-
-from prompt_workflow_gate_core import (
-    extract_fenced_xml_content,
-    extract_fenced_xml_content_from_export,
-    find_ambiguous_scope_terms,
-    has_checklist_container,
-    has_internal_object_leak,
-    is_prompt_workflow_response,
-    missing_context_control_signals,
-    missing_checklist_rows,
-    missing_required_xml_sections,
-    missing_scope_anchors,
-    normalize_prompt_workflow_export,
-)
-
-def test_internal_object_leak_detected() -> None:
-    text = '{"pipeline_mode": "internal_section_refinement_with_final_audit"}'
-    assert has_internal_object_leak(text)
-
-def test_missing_scope_anchors_returns_expected_rows() -> None:
-    text = "target_local_roots only."
-    missing = missing_scope_anchors(text)
-    assert "target_canonical_roots" in missing
-    assert "completion_boundary" in missing
-
-def test_missing_checklist_rows_detected() -> None:
-    text = "checklist_results: structured_scoped_instructions only"
-    missing = missing_checklist_rows(text)
-    assert "completion_boundary_measurable" in missing
-
-def test_checklist_container_detection() -> None:
-    assert has_checklist_container("checklist_results:\n- structured_scoped_instructions")
-
-def test_prompt_workflow_response_detection() -> None:
-    message = (
-        "overall_status: pass\n"
-        "target_local_roots: /repo\n"
-        "comparison_basis: current behavior vs deterministic guarantees\n"
-    )
-    assert is_prompt_workflow_response(message)
-
-def test_missing_context_control_signals_detected() -> None:
-    missing = missing_context_control_signals("base_minimal_instruction_layer: true")
-    assert "on_demand_skill_loading: true" in missing
-
-def test_ambiguous_scope_terms_detected() -> None:
-    text = "Scope applies to this session and current files."
-    terms = find_ambiguous_scope_terms(text)
-    assert "this session" in terms
-    assert "current files" in terms
-
-def _fenced_xml(body: str) -> str:
-    return f"```xml\n{body}\n```"
-
-def _runtime_context_lines() -> tuple[str, ...]:
-    return (
-        "<runtime_context>",
-        "base_minimal_instruction_layer: true",
-        "on_demand_skill_loading: true",
-        "</runtime_context>",
-        "",
-    )
-
-def _flattened_transcript(*lines: str) -> str:
-    return "\n".join(lines) + "\n"
-
-def _flattened_attempt(*body_lines: str, audit_line: str = "Audit: pass 15/15") -> str:
-    flattened_lines = [audit_line, ""]
-    for line in body_lines:
-        flattened_lines.append(f"  {line}" if line else "")
-    return "\n".join(flattened_lines)
-
-def test_missing_required_xml_sections_all_present_returns_empty() -> None:
-    body = (
-        "<role>R.</role>\n"
-        "<background>C.</background>\n"
-        "<instructions>I.</instructions>\n"
-        "<constraints>Co.</constraints>\n"
-        "<output_format>O.</output_format>\n"
-    )
-    assert missing_required_xml_sections(_fenced_xml(body)) == []
-
-def test_missing_required_xml_sections_missing_background() -> None:
-    body = (
-        "<role>R.</role>\n"
-        "<instructions>I.</instructions>\n"
-        "<constraints>Co.</constraints>\n"
-        "<output_format>O.</output_format>\n"
-    )
-    assert missing_required_xml_sections(_fenced_xml(body)) == ["background"]
-
-def test_missing_required_xml_sections_missing_role_and_output_format() -> None:
-    body = (
-        "<background>C.</background>\n"
-        "<instructions>I.</instructions>\n"
-        "<constraints>Co.</constraints>\n"
-    )
-    missing = missing_required_xml_sections(_fenced_xml(body))
-    assert missing == ["role", "output_format"]
-
-def test_missing_required_xml_sections_no_fence_returns_empty() -> None:
-    assert missing_required_xml_sections("no fenced xml here") == []
-
-def test_missing_required_xml_sections_prose_without_tags_counts_as_missing() -> None:
-    body = (
-        "<role>R.</role>\n"
-        "background appears in prose but has no tags.\n"
-        "<instructions>I.</instructions>\n"
-        "<constraints>Co.</constraints>\n"
-        "<output_format>O.</output_format>\n"
-    )
-    assert missing_required_xml_sections(_fenced_xml(body)) == ["background"]
-
-def test_extract_fenced_xml_preserves_content_after_nested_inner_fence() -> None:
-    message = (
-        "```xml\n"
-        "<role>R</role>\n"
-        "<illustrations>\n"
-        "```bash\necho hi\n```\n"
-        "</illustrations>\n"
-        "<background>B</background>\n"
-        "<instructions>I</instructions>\n"
-        "<constraints>C</constraints>\n"
-        "<output_format>O</output_format>\n"
-        "```\n"
-    )
-    extracted = extract_fenced_xml_content(message)
-    assert "</illustrations>" in extracted
-    assert "<background>B</background>" in extracted
-
-def test_normalize_prompt_workflow_export_rebuilds_fence_from_flattened_transcript() -> None:
-    transcript = _flattened_transcript(
-        _flattened_attempt(
-            *_runtime_context_lines(),
-            "<role>R</role>",
-            "<background>B</background>",
-            "<instructions>I</instructions>",
-            "<constraints>C</constraints>",
-            "<output_format>O</output_format>",
-            "✻ Worked for 1m 7s",
-            audit_line="● Audit: pass 15/15",
-        ),
-    )
-    normalized = normalize_prompt_workflow_export(transcript)
-    assert normalized.startswith("Audit: pass 15/15\n```xml\n")
-    assert normalized.endswith("\n```")
-    assert "<runtime_context>" in normalized
-    assert "✻ Worked for 1m 7s" not in normalized
-
-def test_normalize_prompt_workflow_export_uses_last_audit_attempt() -> None:
-    first_attempt = _flattened_attempt(
-        "<role>FIRST</role>",
-        "<background>Old</background>",
-        "<instructions>Old</instructions>",
-        "<constraints>Old</constraints>",
-        "<output_format>Old</output_format>",
-        audit_line="● Audit: pass 15/15",
-    )
-    second_attempt = _flattened_attempt(
-        *_runtime_context_lines(),
-        "<role>FINAL</role>",
-        "<background>Fresh</background>",
-        "<instructions>I</instructions>",
-        "<constraints>C</constraints>",
-        "<output_format>O</output_format>",
-        "✻ Worked for 2m 8s",
-    )
-    transcript = _flattened_transcript(
-        first_attempt,
-        "",
-        "● Re-emitting the full artifact with the runtime signals added.",
-        "",
-        second_attempt,
-    )
-    normalized = normalize_prompt_workflow_export(transcript)
-    assert "<role>FINAL</role>" in normalized
-    assert "<role>FIRST</role>" not in normalized
-
-def test_extract_fenced_xml_content_from_export_supports_flattened_transcript() -> None:
-    transcript = _flattened_transcript(
-        _flattened_attempt(
-            "<role>R</role>",
-            "<background>B</background>",
-            "<instructions>I</instructions>",
-            "<constraints>C</constraints>",
-            "<output_format>O</output_format>",
-            "✻ Worked for 31s",
-            audit_line="● Audit: pass 15/15",
-        ),
-    )
-    extracted = extract_fenced_xml_content_from_export(transcript)
-    assert extracted.startswith("<role>R</role>")
-    assert "<output_format>O</output_format>" in extracted
-    assert "Worked for" not in extracted