claude-dev-env 1.36.1 → 1.37.0

package/_shared/pr-loop/scripts/tests/test_preflight_constants.py

@@ -0,0 +1,77 @@
+"""Tests for preflight_constants.py extracted constant set."""
+
+import importlib.util
+from pathlib import Path
+from types import ModuleType
+
+
+def _load_constants_module() -> ModuleType:
+    module_path = Path(__file__).parent.parent / "config" / "preflight_constants.py"
+    specification = importlib.util.spec_from_file_location(
+        "config.preflight_constants", module_path
+    )
+    assert specification is not None
+    assert specification.loader is not None
+    module = importlib.util.module_from_spec(specification)
+    specification.loader.exec_module(module)
+    return module
+
+
+constants_module = _load_constants_module()
+
+
+def test_bugteam_preflight_skip_env_var_name() -> None:
+    assert (
+        constants_module.BUGTEAM_PREFLIGHT_SKIP_ENV_VAR_NAME == "BUGTEAM_PREFLIGHT_SKIP"
+    )
+
+
+def test_bugteam_preflight_skip_enabled_value() -> None:
+    assert constants_module.BUGTEAM_PREFLIGHT_SKIP_ENABLED_VALUE == "1"
+
+
+def test_git_directory_name() -> None:
+    assert constants_module.GIT_DIRECTORY_NAME == ".git"
+
+
+def test_claude_directory_name() -> None:
+    assert constants_module.CLAUDE_DIRECTORY_NAME == ".claude"
+
+
+def test_pytest_ini_filename() -> None:
+    assert constants_module.PYTEST_INI_FILENAME == "pytest.ini"
+
+
+def test_pyproject_toml_filename() -> None:
+    assert constants_module.PYPROJECT_TOML_FILENAME == "pyproject.toml"
+
+
+def test_pytest_toml_table_prefix() -> None:
+    assert constants_module.PYTEST_TOML_TABLE_PREFIX == "[tool.pytest"
+
+
+def test_pre_commit_config_yaml_filename() -> None:
+    assert constants_module.PRE_COMMIT_CONFIG_YAML_FILENAME == ".pre-commit-config.yaml"
+
+
+def test_all_git_ls_files_test_discovery_command() -> None:
+    assert constants_module.ALL_GIT_LS_FILES_TEST_DISCOVERY_SUBCOMMAND == (
+        "ls-files",
+        "--cached",
+        "--others",
+        "--exclude-standard",
+        "--",
+        "**/test_*.py",
+        "**/*_test.py",
+    )
+
+
+def test_all_repository_root_marker_filenames() -> None:
+    assert constants_module.ALL_REPOSITORY_ROOT_MARKER_FILENAMES == (
+        constants_module.GIT_DIRECTORY_NAME,
+        constants_module.PYTEST_INI_FILENAME,
+    )
+
+
+def test_pytest_no_tests_collected_exit_code() -> None:
+    assert constants_module.PYTEST_NO_TESTS_COLLECTED_EXIT_CODE == 5

package/_shared/pr-loop/scripts/tests/test_revoke_project_claude_permissions.py

