claude-dev-env 8.6.1 → 8.8.0

package/scripts/codex_compat_materializer.py

@@ -27,7 +27,8 @@ publish_plan_max_positional_arguments = 3
 publish_plan_failure_injector_position = 2
 frontmatter_unsupported_fields = ("tools", "model", "color", "disable-model-invocation")
 instruction_alias_filenames = frozenset({"AGENTS.md", "CLAUDE.md"})
-failure_blast_radius_rule_relative_path = "rules/failure-blast-radius.md"
+codex_instruction_rule_relative_paths = ("rules/failure-blast-radius.md", "rules/correction-lens.md")
+codex_instruction_source_separator = ", "
 codex_instruction_target_path = "AGENTS.md"
 codex_instruction_section_heading = "## Excerpt for repository-instruction sessions"
 codex_hook_manifest_source_path = "hooks/hooks.json"
@@ -502,41 +503,57 @@ def convert_agent(agent: ClaudeAgent) -> str:
     return content
 
 
-def render_codex_failure_blast_radius(rule_content: str) -> str:
-    """Extract the repository-instruction contract from the canonical rule.
+def render_codex_instruction_excerpt(rule_content: str, rule_relative_path: str) -> str:
+    """Extract one rule's repository-instruction contract.
+
+    A rule reaches a Codex session through the fenced block under its
+    "Excerpt for repository-instruction sessions" heading, and this returns
+    that block's own text.
 
     Args:
-        rule_content: Canonical failure blast-radius rule text.
+        rule_content: Canonical rule text.
+        rule_relative_path: Repository-relative path of that rule, named in errors.
 
     Returns:
         The fenced repository-instruction excerpt with a trailing newline.
 
     Raises:
