claude-dev-env 2.16.0 → 2.18.0

package/_shared/pr-loop/scripts/fetch_copilot_reviews.py

@@ -0,0 +1,134 @@
+"""Fetch GitHub Copilot reviews for a pull request, newest first.
+
+Usage:
+  python scripts/fetch_copilot_reviews.py --owner <O> --repo <R> --pr-number <N>
+
+Output: JSON array of Copilot reviews to stdout, each with id, state, body,
+commit_id, submitted_at, and html_url.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+_pr_converge_dir = Path(__file__).absolute().parent.parent
+if str(_pr_converge_dir) not in sys.path:
+    sys.path.insert(0, str(_pr_converge_dir))
+
+from pr_converge_skill_constants.constants import (
+    COPILOT_LOGIN_FILTER_SUBSTRING,
+    GH_REVIEWS_PATH_TEMPLATE,
+    REVIEWS_PER_PAGE,
+)
+
+
+def fetch_copilot_reviews(
+    *, owner: str, repo: str, number: int
+) -> list[dict[str, object]]:
+    """Return Copilot reviews for a PR, newest first.
+
+    Args:
+        owner: GitHub repository owner.
+        repo: GitHub repository name.
+        number: Pull request number.
+
+    Returns:
+        List of Copilot review entries sorted by submitted_at descending.
+
+    Raises:
+        SystemExit: When the gh CLI call fails.
+    """
+    endpoint_path = GH_REVIEWS_PATH_TEMPLATE.format(
+        owner=owner, repo=repo, number=number
+    )
+    completed_process = subprocess.run(
+        [
+            "gh", "api",
+            f"{endpoint_path}?per_page={REVIEWS_PER_PAGE}",
+            "--paginate", "--slurp",
+        ],
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+        errors="replace",
+        check=False,
+    )
+    if completed_process.returncode != 0:
+        print(f"gh api error: {completed_process.stderr}", file=sys.stderr)
+        raise SystemExit(1)
+    raw_output: object = json.loads(completed_process.stdout)
+    if not isinstance(raw_output, list):
+        return []
+    all_pages: list[list[dict[str, object]]] = [
+        each_page for each_page in raw_output if isinstance(each_page, list)
+    ]
+    all_flat: list[dict[str, object]] = [
+        each_item for each_page in all_pages for each_item in each_page
+    ]
+    copilot_reviews: list[dict[str, object]] = []
+    for each_review in all_flat:
+        user_object: object = each_review.get("user")
+        if not isinstance(user_object, dict):
+            continue
+        raw_login: object = user_object.get("login")
+        if not isinstance(raw_login, str):
+            continue
+        if COPILOT_LOGIN_FILTER_SUBSTRING not in raw_login.lower():
+            continue
+        copilot_reviews.append({
+            "id": each_review.get("id"),
+            "state": each_review.get("state"),
+            "body": each_review.get("body"),
+            "commit_id": each_review.get("commit_id"),
+            "submitted_at": each_review.get("submitted_at"),
+            "html_url": each_review.get("html_url"),
+        })
+    copilot_reviews.sort(
+        key=lambda each_review: str(each_review.get("submitted_at", "")),
+        reverse=True,
+    )
+    return copilot_reviews
+
+
+def parse_arguments(all_argv: list[str]) -> argparse.Namespace:
+    """Parse command-line arguments.
+
+    Args:
+        all_argv: Command-line argument list.
+
+    Returns:
+        Parsed namespace with owner, repo, and number.
+    """
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--owner", required=True, help="GitHub repository owner")
+    parser.add_argument("--repo", required=True, help="GitHub repository name")
+    parser.add_argument("--pr-number", required=True, type=int, help="Pull request number")
+    return parser.parse_args(all_argv)
+
+
+def main(all_arguments: list[str]) -> int:
+    """Entry point for fetch_copilot_reviews.
+
+    Args:
+        all_arguments: Command-line arguments.
+
+    Returns:
+        0 on success, 1 on error.
+    """
+    arguments = parse_arguments(all_arguments)
+    all_reviews = fetch_copilot_reviews(
+        owner=arguments.owner,
+        repo=arguments.repo,
+        number=getattr(arguments, "pr_number"),
+    )
+    json.dump(all_reviews, sys.stdout)
+    sys.stdout.write("\n")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(sys.argv[1:]))

package/_shared/pr-loop/scripts/fixtures/auth_failure_synthetic.txt

@@ -0,0 +1 @@
+Error: unauthorized (401). Login required before running Codex review.

package/_shared/pr-loop/scripts/fixtures/config_load_failure_v0.125.0.txt

@@ -0,0 +1 @@
+Error loading config.toml: unknown variant 'default', expected 'fast' or 'flex' in 'service_tier'

package/_shared/pr-loop/scripts/fixtures/freeform_findings_v0.144.3.txt

@@ -0,0 +1,6 @@
+The change removes required empty-input handling, causing a deterministic exception and breaking an existing test.
+
+Review comment:
+
+- [P1] Restore empty-input handling — src/stats.py:2-2
+  When average([]) is called, including by the existing test_empty_input_returns_zero, this line divides by zero and raises ZeroDivisionError instead of returning 0.0. This directly breaks the established contract and test suite.

package/_shared/pr-loop/scripts/fixtures/model_rejection_v0.125.0.jsonl

@@ -0,0 +1,5 @@
+{"type":"thread.started","thread_id":"thread-fixture-model"}
+{"type":"turn.started"}
+{"type":"error","message":"{\"error\":{\"type\":\"invalid_request_error\",\"code\":null,\"message\":\"The 'o3' model is not supported when using Codex with a ChatGPT account.\",\"param\":null},\"status\":400}"}
+{"type":"item.completed","item":{"type":"agent_message","text":"Review was interrupted. Please try again."}}
+{"type":"turn.failed","error":{"message":"The 'o3' model is not supported when using Codex with a ChatGPT account. The 'o3' model requires a newer version of Codex."}}

package/_shared/pr-loop/scripts/fixtures/structured_findings.txt

@@ -0,0 +1,13 @@
+Review complete with one finding.
+
+```json
+[
+  {
+    "title": "Restore empty-input handling",
+    "priority": "P1",
+    "file": "src/stats.py",
+    "line_range": "2-2",
+    "body": "Divides by zero on empty input instead of returning 0.0."
+  }
+]
+```

package/_shared/pr-loop/scripts/fixtures/success_stream_v0.144.3.jsonl

@@ -0,0 +1,6 @@
+{"type":"thread.started","thread_id":"thread-fixture-success"}
+{"type":"turn.started"}
+{"type":"item.started","item":{"id":"item_0","type":"command_execution","command":"git status --short","status":"in_progress"}}
+{"type":"item.completed","item":{"id":"item_0","type":"command_execution","command":"git status --short","exit_code":0,"status":"completed"}}
+{"type":"item.completed","item":{"type":"agent_message","text":"No issues found.\n\n```json\n[]\n```"}}
+{"type":"turn.completed","usage":{"input_tokens":12,"cached_input_tokens":0,"output_tokens":6,"reasoning_output_tokens":0}}

package/_shared/pr-loop/scripts/fixtures/unknown_failure_synthetic.txt

@@ -0,0 +1 @@
+Error: unexpected internal failure while running review.

package/_shared/pr-loop/scripts/fixtures/usage_limit_synthetic.txt

@@ -0,0 +1 @@
+Error: rate limit exceeded. Too many requests (429). Quota and credits exhausted; retry later.

package/_shared/pr-loop/scripts/parse_codex_findings.py

@@ -0,0 +1,207 @@
+"""Parse Codex reviewer text into stable internal finding records.
+
+::
+
+    all_findings = parse_codex_findings(reviewer_text)
+    all_findings[0].title      # structured or freeform title
+    all_findings[0].structured # True only for fenced JSON findings
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from dataclasses import dataclass
+
+from codex_review_scripts_constants.findings_constants import (
+    EMPTY_STRING,
+    FENCED_JSON_BLOCK_PATTERN,
+    FINDING_KEY_BODY,
+    FINDING_KEY_FILE,
+    FINDING_KEY_LINE_RANGE,
+    FINDING_KEY_PRIORITY,
+    FINDING_KEY_TITLE,
+    FREEFORM_BULLET_PREFIX,
+    FREEFORM_FINDING_LINE_PATTERN,
+    NEWLINE,
+)
+
+
+@dataclass(frozen=True)
+class CodexFinding:
+    """One review finding in the skill's stable internal shape.
+
+    ::
+
+        CodexFinding(
+            title="Restore empty-input handling",
+            priority="P1",
+            file="src/stats.py",
+            line_range="2-2",
+            body="Divides by zero on empty input.",
+            structured=True,
+        )
+
+    Attributes:
+        title: Short finding title.
+        priority: Priority tag such as ``P1``.
+        file: Path the finding points at.
+        line_range: Inclusive line span as ``start-end``.
+        body: Explanation text for the finding.
+        structured: True when the finding came from fenced JSON.
+    """
+
+    title: str
+    priority: str
+    file: str
+    line_range: str
+    body: str
+    structured: bool
+
+
+def _string_field(all_finding_fields: dict[str, object], field_name: str) -> str:
+    field_payload = all_finding_fields.get(field_name, EMPTY_STRING)
+    if isinstance(field_payload, str):
+        return field_payload
+    return EMPTY_STRING
+
+
+def _finding_from_structured_fields(
+    all_finding_fields: dict[str, object],
+) -> CodexFinding:
+    return CodexFinding(
+        title=_string_field(all_finding_fields, FINDING_KEY_TITLE),
+        priority=_string_field(all_finding_fields, FINDING_KEY_PRIORITY),
+        file=_string_field(all_finding_fields, FINDING_KEY_FILE),
+        line_range=_string_field(all_finding_fields, FINDING_KEY_LINE_RANGE),
+        body=_string_field(all_finding_fields, FINDING_KEY_BODY),
+        structured=True,
+    )
+
+
+def _has_usable_structured_fields(finding: CodexFinding) -> bool:
+    has_title = bool(finding.title.strip())
+    has_body = bool(finding.body.strip())
+    return has_title or has_body
+
+
+def _try_parse_structured_findings(reviewer_text: str) -> list[CodexFinding] | None:
+    fenced_json_block = re.compile(
+        FENCED_JSON_BLOCK_PATTERN,
+        re.DOTALL | re.IGNORECASE,
+    )
+    for each_match in fenced_json_block.finditer(reviewer_text):
+        block_body = each_match.group(1).strip()
+        try:
+            parsed_payload = json.loads(block_body)
+        except json.JSONDecodeError:
+            continue
+        if not isinstance(parsed_payload, list):
+            continue
+        if not parsed_payload:
+            return []
+        all_findings: list[CodexFinding] = []
+        for each_entry in parsed_payload:
+            if not isinstance(each_entry, dict):
+                continue
+            candidate_finding = _finding_from_structured_fields(each_entry)
+            if not _has_usable_structured_fields(candidate_finding):
+                continue
+            all_findings.append(candidate_finding)
+        if all_findings:
+            return all_findings
+    return None
+
+
+def _collect_freeform_body(
+    all_lines: list[str],
+    *,
+    from_index: int,
+) -> tuple[str, int]:
+    all_body_lines: list[str] = []
+    current_index = from_index
+    while current_index < len(all_lines):
+        current_line = all_lines[current_index]
+        stripped_line = current_line.strip()
+        if stripped_line.startswith(FREEFORM_BULLET_PREFIX):
+            break
+        if stripped_line:
+            all_body_lines.append(stripped_line)
+        current_index += 1
+    return NEWLINE.join(all_body_lines), current_index
+
+
+def _parse_freeform_findings(reviewer_text: str) -> list[CodexFinding]:
+    freeform_finding_line = re.compile(FREEFORM_FINDING_LINE_PATTERN)
+    all_lines = reviewer_text.splitlines()
+    all_findings: list[CodexFinding] = []
+    line_index = 0
+    while line_index < len(all_lines):
+        line_match = freeform_finding_line.match(all_lines[line_index].strip())
+        if line_match is None:
+            line_index += 1
+            continue
+        body_text, next_index = _collect_freeform_body(
+            all_lines,
+            from_index=line_index + 1,
+        )
+        all_findings.append(
+            CodexFinding(
+                title=line_match.group("title").strip(),
+                priority=line_match.group("priority"),
+                file=line_match.group("file_path").strip(),
+                line_range=line_match.group("line_range"),
+                body=body_text,
+                structured=False,
+            )
+        )
+        line_index = next_index
+    return all_findings
+
+
+def _floor_finding(reviewer_text: str) -> list[CodexFinding]:
+    return [
+        CodexFinding(
+            title=EMPTY_STRING,
+            priority=EMPTY_STRING,
+            file=EMPTY_STRING,
+            line_range=EMPTY_STRING,
+            body=reviewer_text,
+            structured=False,
+        )
+    ]
+
+
+def parse_codex_findings(reviewer_text: str) -> list[CodexFinding]:
+    """Parse reviewer text into findings; never drop non-empty text.
+
+    ::
+
+        parse_codex_findings("```json\\n[]\\n```")  # ok: []
+        parse_codex_findings("loose note")          # ok: one unstructured finding
+        parse_codex_findings('```json\\n["x"]\\n```\\n- [P1] T — a.py:1-1')
+        # ok: freeform finding (non-dict JSON list is not structured clean)
+
+    Tries fenced JSON first (the custom-instructions contract). An empty
+    array ``[]`` is structured clean. A non-empty array that yields no
+    usable object findings (non-dicts, empty shells, wrong keys) is not
+    accepted; freeform and floor paths run instead. Freeform is the
+    ``- [P1] title — path:start-end`` shape. Floor carries the raw text.
+
+    Args:
+        reviewer_text: Agent message text from a completed Codex review.
+
+    Returns:
+        Parsed findings. Empty only when the text is blank, or when a
+        fenced structured payload is exactly the empty array ``[]``.
+        Non-blank text never returns empty for any other structured shape.
+    """
+    if not reviewer_text.strip():
+        return []
+    maybe_structured = _try_parse_structured_findings(reviewer_text)
+    if maybe_structured is not None:
+        return maybe_structured
+    all_freeform_findings = _parse_freeform_findings(reviewer_text)
+    if all_freeform_findings:
+        return all_freeform_findings
+    return _floor_finding(reviewer_text)