@@ -0,0 +1,49 @@
+"""Smoke tests for revoke_project_claude_permissions wiring.
+
+Confirms the module imports cleanly with the constants now sourced from
+config/claude_permissions_constants.py and config/claude_settings_keys_constants.py.
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import sys
+from pathlib import Path
+from types import ModuleType
+
+
+def _load_revoke_module() -> ModuleType:
+    scripts_directory = Path(__file__).parent.parent
+    parent_directory = str(scripts_directory.resolve())
+    if parent_directory not in sys.path:
+        sys.path.insert(0, parent_directory)
+    sys.modules.pop("config", None)
+    module_path = scripts_directory / "revoke_project_claude_permissions.py"
+    specification = importlib.util.spec_from_file_location(
+        "revoke_project_claude_permissions", module_path
+    )
+    assert specification is not None
+    assert specification.loader is not None
+    module = importlib.util.module_from_spec(specification)
+    specification.loader.exec_module(module)
+    return module
+
+
+def test_module_imports_constants_from_config_modules() -> None:
+    revoke_module = _load_revoke_module()
+    assert revoke_module.ALL_PERMISSION_ALLOW_TOOLS == ("Edit", "Write", "Read")
+    assert "{project_path}" in revoke_module.AUTO_MODE_ENVIRONMENT_ENTRY_TEMPLATE
+    assert revoke_module.CLAUDE_SETTINGS_PERMISSIONS_KEY == "permissions"
+
+
+def test_revoke_module_guards_sys_path_insert_against_duplicates() -> None:
+    """revoke_project_claude_permissions.py must guard its sys.path.insert with a
+    membership check so re-imports under test harnesses do not push duplicate
+    entries (consistent with sibling modules in the same directory)."""
+    module_source = (
+        Path(__file__).parent.parent / "revoke_project_claude_permissions.py"
+    ).read_text(encoding="utf-8")
+    assert "if str(Path(__file__).resolve().parent) not in sys.path:" in module_source, (
+        "revoke_project_claude_permissions.py must guard sys.path.insert against "
+        "duplicate entries on reload (consistent with sibling modules)"
+    )

package/_shared/pr-loop/state-schema.md

@@ -0,0 +1,81 @@
+# State schema
+
+State each PR-loop workflow tracks across iterations. Workflows differ on persistence (in-memory vs files) and which fields they use; shapes overlap.
+
+## Common fields
+
+| Field | Type | Purpose |
+|---|---|---|
+| `loop_count` | int | Iterations completed; bumps on each AUDIT or tick |
+| `last_action` | enum | `fresh` \| `audited` \| `fixed` — drives next-step dispatch |
+| `last_findings` | object | `{p0, p1, p2, total}` count of findings from most recent AUDIT |
+| `audit_log` | list[str] | Per-iteration one-line summaries for the final report |
+| `starting_sha` | str | `git rev-parse HEAD` at workflow start |
+| `loop_comment_index` | dict | `{finding_id: {finding_comment_id, finding_comment_url, used_fallback, fix_status, ...}}` |
+
+## Workflow-specific extensions
+
+### bugteam
+
+Adds:
+- `team_name` — `bugteam-pr-<N>-<YYYYMMDDHHMMSS>` or `bugteam-<YYYYMMDDHHMMSS>` for multi-PR
+- `team_temp_dir` — absolute path resolved from `tempfile.gettempdir()`
+- `pre_fix_sha` — `git rev-parse HEAD` immediately before each FIX
+- `gate_round_count` — consecutive pre-audit gate failures (cap: 5 → exit `error`)
+
+State lives inline in the lead session (orchestrator). Cleared on TeamDelete.
+
+### qbug
+
+Adds nothing beyond common. Single subagent loops internally and returns a final summary; orchestrator discards intermediate state. Subagent's loop counter and findings return in the exit payload (`{exit_reason, loop_count, final_commit_sha, audit_log, unresolved}`).
+
+### pr-converge
+
+Adds the same **traffic** fields whether they live in **`state.json`** or in the **conversation state line**; only the **store** differs.
+
+| Field | Type | Purpose |
+|---|---|---|
+| `phase` | enum | `BUGBOT` \| `BUGTEAM` — which reviewer the current tick drives |
+| `current_head` | str | PR `headRefOid` / `git rev-parse` for the PR under work (each tick; from `view_pr_context.py` when no file store) |
+| `bugbot_clean_at` | str \| null | HEAD SHA at which Cursor Bugbot last reported clean, or `null` (reset on every push) |
+| `copilot_clean_at` | str \| null | HEAD SHA at which the GitHub Copilot reviewer (`copilot-pull-request-reviewer[bot]`) last reported clean (review `state == "APPROVED"`), or `null`. Reset on every push. Convergence gates require this equals `current_head` after bugbot+bugteam are clean (see `skills/pr-converge/SKILL.md` § Convergence gates). |
+| `merge_state_status` | str \| null | Last-observed `mergeStateStatus` from `gh pr view --json mergeable,mergeStateStatus,headRefOid` (e.g., `CLEAN`, `DIRTY`, `BLOCKED`, `BEHIND`, `UNKNOWN`), or `null` before the first check. Reset on every push. `DIRTY` triggers the rebase invocation; non-`CLEAN` non-`DIRTY` is a hard blocker per pr-converge `Stop conditions`. |
+| `inline_lag_streak` | int | Consecutive ticks where bugbot's review body claims findings but inline-comments API returns zero rows for `current_head` |
+| `tick_count` | int | Observability only — **no ceiling**; loop ends on convergence or **Stop conditions** in `pr-converge` |
+
+**Dual persistence** (normative: `skills/pr-converge/SKILL.md` § State across ticks, § Multi-PR orchestration model):
+
+| Mode | When it applies | Source of truth | `tick_count` bump |
+|---|---|---|---|
+| **`state.json`** | File exists at `<TMPDIR>/pr-converge-<session_id>/state.json` (multi-PR orchestration or other file-backed session) | JSON: top-level `session_id`; per-PR objects under `prs[<number>]` with `owner`, `repo`, `branch`, `phase`, `current_head`, `bugbot_clean_at`, `inline_lag_streak`, `tick_count`, `last_action`, `status`, `last_updated`. Optional sibling `converged.log` (append-only; multi-PR only). Writes use lock + atomic replace per skill **Concurrency** | **Orchestrator only** at tick start (locked merge for every non-terminal PR); **never** bump `tick_count` in Step 1 when this file is in use |
+| **Conversation state line** | **No** `state.json` (typical single-PR `/pr-converge` in Cursor) | Persist **`phase`**, **`bugbot_clean_at`**, **`inline_lag_streak`**, **`tick_count`** as **plain text** in each assistant turn; next tick reads them from the **most recent assistant message**. **`current_head` is not serialized in that line** — re-resolve each tick via `view_pr_context.py` (same contract as `skills/pr-converge/SKILL.md` § State across ticks). | **Step 1** increments `tick_count` in that line **only** when no `state.json` — must not double-count with any file-backed path |
+
+**`status` (file-backed `prs[...]` only):** `fresh` \| `in_progress` \| `awaiting_bugbot` \| `awaiting_bugteam` \| `converged` \| `blocked`
+
+### monitor-many
+
+Adds per-PR JSON state file at `~/.claude/skills/monitor-many/state/<owner>-<repo>-<pr_number>.json`:
+
+| Field | Type | Description |
+|---|---|---|
+| `repo_name` | str | Full `owner/repo` |
+| `pr_number` | int | PR number |
+| `status` | enum | `open` \| `blocked_escalation` \| `fixing` \| `ready_candidate` \| `closed` |
+| `copilot_review` | enum | `none` \| `requested` \| `pending` \| `commented` \| `approved` |
+| `bugbot_review` | enum | Same vocabulary as `copilot_review` |
+| `last_seen_comment_id` | int \| null | Highest processed review-comment id (incremental polling watermark) |
+| `review_comments` | list[object] | Optional cache; `{id, author, path, line}` per entry |
+| `escalation_queue` | list[object] | Pending human-judgment items: `{comment_id, summary, created_at}` |
+
+## Reset semantics
+
+- bugteam: cleared on each new `/bugteam` invocation
+- qbug: cleared on each new `/qbug` invocation
+- pr-converge: `bugbot_clean_at`, `copilot_clean_at`, and `merge_state_status` all reset to `null` on every push (a new commit invalidates every reviewer's prior clean and the prior mergeability snapshot by definition); `phase` cycles each tick. With `state.json`, orchestrator reads that file at tick start; without it, rely on the prior conversation state line — **never** mix both increment rules for `tick_count` on the same run
+- monitor-many: persists across orchestrator runs; only `last_seen_comment_id` advances monotonically
+
+## Convergence checks
+
+- bugteam, qbug: `last_action == "audited"` AND `last_findings.total == 0` → `converged`
+- pr-converge: `bugbot_clean_at == current_head` AND most-recent bugteam exit is `converged` AND no push during the bugteam tick AND no outstanding Copilot findings on `current_head` AND `merge_state_status == "CLEAN"` (per `skills/pr-converge/SKILL.md` § Convergence gates) → back-to-back clean → `gh pr ready` (read `current_head` / `bugbot_clean_at` / `copilot_clean_at` / `merge_state_status` from `state.json` when file-backed, else from the conversation state line and Step 1 `view_pr_context.py` output)
+- monitor-many: no unresolved comments requiring code changes AND required checks green AND review policy satisfied → `gh pr ready`

package/hooks/blocking/code_rules_enforcer.py

@@ -57,9 +57,11 @@ from config.stuttering_check_config import (  # noqa: E402
 )
 from config.sys_path_insert_constants import MAX_SYS_PATH_INSERT_ISSUES, SYS_PATH_INSERT_GUIDANCE  # noqa: E402
 from config.unused_module_import_constants import (  # noqa: E402
+    ALL_TYPING_MODULE_NAMES,
     MAX_UNUSED_IMPORT_ISSUES,
     TYPE_CHECKING_IDENTIFIER,
     UNUSED_IMPORT_GUIDANCE,
+    line_suppresses_unused_import_via_noqa,
 )
 from config.stuttering_import_binding_constants import (  # noqa: E402
     AST_LINENO_ATTRIBUTE,
@@ -2324,30 +2326,269 @@ def _import_alias_pairs(
     return bindings
 
 
-def _name_appears_outside_imports(
-    all_content_lines: list[str],
-    all_import_line_numbers: set[int],
-    name: str,
+def _import_statement_line_ranges(tree: ast.Module) -> list[tuple[int, int]]:
+    ranges: list[tuple[int, int]] = []
+    for each_node in tree.body:
+        if isinstance(each_node, (ast.Import, ast.ImportFrom)):
+            start_line = each_node.lineno
+            end_line = each_node.end_lineno or each_node.lineno
+            ranges.append((start_line, end_line))
+    return ranges
+
+
+def _line_number_falls_in_import_ranges(
+    line_number: int,
+    all_import_line_ranges: list[tuple[int, int]],
 ) -> bool:
-    name_pattern = re.compile(rf"\b{re.escape(name)}\b")
-    for each_line_index, each_line in enumerate(all_content_lines, start=1):
-        if each_line_index in all_import_line_numbers:
-            continue
-        if name_pattern.search(each_line):
+    for each_start, each_end in all_import_line_ranges:
+        if each_start <= line_number <= each_end:
             return True
     return False
 
 
-def _line_carries_noqa_marker(line_text: str) -> bool:
-    return "# noqa" in line_text or "#noqa" in line_text
+def _type_checking_guard_aliases(tree: ast.Module) -> tuple[set[str], set[str]]:
+    all_type_checking_names = {TYPE_CHECKING_IDENTIFIER}
+    all_type_checking_module_aliases = set(ALL_TYPING_MODULE_NAMES)
+    for each_statement in tree.body:
+        if isinstance(each_statement, ast.Import):
+            for each_alias in each_statement.names:
+                if each_alias.name in ALL_TYPING_MODULE_NAMES:
+                    all_type_checking_module_aliases.add(
+                        each_alias.asname or each_alias.name
+                    )
+        elif isinstance(each_statement, ast.ImportFrom):
+            if each_statement.module not in ALL_TYPING_MODULE_NAMES:
+                continue
+            for each_alias in each_statement.names:
+                if each_alias.name == TYPE_CHECKING_IDENTIFIER:
+                    all_type_checking_names.add(each_alias.asname or each_alias.name)
+    return all_type_checking_names, all_type_checking_module_aliases
+
+
+def _expression_guards_type_checking_block(
+    test_expression: ast.expr,
+    all_type_checking_names: set[str],
+    all_type_checking_module_aliases: set[str],
+) -> bool:
+    if isinstance(test_expression, ast.Name):
+        return test_expression.id in all_type_checking_names
+    if isinstance(test_expression, ast.Attribute):
+        if test_expression.attr != TYPE_CHECKING_IDENTIFIER:
+            return False
+        receiver = test_expression.value
+        return (
+            isinstance(receiver, ast.Name)
+            and receiver.id in all_type_checking_module_aliases
+        )
+    return False
+
+
+def _module_body_declares_type_checking_gate(tree: ast.Module) -> bool:
+    (
+        all_type_checking_names,
+        all_type_checking_module_aliases,
+    ) = _type_checking_guard_aliases(tree)
+    return any(
+        isinstance(each_statement, ast.If)
+        and _expression_guards_type_checking_block(
+            each_statement.test,
+            all_type_checking_names,
+            all_type_checking_module_aliases,
+        )
+        for each_statement in tree.body
+    )
+
+
+def _attribute_root_name_if_loaded(attribute_node: ast.Attribute) -> ast.Name | None:
+    current: ast.expr = attribute_node
+    while isinstance(current, ast.Attribute):
+        current = current.value
+    if isinstance(current, ast.Name) and isinstance(current.ctx, ast.Load):
+        return current
+    return None
+
+
+class _ScopeBindingCollector(ast.NodeVisitor):
+    def __init__(self) -> None:
+        self.binding_names: set[str] = set()
+        self.global_names: set[str] = set()
+
+    def collect_arguments(self, arguments: ast.arguments) -> None:
+        for each_argument in (
+            arguments.posonlyargs
+            + arguments.args
+            + arguments.kwonlyargs
+        ):
+            self.binding_names.add(each_argument.arg)
+        if arguments.vararg is not None:
+            self.binding_names.add(arguments.vararg.arg)
+        if arguments.kwarg is not None:
+            self.binding_names.add(arguments.kwarg.arg)
+
+    def visit_Global(self, node: ast.Global) -> None:
+        self.global_names.update(node.names)
+
+    def visit_Nonlocal(self, node: ast.Nonlocal) -> None:
+        self.binding_names.update(node.names)
+
+    def visit_FunctionDef(self, node: ast.FunctionDef) -> None:
+        self.binding_names.add(node.name)
+
+    def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef) -> None:
+        self.binding_names.add(node.name)
+
+    def visit_ClassDef(self, node: ast.ClassDef) -> None:
+        self.binding_names.add(node.name)
+
+    def visit_Lambda(self, node: ast.Lambda) -> None:
+        return None
+
+    def visit_Name(self, node: ast.Name) -> None:
+        if isinstance(node.ctx, ast.Store):
+            self.binding_names.add(node.id)
+
+    def visit_Import(self, node: ast.Import) -> None:
+        for each_alias in node.names:
+            self.binding_names.add(each_alias.asname or each_alias.name.split(".")[0])
+
+    def visit_ImportFrom(self, node: ast.ImportFrom) -> None:
+        for each_alias in node.names:
+            if each_alias.name != WILDCARD_IMPORT_SENTINEL:
+                self.binding_names.add(each_alias.asname or each_alias.name)
+
+    def visit_ListComp(self, node: ast.ListComp) -> None:
+        return None
+
+    def visit_SetComp(self, node: ast.SetComp) -> None:
+        return None
+
+    def visit_DictComp(self, node: ast.DictComp) -> None:
+        return None
+
+    def visit_GeneratorExp(self, node: ast.GeneratorExp) -> None:
+        return None
+
+    def visit_ExceptHandler(self, node: ast.ExceptHandler) -> None:
+        if node.name is not None:
+            self.binding_names.add(node.name)
+        self.generic_visit(node)
+
+
+def _scope_binding_names(scope_node: ast.AST) -> tuple[set[str], set[str]]:
+    collector = _ScopeBindingCollector()
+    if isinstance(scope_node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+        collector.collect_arguments(scope_node.args)
+        for each_statement in scope_node.body:
+            collector.visit(each_statement)
+    elif isinstance(scope_node, ast.Lambda):
+        collector.collect_arguments(scope_node.args)
+        collector.visit(scope_node.body)
+    elif isinstance(scope_node, ast.ClassDef):
+        for each_statement in scope_node.body:
+            collector.visit(each_statement)
+    return collector.binding_names, collector.global_names
+
+
+def _load_name_is_shadowed(
+    load_node: ast.AST,
+    name: str,
+    parent_by_node_id: dict[int, ast.AST],
+) -> bool:
+    current = parent_by_node_id.get(id(load_node))
+    has_passed_function_scope = False
+    while current is not None:
+        if isinstance(current, (ast.FunctionDef, ast.AsyncFunctionDef, ast.Lambda)):
+            has_passed_function_scope = True
+            binding_names, global_names = _scope_binding_names(current)
+            if name in global_names:
+                return False
+            if name in binding_names:
+                return True
+        elif isinstance(current, ast.ClassDef) and not has_passed_function_scope:
+            # Class body bindings are order-dependent (name resolution is
+            # dynamic, unlike function locals). A load before an assignment
+            # still resolves to the module-level name, so conservatively
+            # skip class-body shadow detection to avoid false positives.
+            pass
+        current = parent_by_node_id.get(id(current))
+    return False
+
+
+def _names_from_annotation_text(annotation_text: str) -> set[str]:
+    try:
+        annotation_tree = ast.parse(annotation_text, mode="eval")
+    except SyntaxError:
+        return set()
+    referenced_names: set[str] = set()
+    for each_node in ast.walk(annotation_tree):
+        if isinstance(each_node, ast.Name):
+            referenced_names.add(each_node.id)
+        elif isinstance(each_node, ast.Attribute):
+            root_name = _attribute_root_name_if_loaded(each_node)
+            if root_name is not None:
+                referenced_names.add(root_name.id)
+    return referenced_names
+
+
+def _collect_string_annotation_names(tree: ast.Module) -> set[str]:
+    referenced_names: set[str] = set()
+    for each_node in ast.walk(tree):
+        annotation = None
+        if isinstance(each_node, ast.arg):
+            annotation = each_node.annotation
+        elif isinstance(each_node, (ast.AnnAssign, ast.FunctionDef, ast.AsyncFunctionDef)):
+            annotation = each_node.annotation if isinstance(each_node, ast.AnnAssign) else each_node.returns
+        if isinstance(annotation, ast.Constant) and isinstance(annotation.value, str):
+            referenced_names.update(_names_from_annotation_text(annotation.value))
+    return referenced_names
+
+
+def _collect_load_names_outside_import_ranges(
+    tree: ast.Module,
+    all_import_line_ranges: list[tuple[int, int]],
+) -> set[str]:
+    parent_by_node_id = _build_parent_map(tree)
+    referenced_names: set[str] = set()
+    for each_node in ast.walk(tree):
+        if isinstance(each_node, ast.Name) and isinstance(each_node.ctx, ast.Load):
+            line_number = each_node.lineno
+            if line_number is None or _line_number_falls_in_import_ranges(
+                line_number,
+                all_import_line_ranges,
+            ):
+                continue
+            if _load_name_is_shadowed(each_node, each_node.id, parent_by_node_id):
+                continue
+            referenced_names.add(each_node.id)
+        elif isinstance(each_node, ast.Attribute) and isinstance(
+            each_node.ctx, ast.Load
+        ):
+            line_number = each_node.lineno
+            if line_number is None or _line_number_falls_in_import_ranges(
+                line_number,
+                all_import_line_ranges,
+            ):
+                continue
+            root_name = _attribute_root_name_if_loaded(each_node)
+            if root_name is not None and not _load_name_is_shadowed(
+                root_name,
+                root_name.id,
+                parent_by_node_id,
+            ):
+                referenced_names.add(root_name.id)
+    referenced_names.update(_collect_string_annotation_names(tree))
+    return referenced_names
 
 
 def check_unused_module_level_imports(content: str, file_path: str) -> list[str]:
     """Flag module-level imports that are never referenced in the rest of the file.
 
