claude-dev-env 4.2.0 → 7.0.0

package/hooks/blocking/volatile_path_in_post_blocker.py

@@ -1,461 +0,0 @@
-#!/usr/bin/env python3
-"""PreToolUse hook: block durable GitHub posts that reference volatile paths.
-
-Root cause: a background job posted a PR comment citing an artifact under a job
-scratch directory. Job tmp dirs, worktrees, and system temp locations are
-ephemeral — they are cleaned soon after the run — while a posted comment, PR
-body, issue, or review lives forever. A durable post that points at ephemeral
-scratch breaks the moment that scratch is removed.
-
-Detection strategy: gather the post body text from the tool call, then scan it
-for volatile-path markers. Two tool families carry post bodies: shell ``gh``
-post subcommands (``pr create/comment/edit/review``, ``issue
-create/comment/edit``) and the GitHub MCP post tools (any
-``mcp__plugin_github_github__*`` tool that carries a ``body`` or ``comment``
-parameter). For a ``gh`` command the body comes from ``--body``/``-b`` inline
-strings and from the file named by ``--body-file``/``-F`` (its contents are read
-and scanned, since that content is what gets embedded in the post). The ``gh``
-command is tokenized with ``shlex.split`` and the ``gh`` word must be the first
-command token, so a ``gh pr comment`` that only appears as quoted data inside
-another argument never classifies.
-
-The marker scan runs in two tiers over the normalized body. Five bare markers
-— the system temp locations and env tokens — match as a plain substring
-anywhere. Two dot-relative directory markers, ``.claude-profile-a/jobs/`` and
-``.claude/worktrees/``, match when either a slash sits immediately before the
-marker or a path segment follows it. A machine-local absolute path
-(``~/.claude/worktrees/wt/f.py``) and a relative path that names a child
-(``see .claude/worktrees/wt-1/notes.md``) both count; a bare directory-name
-mention with neither anchor posts cleanly.
-"""
-
-import json
-import shlex
-import sys
-from pathlib import Path
-
-_hooks_dir = str(Path(__file__).resolve().parent.parent)
-if _hooks_dir not in sys.path:
-    sys.path.insert(0, _hooks_dir)
-
-from blocking._gh_body_arg_utils import (  # noqa: E402
-    all_body_flags,
-    body_file_flag,
-    body_file_short_flag,
-    count_extra_tokens_to_skip_for_split_quoted_value,
-    get_logical_first_line,
-    is_unresolvable_shell_value,
-    match_body_file_equals_prefix,
-    match_body_flag_equals_prefix,
-    strip_surrounding_quotes,
-)
-from hooks_constants.hook_block_logger import log_hook_block  # noqa: E402
-from hooks_constants.volatile_path_in_post_blocker_constants import (  # noqa: E402
-    ALL_BARE_VOLATILE_PATH_MARKERS,
-    ALL_GH_POST_SUBCOMMANDS,
-    ALL_MCP_BODY_PARAM_NAMES,
-    ALL_PATH_ANCHORED_VOLATILE_PATH_MARKERS,
-    BASH_TOOL_NAME,
-    BODY_FILE_ENCODING,
-    CORRECTIVE_MESSAGE,
-    GH_COMMAND_NAME,
-    MCP_GITHUB_TOOL_PREFIX,
-    MINIMUM_POST_SUBCOMMAND_TOKEN_COUNT,
-    PATH_ANCHOR_CHARACTER,
-    PATH_SEGMENT_START_CHARACTERS,
-    TOKEN_JOIN_SEPARATOR,
-)
-
-
-def _character_starts_path_segment(character: str) -> bool:
-    """Return whether a character can open a path segment after a marker."""
-    return bool(character) and (
-        character.isalnum() or character in PATH_SEGMENT_START_CHARACTERS
-    )
-
-
-def _text_has_anchored_marker(normalized_text: str, marker: str) -> bool:
-    """Return whether the marker appears as part of a path.
-
-    A match counts when either a slash sits immediately before the marker or a
-    path segment follows it. Every occurrence is scanned, so a bare directory
-    mention earlier in the text never masks a path occurrence later::
-
-        ok:   ".claude/worktrees/ is the manifest key"      -> False
-        flag: "path c:/users/me/.claude/worktrees/wt/f.py"  -> True
-        flag: "see .claude/worktrees/wt-1/notes.md"         -> True
-
-    Args:
-        normalized_text: The body text with backslashes folded to forward
-            slashes and lowercased.
-        marker: A dot-relative directory marker to search for.
-
-    Returns:
-        True when at least one occurrence is path-anchored.
-    """
-    search_start = 0
-    while True:
-        found_index = normalized_text.find(marker, search_start)
-        if found_index < 0:
-            return False
-        preceding_character = normalized_text[found_index - 1 : found_index]
-        following_index = found_index + len(marker)
-        following_character = normalized_text[following_index : following_index + 1]
-        is_slash_before = preceding_character == PATH_ANCHOR_CHARACTER
-        is_segment_after = _character_starts_path_segment(following_character)
-        if is_slash_before or is_segment_after:
-            return True
-        search_start = found_index + 1
-
-
-def scan_text_for_volatile_marker(text: str) -> str | None:
-    """Return the first volatile-path marker found in text, or None.
-
-    Backslashes normalize to forward slashes and the text lowercases before the
-    scan. The two dot-relative directory markers count when either a slash sits
-    immediately before them or a path segment follows them; the five bare
-    markers match anywhere::
-
-        ok:   "the `.claude/worktrees/` manifest key"    -> None
-        flag: r"C:\\Users\\me\\.claude-profile-a\\jobs\\x"   -> ".claude-profile-a/jobs/"
-        flag: "see .claude/worktrees/wt-1/notes.md"       -> ".claude/worktrees/"
-        flag: "saved to %TEMP%\\out.txt"                  -> "%temp%"
-
-    A dot-relative marker with neither a slash before it nor a path segment
-    after it — start of text naming the directory, a quoted config constant,
-    or a placeholder form such as ``.claude/worktrees/<name>`` — posts cleanly.
-
-    Args:
-        text: The post body text to scan.
-
-    Returns:
-        The matched marker string, or None when the text names no volatile path.
-    """
-    normalized_text = text.replace("\\", PATH_ANCHOR_CHARACTER).lower()
-    for each_marker in ALL_PATH_ANCHORED_VOLATILE_PATH_MARKERS:
-        if _text_has_anchored_marker(normalized_text, each_marker):
-            return each_marker
-    for each_marker in ALL_BARE_VOLATILE_PATH_MARKERS:
-        if each_marker in normalized_text:
-            return each_marker
-    return None
-
-
-def _is_environment_assignment(token: str) -> bool:
-    """Return whether a token is a ``NAME=value`` shell environment assignment."""
-    equals_index = token.find("=")
-    if equals_index <= 0:
-        return False
-    name_part = token[:equals_index]
-    if not (name_part[0].isalpha() or name_part[0] == "_"):
-        return False
-    return all(
-        each_character.isalnum() or each_character == "_"
-        for each_character in name_part
-    )
-
-
-def _tokens_name_gh_post_command(all_command_tokens: list[str]) -> bool:
-    """Return whether the tokens start with an affected ``gh`` post subcommand.
-
-    Leading ``NAME=value`` env assignments are skipped, then the next token must
-    be the literal ``gh`` command word followed by a post noun and verb. Anchoring
-    to the first command word keeps a ``gh pr comment`` mentioned only as quoted
-    argument data from classifying.
-
-    Args:
-        all_command_tokens: The shlex-split tokens of the logical command line.
-
-    Returns:
-        True when the command invokes an affected ``gh`` post subcommand.
-    """
-    command_index = 0
-    while command_index < len(all_command_tokens) and _is_environment_assignment(
-        all_command_tokens[command_index]
-    ):
-        command_index += 1
-    if command_index >= len(all_command_tokens):
-        return False
-    if all_command_tokens[command_index] != GH_COMMAND_NAME:
-        return False
-    remaining_tokens = all_command_tokens[command_index + 1 :]
-    if len(remaining_tokens) < MINIMUM_POST_SUBCOMMAND_TOKEN_COUNT:
-        return False
-    post_noun = remaining_tokens[0]
-    post_verb = remaining_tokens[1]
-    return post_verb in ALL_GH_POST_SUBCOMMANDS.get(post_noun, frozenset())
-
-
-def _reassemble_split_quoted_value(
-    value_token: str, all_following_tokens: list[str]
-) -> tuple[str, int]:
-    """Rejoin a quoted value that ``shlex.split(posix=False)`` split on spaces.
-
-    ``posix=False`` keeps backslashes intact (so Windows paths survive) but
-    splits a quoted value such as ``"dump in %TEMP%"`` into three tokens. This
-    rejoins the value token with the follow-on tokens up to the closing quote,
-    then strips the surrounding quotes so the full body text can be scanned.
-
-    Args:
-        value_token: The first token of the value, following the flag.
-        all_following_tokens: The tokens after ``value_token`` on the line.
-
-    Returns:
-        A ``(full_value, extra_tokens_consumed)`` pair; ``extra_tokens_consumed``
-        counts the follow-on tokens joined into the value.
-    """
-    extra_tokens = count_extra_tokens_to_skip_for_split_quoted_value(
-        all_following_tokens, value_token
-    )
-    if not extra_tokens:
-        return strip_surrounding_quotes(value_token), 0
-    joined_value = value_token + TOKEN_JOIN_SEPARATOR + TOKEN_JOIN_SEPARATOR.join(
-        all_following_tokens[:extra_tokens]
-    )
-    return strip_surrounding_quotes(joined_value), extra_tokens
-
-
-def _extract_flag_value_at(
-    all_command_tokens: list[str], token_index: int
-) -> tuple[bool, str, int] | None:
-    """Return a body/body-file value starting at token_index, or None.
-
-    Args:
-        all_command_tokens: The shlex-split tokens of the logical command line.
-        token_index: The index of the token to inspect.
-
-    Returns:
-        An ``(is_body_file, value, next_index)`` triple when the token opens a
-        body or body-file flag, else None. ``next_index`` is where scanning
-        resumes after the value's tokens.
-    """
-    current_token = all_command_tokens[token_index]
-    following_tokens = all_command_tokens[token_index + 1:]
-    body_equals_prefix = match_body_flag_equals_prefix(current_token)
-    if body_equals_prefix is not None:
-        value, extra = _reassemble_split_quoted_value(
-            current_token[len(body_equals_prefix):], following_tokens
-        )
-        return False, value, token_index + 1 + extra
-    body_file_equals_prefix = match_body_file_equals_prefix(current_token)
-    if body_file_equals_prefix is not None:
-        value, extra = _reassemble_split_quoted_value(
-            current_token[len(body_file_equals_prefix):], following_tokens
-        )
-        return True, value, token_index + 1 + extra
-    if current_token in all_body_flags and following_tokens:
-        value, extra = _reassemble_split_quoted_value(following_tokens[0], following_tokens[1:])
-        return False, value, token_index + 2 + extra
-    if current_token in (body_file_flag, body_file_short_flag) and following_tokens:
-        value, extra = _reassemble_split_quoted_value(following_tokens[0], following_tokens[1:])
-        return True, value, token_index + 2 + extra
-    return None
-
-
-def _collect_body_flag_values(
-    all_command_tokens: list[str],
-) -> tuple[list[str], list[str]]:
-    """Return inline body strings and body-file paths from the command tokens.
-
-    Args:
-        all_command_tokens: The shlex-split tokens of the logical command line.
-
-    Returns:
-        A ``(all_inline_bodies, all_body_file_paths)`` pair, each value stripped
-        of its surrounding quotes and rejoined across split-quote tokens.
-    """
-    all_inline_bodies: list[str] = []
-    all_body_file_paths: list[str] = []
-    token_index = 0
-    while token_index < len(all_command_tokens):
-        extraction = _extract_flag_value_at(all_command_tokens, token_index)
-        if extraction is None:
-            token_index += 1
-            continue
-        is_body_file, value, next_index = extraction
-        if is_body_file:
-            all_body_file_paths.append(value)
-        else:
-            all_inline_bodies.append(value)
-        token_index = next_index
-    return all_inline_bodies, all_body_file_paths
-
-
-def _read_body_file(
-    body_file_path: str, working_directory: str | None = None
-) -> str | None:
-    """Return the contents of a body-file path, or None when it cannot be read.
-
-    Args:
-        body_file_path: The path given to ``--body-file``/``-F``.
-        working_directory: Optional base directory for relative body-file paths.
-
-    Returns:
-        The file text, or None for an unresolvable shell value (such as ``-`` for
-        stdin or a ``$VAR`` path) or an unreadable file.
-    """
-    if is_unresolvable_shell_value(body_file_path):
-        return None
-    resolved_path = Path(body_file_path)
-    if not resolved_path.is_absolute() and working_directory:
-        resolved_path = Path(working_directory) / body_file_path
-    try:
-        return resolved_path.read_text(encoding=BODY_FILE_ENCODING)
-    except OSError:
-        return None
-
-
-def extract_gh_post_body_texts(
-    command: str, working_directory: str | None = None
-) -> list[str]:
-    """Return every post body text an affected ``gh`` command would send.
-
-    Non-post ``gh`` commands and unparseable command lines yield an empty list.
-    Body-file contents are read from disk so the embedded text is scanned rather
-    than the file path. Relative body-file paths resolve against
-    *working_directory* when provided.
-
-    Args:
-        command: The raw Bash tool command string.
-        working_directory: Optional base directory for relative body-file paths.
-
-    Returns:
-        Inline ``--body`` strings plus the contents of each readable body-file.
-    """
-    logical_line = get_logical_first_line(command)
-    if not logical_line:
-        return []
-    try:
-        all_command_tokens = shlex.split(logical_line, posix=False)
-    except ValueError:
-        return []
-    if not _tokens_name_gh_post_command(all_command_tokens):
-        return []
-    all_inline_bodies, all_body_file_paths = _collect_body_flag_values(
-        all_command_tokens
-    )
-    all_body_texts = list(all_inline_bodies)
-    for each_path in all_body_file_paths:
-        file_text = _read_body_file(each_path, working_directory=working_directory)
-        if file_text is not None:
-            all_body_texts.append(file_text)
-    return all_body_texts
-
-
-def extract_gh_post_body_texts_for_privacy_gate(
-    command: str, working_directory: str | None = None
-) -> tuple[list[str], str | None]:
-    """Like ``extract_gh_post_body_texts``, but fail-closed on unreadable body-files.
-
-    Args:
-        command: The raw Bash tool command string.
-        working_directory: Optional base directory for relative body-file paths.
-
-    Returns:
-        ``(all_body_texts, None)`` when every declared body-file was read (or
-        none were declared), else ``([], deny_reason)`` when a body-file flag is
-        present but its contents could not be loaded for scanning.
-    """
-    logical_line = get_logical_first_line(command)
-    if not logical_line:
-        return [], None
-    try:
-        all_command_tokens = shlex.split(logical_line, posix=False)
-    except ValueError:
-        return [], None
-    if not _tokens_name_gh_post_command(all_command_tokens):
-        return [], None
-    all_inline_bodies, all_body_file_paths = _collect_body_flag_values(
-        all_command_tokens
-    )
-    all_body_texts = list(all_inline_bodies)
-    for each_path in all_body_file_paths:
-        file_text = _read_body_file(each_path, working_directory=working_directory)
-        if file_text is None:
-            return [], (
-                "BLOCKED [pii_prevention_blocker]: durable post uses --body-file "
-                f"but '{each_path}' could not be read for PII scanning. Use an "
-                "absolute path, ensure the file exists, or pass --body text."
-            )
-        all_body_texts.append(file_text)
-    return all_body_texts, None
-
-
-def extract_mcp_body_texts(all_tool_input: dict[str, object]) -> list[str]:
-    """Return the body and comment strings from a GitHub MCP post tool input.
-
-    Args:
-        all_tool_input: The MCP tool's input mapping.
-
-    Returns:
-        The non-empty string values of the ``body`` and ``comment`` parameters.
-    """
-    all_body_texts: list[str] = []
-    for each_param_name in ALL_MCP_BODY_PARAM_NAMES:
-        param_value = all_tool_input.get(each_param_name)
-        if isinstance(param_value, str) and param_value:
-            all_body_texts.append(param_value)
-    return all_body_texts
-
-
-def _collect_body_texts(tool_name: str, all_tool_input: dict[str, object]) -> list[str]:
-    if tool_name == BASH_TOOL_NAME:
-        command = all_tool_input.get("command", "")
-        if not isinstance(command, str) or not command:
-            return []
-        return extract_gh_post_body_texts(command)
-    if tool_name.startswith(MCP_GITHUB_TOOL_PREFIX):
-        return extract_mcp_body_texts(all_tool_input)
-    return []
-
-
-def _first_volatile_marker(all_body_texts: list[str]) -> str | None:
-    for each_text in all_body_texts:
-        matched_marker = scan_text_for_volatile_marker(each_text)
-        if matched_marker is not None:
-            return matched_marker
-    return None
-
-
-def _emit_block(tool_name: str, matched_marker: str) -> None:
-    deny_payload = {
-        "hookSpecificOutput": {
-            "hookEventName": "PreToolUse",
-            "permissionDecision": "deny",
-            "permissionDecisionReason": CORRECTIVE_MESSAGE,
-        }
-    }
-    log_hook_block(
-        calling_hook_name="volatile_path_in_post_blocker.py",
-        hook_event="PreToolUse",
-        block_reason=CORRECTIVE_MESSAGE,
-        tool_name=tool_name,
-        offending_input_preview=matched_marker,
-    )
-    print(json.dumps(deny_payload))
-    sys.stdout.flush()
-
-
-def main() -> None:
-    """Read the PreToolUse payload and block a post that names a volatile path."""
-    try:
-        hook_input = json.load(sys.stdin)
-    except json.JSONDecodeError:
-        sys.exit(0)
-
-    tool_name = hook_input.get("tool_name", "")
-    tool_input = hook_input.get("tool_input", {})
-    if not isinstance(tool_name, str) or not isinstance(tool_input, dict):
-        sys.exit(0)
-
-    all_body_texts = _collect_body_texts(tool_name, tool_input)
-    matched_marker = _first_volatile_marker(all_body_texts)
-    if matched_marker is None:
-        sys.exit(0)
-
-    _emit_block(tool_name, matched_marker)
-    sys.exit(0)
-
-
-if __name__ == "__main__":
-    main()