package/_shared/pr-loop/scripts/post_fix_reply.py

@@ -0,0 +1,168 @@
+"""Post a fix reply to a pull request comment thread or as a general PR comment.
+
+Usage:
+  # Reply to an inline comment thread
+  python scripts/post_fix_reply.py --owner <O> --repo <R> --pr-number <N> \
+      --body "Fixed in <sha>" --in-reply-to <COMMENT_ID>
+
+    python scripts/post_fix_reply.py --owner <O> --repo <R> --pr-number <N> \
+      --body "Your reply text"
+
+Exit codes:
+  0 — reply posted successfully
+  2 — gh CLI error
+"""
+
+from __future__ import annotations
+
+import argparse
+import subprocess
+import sys
+from pathlib import Path
+
+_pr_converge_dir = Path(__file__).absolute().parent.parent
+if str(_pr_converge_dir) not in sys.path:
+    sys.path.insert(0, str(_pr_converge_dir))
+
+from pr_converge_skill_constants.constants import (
+    EXIT_CODE_GH_ERROR,
+    GH_INLINE_COMMENT_REPLY_PATH_TEMPLATE,
+    GH_ISSUE_COMMENT_CREATE_PATH_TEMPLATE,
+)
+
+
+def post_inline_reply(
+    *,
+    owner: str,
+    repo: str,
+    number: int,
+    body: str,
+    in_reply_to: int,
+) -> int:
+    """Post a reply to an inline pull request comment thread.
+
+    Args:
+        owner: GitHub repository owner.
+        repo: GitHub repository name.
+        number: Pull request number.
+        body: Reply body text.
+        in_reply_to: The comment ID to reply to.
+
+    Returns:
+        0 on success, EXIT_CODE_GH_ERROR on failure.
+    """
+    endpoint_path = GH_INLINE_COMMENT_REPLY_PATH_TEMPLATE.format(
+        owner=owner, repo=repo, number=number, comment_id=in_reply_to
+    )
+    completed_process = subprocess.run(
+        [
+            "gh",
+            "api",
+            endpoint_path,
+            "-f",
+            f"body={body}",
+        ],
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+        errors="replace",
+        check=False,
+    )
+    if completed_process.returncode != 0:
+        print(f"gh api error: {completed_process.stderr}", file=sys.stderr)
+        return EXIT_CODE_GH_ERROR
+    return 0
+
+
+def post_pr_comment(
+    *,
+    owner: str,
+    repo: str,
+    number: int,
+    body: str,
+) -> int:
+    """Post a general PR comment.
+
+    Args:
+        owner: GitHub repository owner.
+        repo: GitHub repository name.
+        number: Pull request number (issue_number for PR comments).
+        body: Comment body text.
+
+    Returns:
+        0 on success, EXIT_CODE_GH_ERROR on failure.
+    """
+    endpoint_path = GH_ISSUE_COMMENT_CREATE_PATH_TEMPLATE.format(
+        owner=owner, repo=repo, number=number
+    )
+    completed_process = subprocess.run(
+        [
+            "gh",
+            "api",
+            endpoint_path,
+            "-f",
+            f"body={body}",
+        ],
+        capture_output=True,
+        text=True,
+        encoding="utf-8",
+        errors="replace",
+        check=False,
+    )
+    if completed_process.returncode != 0:
+        print(f"gh api error: {completed_process.stderr}", file=sys.stderr)
+        return EXIT_CODE_GH_ERROR
+    return 0
+
+
+def parse_arguments(all_argv: list[str]) -> argparse.Namespace:
+    """Parse command-line arguments.
+
+    Args:
+        all_argv: Command-line argument list.
+
+    Returns:
+        Parsed namespace with owner, repo, number, body, and in_reply_to.
+    """
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--owner", required=True, help="GitHub repository owner")
+    parser.add_argument("--repo", required=True, help="GitHub repository name")
+    parser.add_argument("--pr-number", required=True, type=int, help="Pull request number")
+    parser.add_argument("--body", required=True, help="Reply body text")
+    parser.add_argument(
+        "--in-reply-to",
+        type=int,
+        default=None,
+        help="Comment ID to reply to (omit for general PR comment)",
+    )
+    return parser.parse_args(all_argv)
+
+
+def main(all_arguments: list[str]) -> int:
+    """Entry point for post_fix_reply.
+
+    Args:
+        all_arguments: Command-line arguments.
+
+    Returns:
+        0 on success, EXIT_CODE_GH_ERROR on failure.
+    """
+    arguments = parse_arguments(all_arguments)
+    if arguments.in_reply_to is not None:
+        return post_inline_reply(
+            owner=arguments.owner,
+            repo=arguments.repo,
+            number=getattr(arguments, "pr_number"),
+            body=arguments.body,
+            in_reply_to=arguments.in_reply_to,
+        )
+    return post_pr_comment(
+        owner=arguments.owner,
+        repo=arguments.repo,
+        number=getattr(arguments, "pr_number"),
+        body=arguments.body,
+    )
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(sys.argv[1:]))

