claude-dev-env 1.14.0 → 1.15.0

package/hooks/blocking/prompt-workflow-stop-guard.py

@@ -1,5 +1,10 @@
 #!/usr/bin/env python3
-"""Stop hook gate for prompt-workflow leakage and deterministic audit coverage."""
+"""Stop hook gate for prompt-workflow leakage and deterministic audit coverage.
+
+When every workflow gate passes, the fenced ``xml`` artifact body is copied to the
+system clipboard via :mod:`prompt_workflow_clipboard` (tkinter, then pyperclip).
+Set ``PROMPT_WORKFLOW_SKIP_CLIPBOARD=1`` to disable (tests, CI, headless).
+"""
 
 from __future__ import annotations
 
@@ -9,7 +14,9 @@ import sys
 from collections.abc import Callable
 from pathlib import Path
 
+from prompt_workflow_clipboard import copy_text_to_system_clipboard
 from prompt_workflow_gate_core import (
+    extract_fenced_xml_content,
     find_ambiguous_scope_terms,
     find_negative_keywords_in_fenced_xml,
     has_debug_intent,
@@ -199,6 +206,10 @@ def main() -> None:
 
     if block is not None:
         sys.stdout.write(json.dumps(block) + "\n")
+    elif is_prompt_workflow_response(assistant_message):
+        artifact_text = extract_fenced_xml_content(assistant_message).strip()
+        if artifact_text:
+            copy_text_to_system_clipboard(artifact_text)
 
     sys.exit(0)
 

package/hooks/blocking/prompt_workflow_clipboard.py

@@ -0,0 +1,63 @@
+#!/usr/bin/env python3
+"""Cross-platform clipboard writes for prompt-workflow XML artifacts."""
+
+from __future__ import annotations
+
+import os
+
+
+def _clipboard_disabled_by_env() -> bool:
+    flag = os.environ.get("PROMPT_WORKFLOW_SKIP_CLIPBOARD", "").strip().lower()
+    return flag in {"1", "true", "yes", "on"}
+
+
+def copy_text_to_system_clipboard(text: str) -> bool:
+    """Write ``text`` to the OS clipboard using Python-only backends.
+
+    Tries :mod:`tkinter` (stdlib) first, then optional ``pyperclip`` if installed.
+    Returns ``True`` when a backend reports success, ``False`` otherwise
+    (missing dependency, headless display, empty payload, or env opt-out).
+    """
+    if not text.strip():
+        return False
+    if _clipboard_disabled_by_env():
+        return False
+    if _copy_via_tkinter(text):
+        return True
+    return _copy_via_pyperclip(text)
+
+
+def _copy_via_tkinter(text: str) -> bool:
+    try:
+        import tkinter as tk
+    except ImportError:
+        return False
+    root: tk.Tk | None = None
+    try:
+        root = tk.Tk()
+        root.withdraw()
+        root.clipboard_clear()
+        root.clipboard_append(text)
+        root.update_idletasks()
+        root.update()
+        return True
+    except Exception:
+        return False
+    finally:
+        if root is not None:
+            try:
+                root.destroy()
+            except Exception:
+                pass
+
+
+def _copy_via_pyperclip(text: str) -> bool:
+    try:
+        import pyperclip
+    except ImportError:
+        return False
+    try:
+        pyperclip.copy(text)
+        return True
+    except Exception:
+        return False

package/hooks/blocking/prompt_workflow_gate_config.py

@@ -96,16 +96,12 @@ NEGATIVE_INDIRECT_PATTERNS_IN_ARTIFACT: tuple[str, ...] = (
 
 REQUIRED_XML_SECTIONS: tuple[str, ...] = (
     "role",
-    "context",
+    "background",
     "instructions",
     "constraints",
     "output_format",
 )
 
-FENCED_XML_BLOCK_PATTERN: re.Pattern[str] = re.compile(
-    r"```xml\s*\n(.*?)```", re.DOTALL
-)
-
 COMPILED_NEGATIVE_KEYWORD_PATTERNS: tuple[re.Pattern[str], ...] = tuple(
     re.compile(rf"\b{re.escape(keyword)}\b", re.IGNORECASE)
     for keyword in NEGATIVE_KEYWORDS_IN_ARTIFACT

package/hooks/blocking/prompt_workflow_gate_core.py

@@ -11,7 +11,6 @@ from prompt_workflow_gate_config import (
     COMPILED_NEGATIVE_INDIRECT_PATTERNS,
     COMPILED_NEGATIVE_KEYWORD_PATTERNS,
     DEBUG_INTENT_MARKERS,
-    FENCED_XML_BLOCK_PATTERN,
     INTERNAL_OBJECT_MARKERS,
     PROMPT_WORKFLOW_RESPONSE_MARKERS,
     REQUIRED_CHECKLIST_ROWS,
@@ -20,9 +19,61 @@ from prompt_workflow_gate_config import (
 )
 
 
+def _line_opens_xml_fence(line: str) -> bool:
+    stripped = line.strip()
+    if not stripped.startswith("```"):
+        return False
+    remainder = stripped[3:].strip()
+    return remainder == "xml" or remainder.startswith("xml ")
+
+
+def _line_is_bare_fence_close(line: str) -> bool:
+    return line.strip() == "```"
+
+
+def _line_opens_inner_markdown_fence(line: str) -> bool:
+    stripped = line.strip()
+    if not stripped.startswith("```"):
+        return False
+    return stripped != "```"
+
+
 def extract_fenced_xml_content(text: str) -> str:
-    all_matches = FENCED_XML_BLOCK_PATTERN.findall(text)
-    return "\n".join(all_matches)
+    """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 _line_opens_xml_fence(lines[index]):
+            index += 1
+            body_lines: list[str] = []
+            while index < len(lines):
+                line = lines[index]
+                if _line_is_bare_fence_close(line):
+                    index += 1
+                    break
+                if _line_opens_inner_markdown_fence(line):
+                    body_lines.append(line)
+                    index += 1
+                    while index < len(lines):
+                        inner_line = lines[index]
+                        body_lines.append(inner_line)
+                        index += 1
+                        if _line_is_bare_fence_close(inner_line):
+                            break
+                    continue
+                body_lines.append(line)
+                index += 1
+            results.append("\n".join(body_lines))
+            continue
+        index += 1
+    return "\n".join(results)
 
 
 def missing_required_xml_sections(text: str) -> list[str]:

package/hooks/blocking/test_prompt_workflow_clipboard.py

@@ -0,0 +1,54 @@
+"""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,6 +1,7 @@
 """Unit tests for shared prompt workflow gate logic."""
 
 from prompt_workflow_gate_core import (
+    extract_fenced_xml_content,
     find_ambiguous_scope_terms,
     has_checklist_container,
     has_internal_object_leak,
@@ -62,7 +63,7 @@ def _fenced_xml(body: str) -> str:
 def test_missing_required_xml_sections_all_present_returns_empty() -> None:
     body = (
         "<role>R.</role>\n"
-        "<context>C.</context>\n"
+        "<background>C.</background>\n"
         "<instructions>I.</instructions>\n"
         "<constraints>Co.</constraints>\n"
         "<output_format>O.</output_format>\n"
@@ -70,19 +71,19 @@ def test_missing_required_xml_sections_all_present_returns_empty() -> None:
     assert missing_required_xml_sections(_fenced_xml(body)) == []
 
 
-def test_missing_required_xml_sections_missing_context() -> None:
+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)) == ["context"]
+    assert missing_required_xml_sections(_fenced_xml(body)) == ["background"]
 
 
 def test_missing_required_xml_sections_missing_role_and_output_format() -> None:
     body = (
-        "<context>C.</context>\n"
+        "<background>C.</background>\n"
         "<instructions>I.</instructions>\n"
         "<constraints>Co.</constraints>\n"
     )
@@ -97,9 +98,27 @@ def test_missing_required_xml_sections_no_fence_returns_empty() -> None:
 def test_missing_required_xml_sections_prose_without_tags_counts_as_missing() -> None:
     body = (
         "<role>R.</role>\n"
-        "context appears in prose but has no tags.\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)) == ["context"]
+    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

package/hooks/blocking/test_prompt_workflow_stop_guard.py

@@ -10,6 +10,14 @@ import pytest
 
 SCRIPT_PATH = Path(__file__).parent / "prompt-workflow-stop-guard.py"
 
+
+@pytest.fixture(autouse=True)
+def _disable_prompt_workflow_clipboard_in_subprocess(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Subprocess hook inherits env; clipboard would be flaky in CI."""
+    monkeypatch.setenv("PROMPT_WORKFLOW_SKIP_CLIPBOARD", "1")
+
 def _run_hook(payload: dict) -> subprocess.CompletedProcess[str]:
     return subprocess.run(
         [sys.executable, str(SCRIPT_PATH)],
@@ -121,7 +129,7 @@ def test_blocks_ambiguous_scope_phrasing() -> None:
 def _wrap_five_section_scaffold(inner_body: str) -> str:
     return (
         "<role>Test role sentence one.</role>\n"
-        "<context>Test context sentence one.</context>\n"
+        "<background>Test background sentence one.</background>\n"
         f"{inner_body}\n"
         "<constraints>Test constraints sentence one.</constraints>\n"
         "<output_format>Test output format sentence one.</output_format>\n"
@@ -218,7 +226,7 @@ def test_permits_negative_keywords_outside_fenced_xml() -> None:
     assert result.stdout.strip() == ""
 
 
-def test_blocks_when_fenced_xml_missing_context_section() -> None:
+def test_blocks_when_fenced_xml_missing_background_section() -> None:
     fenced_body = (
         "<role>Test role sentence one.</role>\n"
         "<instructions>Test instructions sentence one.</instructions>\n"
@@ -231,7 +239,7 @@ def test_blocks_when_fenced_xml_missing_context_section() -> None:
     result = _run_hook(payload)
     response = json.loads(result.stdout)
     assert response["decision"] == "block"
-    assert "context" in response["reason"]
+    assert "background" in response["reason"]
     assert "include all required XML sections" in response["systemMessage"]
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "claude-dev-env",
-    "version": "1.14.0",
+    "version": "1.15.0",
     "description": "Claude Code development standards — rules, hooks, agents, commands, and skills",
     "type": "module",
     "bin": {