package/hooks/hooks_constants/conventional_pr_title_gate_constants.py

@@ -1,58 +0,0 @@
-"""Configuration constants for the conventional_pr_title_gate PreToolUse hook."""
-
-import re
-
-ALL_GH_EXECUTABLE_BASENAMES: frozenset[str] = frozenset({"gh", "gh.exe"})
-PR_SUBCOMMAND_TOKEN: str = "pr"
-ALL_PR_TITLE_SUBCOMMAND_VERBS: frozenset[str] = frozenset({"create", "edit"})
-GH_PR_SUBCOMMAND_MINIMUM_TOKEN_COUNT: int = 3
-
-BASH_TOOL_NAME: str = "Bash"
-
-TITLE_LONG_FLAG: str = "--title"
-TITLE_SHORT_FLAG: str = "-t"
-REPO_LONG_FLAG: str = "--repo"
-REPO_SHORT_FLAG: str = "-R"
-
-WORKFLOWS_DIRECTORY_RELATIVE_PATH: str = ".github/workflows"
-ALL_WORKFLOW_FILE_GLOB_PATTERNS: tuple[str, ...] = ("*.yml", "*.yaml")
-
-ALL_SEMANTIC_TITLE_CI_MARKERS: tuple[str, ...] = (
-    "semantic-pull-request",
-    "action-semantic-pull-request",
-    "semantic_pull_request",
-)
-
-ALL_CONVENTIONAL_COMMIT_TYPES: tuple[str, ...] = (
-    "feat",
-    "fix",
-    "chore",
-    "docs",
-    "refactor",
-    "perf",
-    "ci",
-    "style",
-    "test",
-    "build",
-    "revert",
-)
-
-CONVENTIONAL_COMMIT_TITLE_PATTERN: re.Pattern[str] = re.compile(
-    r"^(?:" + "|".join(ALL_CONVENTIONAL_COMMIT_TYPES) + r")(?:\([^)]+\))?!?: .+"
-)
-
-SEMANTIC_ACTION_TYPES_INPUT_PATTERN: re.Pattern[str] = re.compile(r"^\s*types\s*:")
-
-SEMANTIC_ACTION_FLOW_TYPES_INPUT_PATTERN: re.Pattern[str] = re.compile(r"[{,]\s*types\s*:")
-
-YAML_LIST_ITEM_PREFIX: str = "- "
-
-CORRECTIVE_MESSAGE: str = (
-    "BLOCKED [conventional-pr-title]: this repository's CI validates PR titles "
-    "against Conventional Commits, and the --title value here does not match. "
-    "Required shape: type(scope)!: description, where the scope and the "
-    "breaking-change marker (!) are optional. Allowed types: "
-    f"{', '.join(ALL_CONVENTIONAL_COMMIT_TYPES)}.\n\n"
-    "Example: feat(hooks): add the conventional PR title gate\n\n"
-    "Fix the --title value and retry."
-)

