claude-dev-env 1.17.2 → 1.19.0

package/hooks/blocking/prompt_workflow_gate_core.py

@@ -1,289 +0,0 @@
-#!/usr/bin/env python3
-"""Shared deterministic checks for prompt workflow hooks."""
-
-from __future__ import annotations
-
-import re
-import textwrap
-from typing import Iterable
-
-from prompt_workflow_gate_config import (
-    AMBIGUOUS_SCOPE_TERMS,
-    COMPILED_NEGATIVE_INDIRECT_PATTERNS,
-    COMPILED_NEGATIVE_KEYWORD_PATTERNS,
-    DEBUG_INTENT_MARKERS,
-    INTERNAL_OBJECT_MARKERS,
-    PROMPT_WORKFLOW_RESPONSE_MARKERS,
-    REQUIRED_CHECKLIST_ROWS,
-    REQUIRED_SCOPE_ANCHORS,
-    REQUIRED_XML_SECTIONS,
-)
-
-TRIPLE_BACKTICK = "```"
-AUDIT_LINE_PATTERN = re.compile(r"^\s*[●•]?\s*(Audit:\s*.+?)\s*$")
-
-def _line_opens_xml_fence(line: str) -> bool:
-    stripped = line.strip()
-    if not stripped.startswith(TRIPLE_BACKTICK):
-        return False
-    fence_marker_length = len(TRIPLE_BACKTICK)
-    remainder = stripped[fence_marker_length:].strip()
-    return remainder == "xml" or remainder.startswith("xml ")
-
-def _line_is_bare_fence_close(line: str) -> bool:
-    return line.strip() == TRIPLE_BACKTICK
-
-def _line_opens_inner_markdown_fence(line: str) -> bool:
-    stripped = line.strip()
-    if not stripped.startswith(TRIPLE_BACKTICK):
-        return False
-    return stripped != TRIPLE_BACKTICK
-
-def _collect_inner_markdown_fence(
-    lines: list[str],
-    start_index: int,
-) -> tuple[list[str], int]:
-    inner_lines: list[str] = []
-    index = start_index
-    while index < len(lines):
-        current_line = lines[index]
-        inner_lines.append(current_line)
-        index += 1
-        if _line_is_bare_fence_close(current_line):
-            break
-    return inner_lines, index
-
-def _collect_xml_fence_body(
-    lines: list[str],
-    start_index: int,
-) -> tuple[list[str], int]:
-    body_lines: list[str] = []
-    index = start_index
-    while index < len(lines):
-        current_line = lines[index]
-        if _line_is_bare_fence_close(current_line):
-            return body_lines, index + 1
-        if _line_opens_inner_markdown_fence(current_line):
-            inner_lines, index = _collect_inner_markdown_fence(lines, index)
-            body_lines.extend(inner_lines)
-            continue
-        body_lines.append(current_line)
-        index += 1
-    return body_lines, index
-
-def extract_fenced_xml_content(text: str) -> str:
-    """Extract bodies of ```xml fenced blocks.
-
-    The closing delimiter is a line whose stripped text is exactly three backticks.
-    Inner Markdown code fences (for example a line starting with three backticks
-    plus a language tag) are scanned until their own closing backtick line so the
-    outer ``xml`` fence does not end early.
-    """
-    results: list[str] = []
-    lines = text.splitlines()
-    index = 0
-    while index < len(lines):
-        if not _line_opens_xml_fence(lines[index]):
-            index += 1
-            continue
-        body_lines, index = _collect_xml_fence_body(lines, index + 1)
-        results.append("\n".join(body_lines))
-    return "\n".join(results)
-
-def _line_is_audit_line(line: str) -> bool:
-    return AUDIT_LINE_PATTERN.match(line) is not None
-
-def _normalize_audit_line(line: str) -> str:
-    match = AUDIT_LINE_PATTERN.match(line)
-    if match:
-        return match.group(1).strip()
-    return line.strip()
-
-def _line_starts_exported_artifact(line: str) -> bool:
-    stripped = line.strip()
-    if not stripped:
-        return False
-    if _line_opens_xml_fence(stripped):
-        return True
-    exported_artifact_pattern = re.compile(
-        r"^<(\?xml\b|prompt\b|runtime_context\b|role\b|background\b|instructions\b|constraints\b|output_format\b|illustrations\b|open_question\b)",
-    )
-    return exported_artifact_pattern.match(stripped) is not None
-
-def _trim_trailing_blank_lines(lines: list[str]) -> list[str]:
-    trimmed = list(lines)
-    while trimmed and not trimmed[-1].strip():
-        trimmed.pop()
-    return trimmed
-
-def _trim_flattened_export_tail(lines: list[str]) -> list[str]:
-    trimmed = _trim_trailing_blank_lines(lines)
-    while trimmed and trimmed[-1].lstrip().startswith("✻ "):
-        trimmed.pop()
-        trimmed = _trim_trailing_blank_lines(trimmed)
-    return trimmed
-
-def _find_last_audit_index(lines: list[str]) -> int | None:
-    last_audit_index: int | None = None
-    for index, line in enumerate(lines):
-        if _line_is_audit_line(line):
-            last_audit_index = index
-    return last_audit_index
-
-def _find_first_artifact_index(lines: list[str]) -> int | None:
-    for index, line in enumerate(lines):
-        if _line_starts_exported_artifact(line):
-            return index
-    return None
-
-def _rebuild_from_existing_fence(audit_line: str, artifact_text: str) -> str:
-    fenced_body = extract_fenced_xml_content(artifact_text).strip()
-    if not fenced_body:
-        return audit_line
-    return f"{audit_line}\n```xml\n{fenced_body}\n```"
-
-def _rebuild_from_flattened_body(audit_line: str, artifact_text: str) -> str:
-    dedented_body = textwrap.dedent(artifact_text).strip("\n")
-    if not dedented_body:
-        return audit_line
-    return f"{audit_line}\n```xml\n{dedented_body}\n```"
-
-def _rebuild_canonical_export(audit_line: str, artifact_lines: list[str]) -> str:
-    if not artifact_lines:
-        return audit_line
-    artifact_text = "\n".join(artifact_lines).rstrip()
-    if _line_opens_xml_fence(artifact_lines[0]):
-        return _rebuild_from_existing_fence(audit_line, artifact_text)
-    return _rebuild_from_flattened_body(audit_line, artifact_text)
-
-def normalize_prompt_workflow_export(text: str) -> str:
-    """Return the last successful Audit + fenced XML pair from a message or export.
-
-    Saved transcript exports can flatten blocked retry turns and strip the outer
-    ``xml`` fence. This helper keeps only the last successful ``Audit:`` attempt
-    and rebuilds the canonical audit-plus-fence shape used by prompt-workflow
-    hooks and reviewers.
-    """
-    lines = text.splitlines()
-    last_audit_index = _find_last_audit_index(lines)
-    if last_audit_index is None:
-        return text.strip()
-    audit_line = _normalize_audit_line(lines[last_audit_index])
-    artifact_index = _find_first_artifact_index(lines[last_audit_index + 1 :])
-    if artifact_index is None:
-        return audit_line
-    artifact_lines = _trim_flattened_export_tail(
-        lines[last_audit_index + 1 + artifact_index :],
-    )
-    return _rebuild_canonical_export(audit_line, artifact_lines)
-
-def extract_fenced_xml_content_from_export(text: str) -> str:
-    """Extract fenced XML from a canonical message or flattened transcript export."""
-    normalized = normalize_prompt_workflow_export(text)
-    return extract_fenced_xml_content(normalized)
-
-def missing_required_xml_sections(text: str) -> list[str]:
-    fenced_body = extract_fenced_xml_content(text)
-    if not fenced_body.strip():
-        return []
-    missing_sections: list[str] = []
-    for section_name in REQUIRED_XML_SECTIONS:
-        open_tag = re.compile(rf"<{re.escape(section_name)}(\s[^>]*)?>")
-        close_tag = re.compile(rf"</{re.escape(section_name)}>")
-        if not open_tag.search(fenced_body) or not close_tag.search(fenced_body):
-            missing_sections.append(section_name)
-    return missing_sections
-
-def _build_negative_keyword_violation(
-    match: re.Match[str],
-    line_number: int,
-    line_text: str,
-) -> dict[str, str | int]:
-    return {
-        "keyword": match.group(),
-        "line_number": line_number,
-        "line_text": line_text.strip(),
-    }
-
-def _find_pattern_violations(
-    patterns: Iterable[re.Pattern[str]],
-    line_text: str,
-    line_number: int,
-) -> list[dict[str, str | int]]:
-    violations: list[dict[str, str | int]] = []
-    for pattern in patterns:
-        match = pattern.search(line_text)
-        if match:
-            violations.append(
-                _build_negative_keyword_violation(match, line_number, line_text),
-            )
-    return violations
-
-def find_negative_keywords_in_fenced_xml(
-    text: str,
-) -> list[dict[str, str | int]]:
-    fenced_content = extract_fenced_xml_content(text)
-    if not fenced_content:
-        return []
-    all_violations: list[dict[str, str | int]] = []
-    for line_index, each_line in enumerate(fenced_content.splitlines(), start=1):
-        all_violations.extend(
-            _find_pattern_violations(
-                COMPILED_NEGATIVE_KEYWORD_PATTERNS,
-                each_line,
-                line_index,
-            ),
-        )
-        all_violations.extend(
-            _find_pattern_violations(
-                COMPILED_NEGATIVE_INDIRECT_PATTERNS,
-                each_line,
-                line_index,
-            ),
-        )
-    return all_violations
-
-def _contains_any_marker(text: str, markers: Iterable[str]) -> bool:
-    lower_text = text.lower()
-    return any(marker.lower() in lower_text for marker in markers)
-
-def has_debug_intent(text: str) -> bool:
-    return _contains_any_marker(text, DEBUG_INTENT_MARKERS)
-
-def has_internal_object_leak(text: str) -> bool:
-    return _contains_any_marker(text, INTERNAL_OBJECT_MARKERS)
-
-def missing_scope_anchors(text: str) -> list[str]:
-    return [anchor for anchor in REQUIRED_SCOPE_ANCHORS if anchor not in text]
-
-def find_ambiguous_scope_terms(text: str) -> list[str]:
-    if "scope" not in text.lower():
-        return []
-    matches: list[str] = []
-    lower_text = text.lower()
-    for term in AMBIGUOUS_SCOPE_TERMS:
-        if re.search(rf"\b{re.escape(term)}\b", lower_text):
-            matches.append(term)
-    return matches
-
-def has_checklist_container(text: str) -> bool:
-    lower_text = text.lower()
-    return "checklist_results" in lower_text or "checklist:" in lower_text
-
-def missing_checklist_rows(text: str) -> list[str]:
-    return [row for row in REQUIRED_CHECKLIST_ROWS if row not in text]
-
-def is_prompt_workflow_response(text: str) -> bool:
-    lower_text = text.lower()
-    matched_markers = [
-        marker for marker in PROMPT_WORKFLOW_RESPONSE_MARKERS if marker in lower_text
-    ]
-    return len(matched_markers) >= 2
-
-def missing_context_control_signals(text: str) -> list[str]:
-    required_signals: tuple[str, ...] = (
-        "base_minimal_instruction_layer: true",
-        "on_demand_skill_loading: true",
-    )
-    lowered = text.lower()
-    return [signal for signal in required_signals if signal not in lowered]

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