Increment version to 1.0.18, update README to clarify exit code behavior and analysis limits, enhance documentation on severity filtering, and improve performance detection for async loops. Refactor detector methods for better clarity and add tests for new functionality and suppression behavior.

Author: tboy1337

README.md

@@ -17,11 +17,11 @@ A Python refactoring and optimization linter that uses AST analysis to identify
 - **Complexity**: High cyclomatic complexity functions
 - **Performance**: String concatenation in loops (thresholded), repeated uncached calls in loops, inefficient operations
 - **Boolean Logic**: Overcomplicated boolean expressions
-- **Loops**: Index patterns, nested loops with lookups, loop-invariant calls (dict comprehensions are R010)
+- **Loops**: Index patterns, nested loops with lookups, loop-invariant calls
 - **Duplication**: Duplicate code blocks
 - **Context Manager**: Missing `with` statements for resource operations
 - **Control Flow**: Unnecessary `else` after `return`/`raise`/`break`/`continue`
-- **Dictionary Operations**: Non-idiomatic dict patterns, missing `.get()`, unnecessary `.keys()`
+- **Dictionary Operations**: Non-idiomatic dict patterns, missing `.get()`, unnecessary `.keys()`, dict comprehensions (R010)
 - **Comparisons**: Chained comparisons, singleton checks, `type()` vs `isinstance()`
 
 See [docs/RULES.md](docs/RULES.md) for the full rule catalog (C001–C006, P001–P007, B001/B004–B007, L001–L004, D001, R001–R016).
@@ -78,18 +78,24 @@ pyrefactor --config custom.toml src/
 
 - `-c, --config`: Configuration file path; when omitted, auto-discover `pyproject.toml` (`[tool.pyrefactor]`), then `pyrefactor.ini`, then built-in defaults
 - `-g, --group-by`: Group by `file` or `severity` (default: `file`)
-- `--min-severity`: Minimum severity to report: `info`, `low`, `medium`, `high` (default: `info`)
+- `--min-severity`: Minimum severity to report: `info`, `low`, `medium`, `high` (default: `info`). Also filters which issues count toward the exit code.
 - `-j, --jobs`: Number of parallel workers (default: 4)
 - `-v, --verbose`: Enable verbose logging
 - `--fail-on-parse-errors`: Exit with code 1 when any file has a syntax or parse error
 - `--version`: Show version
 
 ### Exit Codes
 
-- `0` - No MEDIUM/HIGH severity issues (INFO/LOW only). Per-file syntax or parse errors are reported in output but do not change the exit code unless `--fail-on-parse-errors` is set.
-- `1` - MEDIUM/HIGH severity issues found, or parse errors when `--fail-on-parse-errors` is used
+Exit codes are computed **after** applying `--min-severity`. For example, `--min-severity high` can exit `0` even when MEDIUM issues exist, because those issues are filtered out before the exit code is determined.
+
+- `0` - No MEDIUM/HIGH severity issues remain after filtering (INFO/LOW only). Per-file syntax or parse errors are reported in output but do not change the exit code unless `--fail-on-parse-errors` is set.
+- `1` - MEDIUM/HIGH severity issues remain after filtering, or parse errors when `--fail-on-parse-errors` is used
 - `2` - Configuration, path, or orchestration error (invalid paths, missing config, no Python files to analyze)
 
+### Analysis Limits
+
+Files larger than **10 MB** are skipped with a parse-style error message. This limit is fixed and not configurable.
+
 ## Configuration
 
 Configure via TOML file (e.g., `pyproject.toml`):
@@ -141,6 +147,8 @@ Configuration is searched in: `--config` → `pyproject.toml` → `pyrefactor.in
 
 ### INI configuration (`pyrefactor.ini`)
 
+See the repository's [`pyrefactor.ini`](pyrefactor.ini) for a full annotated example with every detector section. A minimal example:
+
 ```ini
 [complexity]
 enabled = true

docs/CONFIGURATION.md

@@ -124,6 +124,12 @@ The CLI does not override individual detector thresholds. Use `--config` to poin
 
 Use `--fail-on-parse-errors` when integrating PyRefactor into CI: by default, syntax and parse errors are reported but do not affect the exit code; with this flag, any parse error causes exit code `1`.
 
+`--min-severity` filters both console output and exit-code calculation. Issues below the minimum severity are omitted entirely.
+
+## Analysis Limits
+
+Files larger than **10 MB** are skipped with a parse-style error message. This limit is fixed in the implementation and is not configurable.
+
 ## Related Documentation
 
 - [RULES.md](RULES.md) — rule IDs, severities, and examples

docs/RULES.md

@@ -45,7 +45,7 @@ B002/B003 are intentionally not used; boolean `== True`/`== False` checks are re
 | Rule | Severity | Description |
 |------|----------|-------------|
 | L001 | LOW | `for i in range(len(seq))` should use `enumerate()` |
-| L002 | LOW | Manual index increment pattern (`i += 1`) |
+| L002 | INFO | Manual index increment pattern (`i += 1`) |
 | L003 | MEDIUM | Deeply nested loops with membership or subscript lookups |
 | L004 | MEDIUM | Loop-invariant expensive call inside loop body |
 