package/hooks/hooks_constants/gh_pr_author_swap_constants.py

@@ -1,76 +0,0 @@
-"""Configuration constants for the gh-pr-author swap hook trio.
-
-The PreToolUse enforcer (``gh_pr_author_enforcer.py``) auto-switches the
-active ``gh`` CLI account to ``GITHUB_DEFAULT_ACCOUNT`` before a
-``gh pr create`` invocation, the PostToolUse companion
-(``gh_pr_author_restore.py``) restores the prior account afterwards, and
-the SessionStart cleanup hook (``gh_pr_author_session_cleanup.py``)
-sweeps any stale state files left behind when a prior session was
-interrupted between the swap and the restore. The state file written
-between the hooks is keyed per session so parallel Claude Code sessions
-cannot stomp on each other's swap state.
-"""
-
-from __future__ import annotations
-
-import re
-
-REQUIRED_ACCOUNT_ENV_VAR: str = "GITHUB_DEFAULT_ACCOUNT"
-
-BASH_TOOL_NAME: str = "Bash"
-
-GH_PR_CREATE_PATTERN: re.Pattern[str] = re.compile(
-    r"(?:^|[;&|\n`({]|\$\()[ \t]*"
-    r"(?:(?:if|then|else|elif|while|until|do|!)[ \t]+)*"
-    r"(?:[A-Za-z_][A-Za-z0-9_]*=\S+[ \t]+)*"
-    r"gh(?:[ \t]+(?:--[A-Za-z][\w-]*(?:=\S+)?|-[A-Za-z])(?:[ \t]+(?!-)\S+)?)*"
-    r"[ \t]+pr[ \t]+create\b",
-    re.IGNORECASE,
-)
-WEB_FLAG_PATTERN: re.Pattern[str] = re.compile(r"(?<!\S)(?:--web|-w)(?!\S)")
-COMMAND_SEPARATOR_PATTERN: re.Pattern[str] = re.compile(
-    r"(?:&&|\|\||;|(?<!\|)\|(?!\|)|(?<!&)&(?!&)|[\r\n])"
-)
-BASH_COMMENT_INTRODUCER_CHARACTER: str = "#"
-COMMAND_SUBSTITUTION_OPENER_LENGTH: int = 2
-
-ALL_GH_API_USER_COMMAND: tuple[str, ...] = ("gh", "api", "user", "--jq", ".login")
-GH_API_USER_TIMEOUT_SECONDS: int = 5
-
-ALL_GH_AUTH_SWITCH_COMMAND_HEAD: tuple[str, ...] = ("gh", "auth", "switch", "--user")
-GH_AUTH_SWITCH_TIMEOUT_SECONDS: int = 10
-
-STATE_FILE_PREFIX: str = "gh_pr_author_swap_"
-STATE_FILE_SUFFIX: str = ".json"
-STATE_FILE_DEFAULT_SESSION_ID: str = "default"
-
-SESSION_ID_UNSAFE_CHARACTERS_PATTERN: re.Pattern[str] = re.compile(r"[^A-Za-z0-9_-]")
-
-STATE_FILE_ORIGINAL_ACCOUNT_KEY: str = "original_account"
-STATE_FILE_PRIMARY_ACCOUNT_KEY: str = "primary_account"
-
-STATE_FILE_PERMISSION_MODE: int = 0o600
-
-STATE_FILE_PAYLOAD_TEXT_ENCODING_NAME: str = "utf-8"
-
-OS_O_NOFOLLOW_ATTRIBUTE_NAME: str = "O_NOFOLLOW"
-
-STATE_FILE_STALE_AGE_SECONDS: int = 1800
-
-ALL_SHELL_QUOTE_CHARACTERS: tuple[str, ...] = ("\"", "'")
-SHELL_QUOTE_REPLACEMENT_CHARACTER: str = " "
-SHELL_BACKSLASH_ESCAPE_PAIR_LENGTH: int = 2
-SHELL_BACKTICK_CHARACTER: str = "`"
-SHELL_DOLLAR_CHARACTER: str = "$"
-SHELL_PAREN_OPEN_CHARACTER: str = "("
-SHELL_PAREN_CLOSE_CHARACTER: str = ")"
-SHELL_LESS_THAN_CHARACTER: str = "<"
-SHELL_BACKSLASH_CHARACTER: str = "\\"
-SHELL_NEWLINE_CHARACTER: str = "\n"
-
-HEREDOC_OPENER_TAG_PATTERN: re.Pattern[str] = re.compile(
-    r"[ \t]*(?P<dash>-?)[ \t]*(?:'(?P<sq_tag>[A-Za-z_][A-Za-z0-9_]*)'"
-    r"|\"(?P<dq_tag>[A-Za-z_][A-Za-z0-9_]*)\""
-    r"|(?P<bare_tag>[A-Za-z_][A-Za-z0-9_]*))"
-)
-HEREDOC_OPENER_TOKEN_LENGTH: int = 2