-        MaterializerError: If the canonical rule lacks the required excerpt.
+        MaterializerError: If the rule lacks a complete excerpt.
     """
     heading_start = rule_content.find(codex_instruction_section_heading)
     if heading_start < 0:
-        raise MaterializerError("failure blast-radius rule requires a Codex excerpt")
+        raise MaterializerError(f"{rule_relative_path} requires a Codex excerpt")
     fence_start = rule_content.find("```", heading_start)
     if fence_start < 0:
-        raise MaterializerError("failure blast-radius rule requires a Codex excerpt")
+        raise MaterializerError(f"{rule_relative_path} requires a Codex excerpt")
     content_start = rule_content.find(line_separator, fence_start)
     fence_end = rule_content.find(line_separator + "```", content_start + 1)
     if content_start < 0 or fence_end < 0:
-        raise MaterializerError("failure blast-radius rule requires a complete Codex excerpt")
+        raise MaterializerError(f"{rule_relative_path} requires a complete Codex excerpt")
     return rule_content[content_start + len(line_separator) : fence_end].rstrip() + line_separator
 
 
 def _build_codex_instruction_projection(config: MaterializerConfig) -> PlannedFile | None:
-    """Build the managed AGENTS.md projection when the canonical rule is present."""
-    source_path = config.source_root / failure_blast_radius_rule_relative_path
-    if not source_path.exists() and not _is_reparse_point(source_path):
+    """Build the managed AGENTS.md projection from every projected rule present."""
+    all_present_rules: list[tuple[str, str]] = []
+    for each_relative_path in codex_instruction_rule_relative_paths:
+        candidate_path = config.source_root / each_relative_path
+        if not candidate_path.exists() and not _is_reparse_point(candidate_path):
+            continue
+        source_path = _validated_source_file(config, each_relative_path, each_relative_path)
+        rule_content = source_path.read_text(encoding="utf-8")
+        all_present_rules.append(
+            (each_relative_path, render_codex_instruction_excerpt(rule_content, each_relative_path))
+        )
+    if not all_present_rules:
         return None
-    source_path = _validated_source_file(config, failure_blast_radius_rule_relative_path, "failure blast-radius rule")
-    rule_content = source_path.read_text(encoding="utf-8")
-    projected_content = render_codex_failure_blast_radius(rule_content)
+    projected_content = line_separator.join(
+        each_excerpt for _, each_excerpt in all_present_rules
+    )
     return PlannedFile(
-        failure_blast_radius_rule_relative_path,
+        codex_instruction_source_separator.join(
+            each_path for each_path, _ in all_present_rules
+        ),
         codex_instruction_target_path,
         projected_content,
         hash_content(projected_content),
@@ -987,7 +1004,7 @@ def discover_agents(config: MaterializerConfig) -> list[ClaudeAgent]:
         if _is_reparse_point(each_path):
             raise MaterializerError(f"source reparse point is not allowed: {each_path}")
         relative_source = each_path.relative_to(config.source_root).as_posix()
-        if relative_source == failure_blast_radius_rule_relative_path:
+        if relative_source in codex_instruction_rule_relative_paths:
             _validate_containment(config.source_root, each_path)
             continue
         _validate_containment(config.source_root, each_path)

package/scripts/contrast_framing.py

@@ -0,0 +1,101 @@
+"""Find contrast framing in authored prose.
+
+A contrast defines its subject against a rejected alternative, so the reader
+carries two readings where one would do.
+
+::
+
+    all_hits = find_contrast_framing("A diff regression, not shared code.")
+    ok:   all_hits == [(1, 18, "trailing-comma-not")]
+    flag: find_contrast_framing("The function runs more than 30 lines.") == []
+
+Code spans, fenced blocks, paths, and link targets are blanked before the
+patterns run, so an example quoted in backticks stays quiet. A blockquote line
+is skipped, since it carries someone else's words. A comma-``not`` match
+reports only when no bare ``not`` already sits earlier in the line, so a
+second one in a list stays quiet, and a list that opens with ``not`` keeps
+even its first comma quiet. The pattern list lives in the constants module
+beside this one, and the durable post linter reads the same list.
+"""
+
+from __future__ import annotations
+
+import re
+
+from banned_prose_words import prose_lines
+from dev_env_scripts_constants.contrast_framing_constants import (
+    ALL_CONTRAST_FRAMING_FORMS,
+    CONTRAST_FRAMING_MESSAGE_TEMPLATE,
+    CONTRAST_FRAMING_QUOTED_LINE_LIMIT,
+    ContrastFramingForm,
+)
+
+_BARE_NOT = re.compile(r"\bnot\b", re.IGNORECASE)
+
+
+def _reports(form: ContrastFramingForm, prose_line: str, match_start: int) -> bool:
+    if not form.repeats_as_a_list:
+        return True
+    return _BARE_NOT.search(prose_line[:match_start]) is None
+
+
+def _line_hits(line_number: int, prose_line: str) -> list[tuple[int, int, str]]:
+    if prose_line.lstrip().startswith(">"):
+        return []
+    return [
+        (line_number, each_match.start() + 1, each_form.name)
+        for each_form in ALL_CONTRAST_FRAMING_FORMS
+        for each_match in each_form.pattern.finditer(prose_line)
+        if _reports(each_form, prose_line, each_match.start())
+    ]
+
+
+def find_contrast_framing(document_text: str) -> list[tuple[int, int, str]]:
+    """Return each contrast-framing occurrence in authored prose.
+
+    Args:
+        document_text: Full document source.
+
+    Returns:
+        Ordered ``(line number, column, form name)`` triples, both 1-based.
+    """
+    all_hits: list[tuple[int, int, str]] = []
+    for each_line_number, each_prose_line in enumerate(prose_lines(document_text), 1):
+        all_hits.extend(_line_hits(each_line_number, each_prose_line))
+    return sorted(all_hits)
+
+
+def form_named(form_name: str) -> ContrastFramingForm:
+    """Return the contrast form carrying one name.
+
+    Args:
+        form_name: Name reported by ``find_contrast_framing``.
+
+    Returns:
+        The matching form.
+
+    Raises:
+        KeyError: If no form carries that name.
+    """
+    for each_form in ALL_CONTRAST_FRAMING_FORMS:
+        if each_form.name == form_name:
+            return each_form
+    raise KeyError(form_name)
+
+
+def describe_contrast_framing(source_line: str, form_name: str) -> str:
+    """Return the reader-facing message for one occurrence.
+
+    Args:
+        source_line: The document line the occurrence sits on.
+        form_name: Name of the form that matched.
+
+    Returns:
+        The message naming the form, the line it sits on, and the fix.
+    """
+    matched_form = form_named(form_name)
+    return CONTRAST_FRAMING_MESSAGE_TEMPLATE.format(
+        name=form_name,
+        text=source_line.strip()[:CONTRAST_FRAMING_QUOTED_LINE_LIMIT],
+        guidance=matched_form.guidance,
+    )

package/scripts/dev_env_scripts_constants/agent_merge_check_constants.py

@@ -0,0 +1,121 @@
+"""Named constants for agent_merge_check, the agent merge check."""
+
+from __future__ import annotations
+
+GITHUB_API_ROOT = "https://api.github.com"
+GITHUB_GRAPHQL_ENDPOINT = "https://api.github.com/graphql"
+PULL_REQUEST_ENDPOINT_TEMPLATE = "{api_root}/repos/{slug}/pulls/{number}"
+REVIEW_THREADS_ENDPOINT_TEMPLATE = (
+    "{api_root}/repos/{slug}/pulls/{number}/ccr/review_threads"
+)
+ACCEPT_HEADER = "Accept"
+GITHUB_ACCEPT_TYPE = "application/vnd.github+json"
+AUTHORIZATION_HEADER = "Authorization"
+BEARER_PREFIX = "Bearer "
+CONTENT_TYPE_HEADER = "Content-Type"
+JSON_CONTENT_TYPE = "application/json"
+UTF8_ENCODING = "utf-8"
+REQUEST_TIMEOUT_SECONDS = 30
+
+ALL_TOKEN_ENVIRONMENT_VARIABLES = ("GH_TOKEN", "GITHUB_TOKEN")
+
+DRAFT_KEY = "draft"
+MERGEABLE_STATE_KEY = "mergeable_state"
+NUMBER_KEY = "number"
+TITLE_KEY = "title"
+HEAD_KEY = "head"
+SHA_KEY = "sha"
+
+MERGEABLE_STATE_CLEAN = "clean"
+MERGEABLE_STATE_BEHIND = "behind"
+MERGEABLE_STATE_DIRTY = "dirty"
+MERGEABLE_STATE_BLOCKED = "blocked"
+MERGEABLE_STATE_UNSTABLE = "unstable"
+MERGEABLE_STATE_UNKNOWN = "unknown"
+SETTLE_ATTEMPT_COUNT = 5
+SETTLE_WAIT_SECONDS = 3
+
+DRAFT_HOLD_REASON = (
+    "The pull request is a draft, so it carries no verdict to merge on. "
+    "Mark it ready once its checks pass."
+)
+BEHIND_HOLD_REASON = (
+    "The head is behind the base branch and the branch rule requires an "
+    "up-to-date head. Merge the base branch into this one and push."
+)
+DIRTY_HOLD_REASON = (
+    "The head conflicts with the base branch. Merge the base branch into "
+    "this one, resolve the conflict, and push."
+)
+BLOCKED_HOLD_REASON = (
+    "A required status check is not passing on this head. Read the failing "
+    "check, fix it, and push."
+)
+UNSTABLE_HOLD_REASON = (
+    "A check on this head is failing or still running. Wait for it, and fix "
+    "it when it comes back red."
+)
+ALL_HOLD_REASONS_BY_STATE = {
+    MERGEABLE_STATE_BEHIND: BEHIND_HOLD_REASON,
+    MERGEABLE_STATE_DIRTY: DIRTY_HOLD_REASON,
+    MERGEABLE_STATE_BLOCKED: BLOCKED_HOLD_REASON,
+    MERGEABLE_STATE_UNSTABLE: UNSTABLE_HOLD_REASON,
+}
+UNKNOWN_STATE_HOLD_TEMPLATE = (
+    "GitHub reports the merge state as {state}, which this check does not "
+    "treat as ready. Read the pull request page."
+)
+UNRESOLVED_THREADS_HOLD_TEMPLATE = (
+    "{count} review thread(s) are open. Answer each one and resolve it."
+)
+
+MERGE_VERDICT_LABEL = "MERGE"
+HOLD_VERDICT_LABEL = "HOLD"
+VERDICT_LINE_TEMPLATE = "{label} {slug}#{number} {sha} :: {detail}"
+SHORT_SHA_LENGTH = 7
+READY_DETAIL = "green, no open review thread, ready for the agent to merge"
+
+MERGE_EXIT_CODE = 0
+HOLD_EXIT_CODE = 1
+ERROR_EXIT_CODE = 2
+
+NO_SIGN_IN_MESSAGE = "No GitHub token in the environment. Set GH_TOKEN or GITHUB_TOKEN."
+SLUG_SEPARATOR = "/"
+SLUG_ARGUMENT_HELP = "Repository as owner/name, such as jl-cmd/claude-dev-env."
+NUMBER_ARGUMENT_HELP = "Pull request number."
+COMMAND_DESCRIPTION = (
+    "Report whether a pull request is ready for the agent that drives it to merge it."
+)
+
+REVIEW_THREAD_PAGE_SIZE = 100
+UNRESOLVED_THREAD_QUERY = """
+query($owner: String!, $name: String!, $number: Int!, $pageSize: Int!) {
+  repository(owner: $owner, name: $name) {
+    pullRequest(number: $number) {
+      reviewThreads(first: $pageSize) {
+        nodes { isResolved isOutdated }
+      }
+    }
+  }
+}
+"""
+QUERY_KEY = "query"
+VARIABLES_KEY = "variables"
+OWNER_VARIABLE = "owner"
+NAME_VARIABLE = "name"
+NUMBER_VARIABLE = "number"
+PAGE_SIZE_VARIABLE = "pageSize"
+DATA_KEY = "data"
+REPOSITORY_KEY = "repository"
+PULL_REQUEST_KEY = "pullRequest"
+REVIEW_THREADS_KEY = "reviewThreads"
+NODES_KEY = "nodes"
+ALL_THREAD_NODE_KEYS = (
+    DATA_KEY,
+    REPOSITORY_KEY,
+    PULL_REQUEST_KEY,
+    REVIEW_THREADS_KEY,
+    NODES_KEY,
+)
+ALL_RESOLVED_KEYS = ("isResolved", "is_resolved", "resolved")
+ALL_OUTDATED_KEYS = ("isOutdated", "is_outdated", "outdated")

package/scripts/dev_env_scripts_constants/claude_account_constants.py

@@ -0,0 +1,166 @@
+"""Named constants for the second Claude account: its profile, launcher, and picker.
+
+The profile sync links the main Claude home into a second account's profile
+directory. The launcher points Claude at that profile. The picker reads both
+accounts' usage meters and names the account a job runs on, protecting the
+main account so its owner never runs out.
+"""
+
+from __future__ import annotations
+
+from datetime import timedelta
+
+MAIN_CLAUDE_HOME_DIRECTORY_NAME: str = ".claude"
+"""Directory under the user home that holds the main account's Claude home."""
+
+PROFILES_ROOT_DIRECTORY_NAME: str = ".claude-profiles"
+"""Directory under the user home that holds named Claude profiles."""
+
+PROFILES_ROOT_ENVIRONMENT_VARIABLE: str = "LLM_SETTINGS_PROFILES_ROOT"
+"""Environment variable that relocates the profiles root."""
+
+SECOND_ACCOUNT_PROFILE_NAME: str = "ev"
+"""Profile directory name the second account signs in under."""
+
+ALL_LAUNCHER_DIRECTORY_RELATIVE_PARTS: tuple[str, ...] = (".local", "bin")
+"""Path parts under the user home of the directory on PATH that holds the launcher."""
+
+LAUNCHER_FILE_NAME: str = "claude-ev.cmd"
+"""File name of the launcher that runs Claude under the second account."""
+
+LAUNCHER_TEXT_TEMPLATE: str = (
+    "@echo off\r\n"
+    "setlocal\r\n"
+    'set "CLAUDE_CONFIG_DIR={profile_home}"\r\n'
+    "claude %*\r\n"
+    "exit /b %ERRORLEVEL%\r\n"
+)
+"""Launcher body: point Claude at the profile and pass every argument through."""
+
+LAUNCHER_REPLACED_SUFFIX: str = ".replaced-"
+"""Suffix, before the run time, of an older launcher the sync moved aside."""
+
+ALL_WINDOWS_JUNCTION_COMMAND_PREFIX: tuple[str, ...] = ("cmd", "/c", "mklink", "/J")
+"""Command that links a directory as a junction on Windows, before link and target."""
+
+CREDENTIALS_FILE_NAME: str = ".credentials.json"
+"""File in a Claude home that holds that account's sign-in."""
+
+ALL_ACCOUNT_LOCAL_NAMES: frozenset[str] = frozenset(
+    {
+        ".credentials.json",
+        "projects",
+        "sessions",
+        "session-env",
+        "shell-snapshots",
+        "todos",
+        "statsig",
+        "file-history",
+        "history.jsonl",
+        "ide",
+        "debug",
+        "telemetry",
+        "logs",
+        "tasks",
+        "plans",
+        "backups",
+        "cache",
+        "paste-cache",
+        "stats-cache.json",
+    }
+)
+"""Top-level Claude home entries that belong to one account and are never linked."""
+
+ALL_ACCOUNT_LOCAL_NAME_PREFIXES: tuple[str, ...] = (".claude.json", ".credentials.json")
+"""Name prefixes of per-account state files, covering the global config and its backups."""
+
+REPLACED_DIRECTORY_NAME: str = ".replaced"
+"""Profile subdirectory that holds entries the sync moved aside, one folder per run."""
+
+REPLACED_STAMP_FORMAT: str = "%Y%m%dT%H%M%SZ"
+"""UTC time format naming each run's folder under the replaced directory."""
+
+WINDOWS_EXTENDED_PATH_PREFIX: str = "\\\\?\\"
+"""Prefix Windows puts on a junction target that the link comparison strips."""
+
+WINDOWS_OS_NAME: str = "nt"
+"""Value of ``os.name`` on Windows, where directories link as junctions."""
+
+TEXT_ENCODING: str = "utf-8"
+"""Encoding for the launcher file and the JSON reports."""
+
+MAIN_SPEND_WINDOW: timedelta = timedelta(hours=24)
+"""Main takes jobs only when its weekly window resets within this span."""
+
+MAIN_WEEKLY_USED_CEILING_PERCENT: float = 90.0
+"""Main takes jobs only while its weekly use is under this percent."""
+
+MAIN_SESSION_USED_CEILING_PERCENT: float = 50.0
+"""Main takes jobs only while its 5-hour use is under this percent."""
+
+SECOND_WEEKLY_USED_CEILING_PERCENT: float = 95.0
+"""The second account takes jobs while its weekly use is under this percent."""
+
+SECOND_SESSION_USED_CEILING_PERCENT: float = 90.0
+"""The second account takes jobs while its 5-hour use is under this percent."""
+
+FULL_PERCENT: float = 100.0
+"""Percent scale ceiling, so remaining is this minus used."""
+
+SECONDS_PER_HOUR: int = 3600
+"""Seconds in one hour, for reason text that names hours until a reset."""
+
+CHOICE_MAIN: str = "main"
+"""Picker answer: run the job on the main account."""
+
+CHOICE_SECOND: str = "second"
+"""Picker answer: run the job on the second account."""
+
+CHOICE_WAIT: str = "wait"
+"""Picker answer: neither account has room, so the job waits."""
+
+REASON_MAIN_EXPIRING_TEMPLATE: str = (
+    "main week resets in {hours_until_reset} hours with {remaining_percent:.0f}% left"
+)
+"""Reason when main spends leftover usage that expires soon."""
+
+REASON_SECOND_HAS_ROOM_TEMPLATE: str = (
+    "second account has {weekly_remaining_percent:.0f}% of its week"
+    " and {session_remaining_percent:.0f}% of its 5-hour window left"
+)
+"""Reason when the second account takes the job."""
+
+REASON_SECOND_UNREAD: str = (
+    "second account meter unreadable; its own run refreshes the sign-in"
+)
+"""Reason when the second account's meter cannot be read and it takes the job anyway."""
+
+REASON_WAIT_TEMPLATE: str = (
+    "second account is at {weekly_used_percent:.0f}% of its week"
+    " and {session_used_percent:.0f}% of its 5-hour window; next reset {next_reset}"
+)
+"""Reason when neither account has room."""
+
+UNKNOWN_RESET_TEXT: str = "unknown"
+"""Reset text when the blocking meter carries no reset time."""
+
+JSON_ACCOUNT_KEY: str = "account"
+"""Picker JSON key naming the chosen account."""
+
+JSON_CONFIG_DIRECTORY_KEY: str = "config_dir"
+"""Picker JSON key naming the Claude home the chosen account runs under."""
+
+JSON_REASON_KEY: str = "reason"
+"""Picker JSON key carrying the plain-words reason for the choice."""
+
+JSON_LINKED_KEY: str = "linked"
+"""Sync JSON key listing entries the run linked."""
+
+JSON_MOVED_ASIDE_KEY: str = "moved_aside"
+"""Sync JSON key listing entries the run moved into the replaced directory."""
+
+JSON_UNLINKED_KEY: str = "unlinked"
+"""Sync JSON key listing links the run removed because main no longer has the entry."""
+
+JSON_LAUNCHER_KEY: str = "launcher"
+"""Sync JSON key naming the launcher file the run wrote or confirmed."""