@@ -81,8 +81,8 @@ Covers `open`, `urlopen`, `ZipFile`, `Popen`, `Path.open()`, and related APIs.
 | Rule | Severity | Description |
 |------|----------|-------------|
 | R006 | LOW | `if key in d: x = d[key] else: x = default` should use `.get()` |
-| R007 | LOW | Consider `.items()` when iterating keys and accessing values |
-| R009 | LOW | Unnecessary `.keys()` in a membership test |
+| R007 | MEDIUM | Consider `.items()` when iterating keys and accessing values |
+| R009 | INFO | Unnecessary `.keys()` in a membership test |
 | R010 | LOW | `dict([...])` should be a dict comprehension |
 
 R008 is reserved and not currently implemented.
@@ -114,8 +114,14 @@ y = 2
 
 ## Exit Codes
 
+Exit codes are computed **after** applying `--min-severity`. Issues below the minimum severity are omitted from output and do not affect the exit code.
+
 | Code | Meaning |
 |------|---------|
-| 0 | No MEDIUM/HIGH issues (after severity filter). Per-file syntax/parse errors are reported but exit 0. |
-| 1 | One or more MEDIUM/HIGH issues found |
+| 0 | No MEDIUM/HIGH issues remain after the severity filter. Per-file syntax/parse errors are reported but exit 0 unless `--fail-on-parse-errors` is set. |
+| 1 | One or more MEDIUM/HIGH issues remain after the severity filter, or any parse error when `--fail-on-parse-errors` is set |
 | 2 | Configuration, path, or orchestration error (invalid paths, no Python files to analyze) |
+
+## Analysis Limits
+
+Files larger than **10 MB** are skipped with a parse-style error message. This limit is fixed in the implementation and is not configurable.

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pyrefactor"
-version = "1.0.17"
+version = "1.0.18"
 description = "A Python refactoring and optimization linter that analyzes code for performance issues, complexity problems, and opportunities for improvement"
 authors = [{name = "tboy1337"}]
 maintainers = [{name = "tboy1337"}]

src/pyrefactor/__main__.py

@@ -247,6 +247,8 @@ def main() -> int:
         return 2
 
     # Create analyzer and analyze files
+    if args.jobs < 1:
+        logger.warning("--jobs must be at least 1; using 1 worker")
     max_workers = max(1, args.jobs)
     analyzer = Analyzer(config)
     result = _analyze_files_safely(analyzer, paths, max_workers, verbose=args.verbose)

src/pyrefactor/detectors/boolean_logic.py

@@ -1,7 +1,6 @@
 """Boolean logic detector for PyRefactor."""
 
 import ast
-from typing import Union
 
 from ..ast_visitor import BaseDetector
 from ..models import Severity
@@ -68,18 +67,22 @@ def _check_boolean_singleton_comparison(self, node: ast.Compare) -> None:
             )
             return
 
-    def visit_FunctionDef(
-        self, node: Union[ast.FunctionDef, ast.AsyncFunctionDef]
+    def _visit_function_scope(
+        self, node: ast.FunctionDef | ast.AsyncFunctionDef
     ) -> None:
         """Track function context for early return detection."""
         old_function = self.current_function
         self.current_function = node
         self.generic_visit(node)
         self.current_function = old_function
 
+    def visit_FunctionDef(self, node: ast.FunctionDef) -> None:
+        """Track function context for early return detection."""
+        self._visit_function_scope(node)
+
     def visit_AsyncFunctionDef(self, node: ast.AsyncFunctionDef) -> None:
         """Track async function context for early return detection."""
-        self.visit_FunctionDef(node)
+        self._visit_function_scope(node)
 
     def visit_If(self, node: ast.If) -> None:
         """Check for opportunities to use early returns."""

src/pyrefactor/detectors/comparisons.py

@@ -324,14 +324,6 @@ def _check_unidiomatic_typecheck(self, node: ast.Compare) -> None:
             ),
         )
 
-    def visit_Call(self, node: ast.Call) -> None:
-        """Visit call nodes for comparison checks."""
-        if self.is_suppressed(node):
-            self.generic_visit(node)
-            return
-
-        self.generic_visit(node)
-
     def _get_op_str(self, op: ast.cmpop) -> Optional[str]:
         """Convert comparison operator to string."""
         op_map = {

src/pyrefactor/detectors/dict_operations.py

@@ -1,7 +1,7 @@
 """Dictionary operations detector for PyRefactor."""
 
 import ast
-from typing import Optional, Tuple, cast
+from typing import cast
 
 from ..ast_visitor import BaseDetector
 from ..models import Severity
@@ -67,7 +67,7 @@ def _is_valid_dict_get_structure(self, node: ast.If) -> bool:
 
     def _extract_dict_get_components(
         self, node: ast.If
-    ) -> Optional[Tuple[str, str, str, str]]:
+    ) -> tuple[str, str, str, str] | None:
         """Extract variable names and values for dict.get() suggestion."""
         if_stmt = node.body[0]
         else_stmt = node.orelse[0]