package/hooks/hooks_constants/pr_description_writer_gate_constants.py

@@ -1,73 +0,0 @@
-"""Constants for the pr-description-writer spawn tracker and its gh pr create gate.
-
-The tracker records one fact per session: the session spawned the
-``pr-description-writer`` agent. The gate reads that fact when the session runs
-``gh pr create`` and denies the command when the fact is absent.
-"""
-
-from __future__ import annotations
-
-import tempfile
-from pathlib import Path
-
-from hooks_constants.session_edit_stage_gate_constants import (
-    SESSION_ID_UNSAFE_CHARACTERS_PATTERN,
-)
-
-PR_DESCRIPTION_WRITER_SUBAGENT_TYPE: str = "pr-description-writer"
-
-ALL_AGENT_SPAWN_TOOL_NAMES: frozenset[str] = frozenset({"Agent", "Task"})
-
-SPAWN_MARKER_FILE_PREFIX: str = "claude-session-pr-description-writer-"
-SPAWN_MARKER_FILE_SUFFIX: str = ".marker"
-
-SUBAGENT_TYPE_FIELD_NAME: str = "subagent_type"
-TOOL_INPUT_FIELD_NAME: str = "tool_input"
-TOOL_NAME_FIELD_NAME: str = "tool_name"
-COMMAND_FIELD_NAME: str = "command"
-
-ALL_GH_EXECUTABLE_BASENAMES: frozenset[str] = frozenset({"gh", "gh.exe", "gh.cmd"})
-PR_SUBCOMMAND_TOKEN: str = "pr"
-CREATE_SUBCOMMAND_TOKEN: str = "create"
-GH_PR_CREATE_MINIMUM_TOKEN_COUNT: int = 3
-
-SPAWN_BYPASS_MARKER: str = "# pr-description-skip"
-
-CORRECTIVE_MESSAGE: str = (
-    "BLOCKED: [PR_DESCRIPTION_WRITER] This session runs `gh pr create` with no "
-    "`pr-description-writer` agent spawn recorded.\n\n"
-    "The agent writes the title and body from the current diff, then returns the "
-    "markdown and a body-file path for you to publish.\n\n"
-    "Two ways forward:\n"
-    "  1. Spawn the agent (Agent tool, subagent_type `pr-description-writer`), "
-    "then run `gh pr create --body-file <path>` with what it returns.\n"
-    "  2. Append the trailing comment `# pr-description-skip` to the command when "
-    "you are writing the body yourself on purpose."
-)
-
-
-def spawn_marker_path(session_id: str, temp_directory: Path | None = None) -> Path | None:
-    """Return this session's marker file path, or None when it names no session.
-
-    The tracker writes this path and the gate reads it, so the file name lives
-    in one place. A session id that sanitizes to nothing yields no path, so
-    every marker on disk belongs to one real session and a marker a crashed
-    session leaves behind is inert.
-
-    Args:
-        session_id: Raw ``session_id`` from the hook payload.
-        temp_directory: The directory holding the marker. Defaults to the
-            system temp directory.
-
-    Returns:
-        Absolute path to this session's marker file, or None when the payload
-        names no session this hook can key on.
-    """
-    sanitized_session_id = SESSION_ID_UNSAFE_CHARACTERS_PATTERN.sub("", session_id)
-    if not sanitized_session_id:
-        return None
-    file_name = (
-        f"{SPAWN_MARKER_FILE_PREFIX}{sanitized_session_id}{SPAWN_MARKER_FILE_SUFFIX}"
-    )
-    resolved_temp_directory = temp_directory or Path(tempfile.gettempdir())
-    return resolved_temp_directory / file_name