package/_shared/pr-loop/scripts/pr_converge_scripts_constants/.claude/CLAUDE.md

@@ -0,0 +1 @@
+@../AGENTS.md

package/_shared/pr-loop/scripts/pr_converge_scripts_constants/AGENTS.md

@@ -0,0 +1,18 @@
+# pr_converge_scripts_constants
+
+Constants module for shared PR-loop convergence scripts. Re-exports all runtime/API constants from `pr_converge_skill_constants` and adds script-specific constants for CLI arguments, markdown patterns, and reflow settings.
+
+## Key files
+
+| File | Purpose |
+|---|---|
+| `__init__.py` | Package marker |
+| `pr_converge_constants.py` | Re-exports all constants from `pr_converge_skill_constants.constants` plus adds script-specific values |
+| `reflow_skill_md_constants.py` | Constants for `reflow_skill_md.py`: line width limit, list item patterns, `TARGET_SKILL_PATH` |
+| `convergence_gate_constants.py` | Constants for `check_convergence_gates.py`: short-SHA length, join separators, and the review-threads GraphQL query |
+
+## Conventions
+
+- `pr_converge_constants.py` uses `from pr_converge_skill_constants.constants import ...` (with `# noqa: F401`) to re-export everything so script files can import from one location.
+- `reflow_skill_md_constants.py` resolves `TARGET_SKILL_PATH` from its own `__file__` path, pointing to `SKILL.md` three directories up.
+- Script-specific regex patterns (ordered list items, bullet list items, unfinished markdown link targets, markdown reference definitions) live in `reflow_skill_md_constants.py`.