package/scripts/dev_env_scripts_constants/contrast_framing_constants.py

@@ -0,0 +1,82 @@
+"""Constants for the contrast-framing detector.
+
+Each form names one shape a sentence takes when it defines its subject
+against a rejected reading::
+
+    "a diff regression, not shared code"   -> trailing-comma-not
+    "park it rather than fix it"           -> substitution-rather-than
+    "precision matters more than coverage" -> comparative-ranking
+    ok: "the function runs more than 30 lines"
+
+The rule file ``rules/no-contrast-framing.md`` carries one row for each name
+here, and a test holds the two in step.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class ContrastFramingForm:
+    """One banned contrast form and the pattern that finds it."""
+
+    name: str
+    pattern: re.Pattern[str]
+    guidance: str
+    repeats_as_a_list: bool = False
+
+
+ALL_CONTRAST_FRAMING_FORMS: tuple[ContrastFramingForm, ...] = (
+    ContrastFramingForm(
+        "trailing-comma-not",
+        re.compile(r",\s+not\s+[\w\"'`(]", re.IGNORECASE),
+        "Drop the clause after the comma and state what is true.",
+        repeats_as_a_list=True,
+    ),
+    ContrastFramingForm(
+        "corrective-it-is-not",
+        re.compile(
+            r"\b(?:it|that|this)(?:'s|\s+is|\s+was)\s+not\b[^.!?]*?,\s*"
+            r"(?:it|that|this)(?:'s|\s+is|\s+was)\b",
+            re.IGNORECASE,
+        ),
+        "State what it is and leave the rejected reading out.",
+    ),
+    ContrastFramingForm(
+        "substitution-rather-than",
+        re.compile(r"\brather than\b", re.IGNORECASE),
+        "Name the thing you chose and stop.",
+    ),
+    ContrastFramingForm(
+        "additive-not-just",
+        re.compile(r"\bnot (?:just|only|merely|simply)\b", re.IGNORECASE),
+        "Say the point the sentence is building toward.",
+    ),
+    ContrastFramingForm(
+        "comparative-ranking",
+        re.compile(
+            r"\b(?:matters?|counts?|helps?|weighs?)\s+more\s+than\b"
+            r"|\b(?:more|less)\s+(?:important|useful|valuable)\s+than\b"
+            r"|\bmore\s+than\s+(?:trying|attempting|hoping)\b",
+            re.IGNORECASE,
+        ),
+        "State the thing you want. Leave the ranking out.",
+    ),
+    ContrastFramingForm(
+        "substitution-as-opposed-to",
+        re.compile(r"\bas opposed to\b", re.IGNORECASE),
+        "Name the thing you chose and stop.",
+    ),
+)
+
+CONTRAST_FRAMING_MESSAGE_TEMPLATE: str = (
+    'Contrast framing ({name}): "{text}". {guidance}'
+)
+
+CONTRAST_FRAMING_QUOTED_LINE_LIMIT: int = 120
+
+CONTRAST_FRAMING_FINDING_CODE: str = "contrast-framing"
+
+CONTRAST_FRAMING_RULE_DOCUMENT: str = "rules/no-contrast-framing.md"

package/scripts/dev_env_scripts_constants/merge_gate_check_constants.py

@@ -0,0 +1,23 @@
+"""Names and values ``merge_gate_checks.py`` reads a merge policy with.
+
+The fenced block marker and the ruleset field names describe a document and a
+GitHub payload that both live outside this package, so they sit here rather
+than inside the module that reads them.
+"""
+
+REQUIRED_CHECK_BLOCK_INFO_STRING: str = "required-status-checks"
+FENCE_MARKER: str = "```"
+RULESET_API_TEMPLATE: str = (
+    "https://api.github.com/repos/{repository}/rules/branches/{branch}"
+)
+RULESET_API_ACCEPT_HEADER: str = "application/vnd.github+json"
+RULESET_REQUEST_TIMEOUT_SECONDS: int = 30
+REQUIRED_STATUS_CHECKS_RULE_TYPE: str = "required_status_checks"
+RULE_TYPE_KEY: str = "type"
+RULE_PARAMETERS_KEY: str = "parameters"
+RULE_CONTEXT_KEY: str = "context"
+ALL_GITHUB_TOKEN_VARIABLES: tuple[str, ...] = ("GITHUB_TOKEN", "GH_TOKEN")
+MERGE_GATE_CLEAN_EXIT_CODE: int = 0
+MERGE_GATE_MISSING_CHECK_EXIT_CODE: int = 1
+JSON_INDENT_WIDTH: int = 2
+UTF8_ENCODING: str = "utf-8"