-    The rule is intentionally conservative — files declaring __all__ or
-    using TYPE_CHECKING are skipped to avoid false positives on
-    re-exports and annotation-only imports.
+    References are detected from AST ``Name`` / ``Attribute`` loads outside import
+    statements so mentions in comments or string literals do not count. Files
+    declaring ``__all__`` (including annotated assignments) are skipped. Files
+    whose module body includes ``if TYPE_CHECKING:`` (or
+    ``typing[._extensions].TYPE_CHECKING``) are skipped. Suppression honors bare
+    ``# noqa`` or an explicit ``F401`` code in the noqa list only.
     """
     if is_test_file(file_path):
         return []
@@ -2374,16 +2615,17 @@ def check_unused_module_level_imports(content: str, file_path: str) -> list[str]
     )
     if file_declares_dunder_all:
         return []
-    if TYPE_CHECKING_IDENTIFIER in content:
+    if _module_body_declares_type_checking_gate(tree):
         return []
     content_lines = content.splitlines()
-    import_line_numbers: set[int] = set()
+    import_line_ranges = _import_statement_line_ranges(tree)
+    referenced_names = _collect_load_names_outside_import_ranges(
+        tree,
+        import_line_ranges,
+    )
     import_bindings: list[tuple[str, int, int | None]] = []
     for each_node in tree.body:
         if isinstance(each_node, (ast.Import, ast.ImportFrom)):
-            import_line_numbers.add(each_node.lineno)
-            for each_alias in each_node.names:
-                import_line_numbers.add(each_alias.lineno or each_node.lineno)
             if isinstance(each_node, ast.ImportFrom) and each_node.module == "__future__":
                 continue
             for each_binding in _import_alias_pairs(each_node):
@@ -2391,12 +2633,16 @@ def check_unused_module_level_imports(content: str, file_path: str) -> list[str]
     issues: list[str] = []
     for each_name, each_line_number, each_from_keyword_line in import_bindings:
         if 1 <= each_line_number <= len(content_lines):
-            if _line_carries_noqa_marker(content_lines[each_line_number - 1]):
+            if line_suppresses_unused_import_via_noqa(content_lines[each_line_number - 1]):
                 continue
-        if each_from_keyword_line is not None and 1 <= each_from_keyword_line <= len(content_lines):
-            if _line_carries_noqa_marker(content_lines[each_from_keyword_line - 1]):
+        if each_from_keyword_line is not None and 1 <= each_from_keyword_line <= len(
+            content_lines
+        ):
+            if line_suppresses_unused_import_via_noqa(
+                content_lines[each_from_keyword_line - 1]
+            ):
                 continue
-        if _name_appears_outside_imports(content_lines, import_line_numbers, each_name):
+        if each_name in referenced_names:
             continue
         issues.append(
             f"Line {each_line_number}: unused module-level import {each_name!r}"