package/_shared/pr-loop/scripts/pr_converge_scripts_constants/convergence_gate_constants.py

@@ -0,0 +1,70 @@
+"""Named constants for the convergence gate IO leaves.
+
+Holds the short-SHA length, the review field key the newest-first sort reads,
+the join separators for gate detail strings, the fixture payload keys, and the
+GraphQL query that lists a PR's review threads.
+"""
+
+SHORT_SHA_LENGTH: int = 7
+
+REVIEW_SUBMITTED_AT_KEY: str = "submitted_at"
+
+THREAD_PATH_JOIN_SEPARATOR: str = "; "
+
+PENDING_REVIEWER_JOIN_SEPARATOR: str = ", "
+
+GRAPHQL_REVIEW_THREADS_QUERY: str = """
+query($owner: String!, $repo: String!, $number: Int!, $first: Int!, $cursor: String) {
+  repository(owner: $owner, name: $repo) {
+    pullRequest(number: $number) {
+      reviewThreads(first: $first, after: $cursor) {
+        nodes {
+          isResolved
+          isOutdated
+          path
+          comments(first: 1) {
+            nodes {
+              author { login }
+            }
+          }
+        }
+        pageInfo {
+          hasNextPage
+          endCursor
+        }
+      }
+    }
+  }
+}
+"""
+
+FIXTURE_KEY_HEAD_SHA: str = "head_sha"
+FIXTURE_KEY_PR_OBJECT: str = "pr_object"
+FIXTURE_KEY_REVIEWS: str = "reviews"
+FIXTURE_KEY_UNRESOLVED_BOT_THREADS_PASSED: str = "unresolved_bot_threads_passed"
+FIXTURE_KEY_UNRESOLVED_BOT_THREADS_DETAIL: str = "unresolved_bot_threads_detail"
+FIXTURE_KEY_PENDING_REVIEWS_PASSED: str = "pending_reviews_passed"
+FIXTURE_KEY_PENDING_REVIEWS_DETAIL: str = "pending_reviews_detail"
+FIXTURE_KEY_CODEX_PERCENT_LEFT: str = "codex_percent_left"
+FIXTURE_KEY_CODEX_CLEAN_AT: str = "codex_clean_at"
+FIXTURE_DEFAULT_THREADS_DETAIL: str = "0 unresolved"
+FIXTURE_DEFAULT_PENDING_DETAIL: str = "none pending"
+MERGEABLE_STATE_CLEAN: str = "clean"
+
+COPILOT_DOWN_BYPASS_NOTE: str = "copilot_down"
+BUGBOT_DOWN_BYPASS_NOTE: str = "bugbot_down"
+REVIEWER_UNAVAILABLE_NOTE_TEMPLATE: str = "{token} unavailable: {message}"
+SETTINGS_DISK_FALLBACK_LOG_TEMPLATE: str = (
+    "reviewer-availability: settings.json unreadable; using process env for %s and %s"
+)
+
+CODEX_GATE_LABEL: str = "codex_clean_at == current_head"
+CODEX_BYPASS_DETAIL: str = "bypassed (codex_down)"
+CODEX_SKIPPED_USAGE_DETAIL: str = "skipped (codex review not required)"
+CODEX_CLEAN_DETAIL_TEMPLATE: str = "clean at %s"
+CODEX_MISSING_CLEAN_DETAIL_TEMPLATE: str = "no codex clean on %s"
+CLAUDE_JOB_DIR_ENV_VAR_NAME: str = "CLAUDE_JOB_DIR"
+PR_CONVERGE_STATE_FILENAME: str = "pr-converge-state.json"
+CODEX_CLEAN_AT_STATE_KEY: str = "codex_clean_at"
+CODEX_DOWN_STATE_KEY: str = "codex_down"
+MINIMUM_ABBREVIATED_SHA_LENGTH: int = 7