@@ -123,7 +123,7 @@ def _validate_assignment_structure(
 
     def _extract_condition_data(
         self, test: ast.expr
-    ) -> Optional[Tuple[ast.Name, ast.Name]]:
+    ) -> tuple[ast.Name, ast.Name] | None:
         """Extract key and dict names from the condition."""
         if not isinstance(test, ast.Compare):
             return None
@@ -336,7 +336,7 @@ def _check_dict_comprehension(self, node: ast.Call) -> None:
             "for better readability and performance",
         )
 
-    def _get_name(self, node: ast.AST) -> Optional[str]:
+    def _get_name(self, node: ast.AST) -> str | None:
         """Extract the name from a node."""
         if isinstance(node, ast.Name):
             return node.id

src/pyrefactor/detectors/performance.py

@@ -131,7 +131,7 @@ def _is_suppressed_for_rule(self, node: ast.AST, rule_id: str) -> bool:
         """Return True when a node is suppressed for a specific rule."""
         return self.is_suppressed(node, rule_id)
 
-    def _visit_loop(self, node: ast.For | ast.While) -> None:
+    def _visit_loop(self, node: ast.For | ast.While | ast.AsyncFor) -> None:
         """Track loop entry, analyze body, then exit."""
         self.loop_stack.append(node)
         self.in_loop = True
@@ -144,6 +144,10 @@ def visit_For(self, node: ast.For) -> None:
         """Track when we're inside a for loop."""
         self._visit_loop(node)
 
+    def visit_AsyncFor(self, node: ast.AsyncFor) -> None:
+        """Track when we're inside an async for loop."""
+        self._visit_loop(node)
+
     def visit_While(self, node: ast.While) -> None:
         """Track when we're inside a while loop."""
         self._visit_loop(node)
@@ -172,12 +176,16 @@ def _is_string_initializer(self, node: ast.expr) -> bool:
         """Return True if an expression initializes a string value."""
         return isinstance(node, ast.Constant) and isinstance(node.value, str)
 
-    def _check_loop_performance(self, loop_node: ast.For | ast.While) -> None:
+    def _check_loop_performance(
+        self, loop_node: ast.For | ast.While | ast.AsyncFor
+    ) -> None:
         """Check loop body for concatenation and duplicate call patterns."""
         self._check_string_concatenations(loop_node)
         self._check_duplicate_calls(loop_node)
 
-    def _check_string_concatenations(self, loop_node: ast.For | ast.While) -> None:
+    def _check_string_concatenations(
+        self, loop_node: ast.For | ast.While | ast.AsyncFor
+    ) -> None:
         """Report P001 when string += count meets threshold."""
         counter = _LoopBodyConcatCounter(
             self._is_suppressed_for_rule,
@@ -200,7 +208,9 @@ def _check_string_concatenations(self, loop_node: ast.For | ast.While) -> None:
                 ),
             )
 
-    def _check_duplicate_calls(self, loop_node: ast.For | ast.While) -> None:
+    def _check_duplicate_calls(
+        self, loop_node: ast.For | ast.While | ast.AsyncFor
+    ) -> None:
         """Report P007 when identical calls repeat within a loop body."""
         counter = _LoopBodyCallCounter(self._is_suppressed_for_rule, "P007")
         counter.visit(loop_node)

tests/test_ast_visitor.py

@@ -3,13 +3,15 @@
 import ast
 
 from pyrefactor.ast_visitor import (
+    BaseDetector,
     build_parent_map,
     calculate_cyclomatic_complexity,
     count_branches,
     count_nesting_depth,
     node_col_offset,
     node_lineno,
 )
+from pyrefactor.config import Config
 
 
 class TestNodeLineno:
@@ -154,3 +156,34 @@ def func(value):
         func_def = tree.body[0]
         assert isinstance(func_def, ast.FunctionDef)
         assert count_branches(func_def) >= 2
+
+
+class _SuppressionProbeDetector(BaseDetector):
+    """Minimal detector for exercising suppression helpers."""
+
+    def get_detector_name(self) -> str:
+        return "suppression_probe"
+
+
+class TestBaseDetectorSuppression:
+    """Tests for BaseDetector suppression behavior."""
+
+    def test_noqa_suppresses_all_rules(self) -> None:
+        """Test blanket # noqa suppresses every rule on the line."""
+        source_lines = ["x = 1  # noqa"]
+        detector = _SuppressionProbeDetector(Config(), "test.py", source_lines)
+        tree = ast.parse("x = 1")
+        node = tree.body[0]
+
+        assert detector.is_suppressed(node, "C001") is True
+        assert detector.is_suppressed(node, "P001") is True
+
+    def test_rule_scoped_noqa_does_not_suppress_other_rules(self) -> None:
+        """Test rule-specific pyrefactor ignore does not blanket-suppress."""
+        source_lines = ["x = 1  # pyrefactor: ignore C001"]
+        detector = _SuppressionProbeDetector(Config(), "test.py", source_lines)
+        tree = ast.parse("x = 1")
+        node = tree.body[0]
+
+        assert detector.is_suppressed(node, "C001") is True
+        assert detector.is_suppressed(node, "P001") is False