python-code-validator 0.1.3__tar.gz → 0.3.0__tar.gz

{python_code_validator-0.1.3/src/python_code_validator.egg-info → python_code_validator-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-code-validator
-Version: 0.1.3
+Version: 0.3.0
 Summary: A flexible, AST-based framework for static validation of Python code using declarative JSON rules.
 Author-email: Qu1nel <covach.qn@gmail.com>
 License: MIT License
@@ -287,7 +287,7 @@ Validation failed.
   **[Read the Docs](https://[your-project].readthedocs.io)**.
 - **Developer's Guide**: For a deep dive into the architecture, see the
   **[How It Works guide](./docs/how_it_works/index.md)**.
-- **Interactive AI-Powered Docs**: *(Coming Soon)* An interactive documentation experience.
+- **Interactive AI-Powered Docs**: **[DeepWiki](https://deepwiki.com/Qu1nel/PythonCodeValidator)**.
 
 ## 🤝 Contributing
 

{python_code_validator-0.1.3 → python_code_validator-0.3.0}/README.md

@@ -229,7 +229,7 @@ Validation failed.
   **[Read the Docs](https://[your-project].readthedocs.io)**.
 - **Developer's Guide**: For a deep dive into the architecture, see the
   **[How It Works guide](./docs/how_it_works/index.md)**.
-- **Interactive AI-Powered Docs**: *(Coming Soon)* An interactive documentation experience.
+- **Interactive AI-Powered Docs**: **[DeepWiki](https://deepwiki.com/Qu1nel/PythonCodeValidator)**.
 
 ## 🤝 Contributing
 
@@ -253,4 +253,4 @@ Email: **[covach.qn@gmail.com](mailto:covach.qn@gmail.com)** Telegram: **[@qnlln
 
 <br/>
 
-<p align="right"><a href="./LICENSE">MIT</a> © <a href="https://github.com/Qu1nel/">Ivan Kovach</a></p>
+<p align="right"><a href="./LICENSE">MIT</a> © <a href="https://github.com/Qu1nel/">Ivan Kovach</a></p>

{python_code_validator-0.1.3 → python_code_validator-0.3.0}/pyproject.toml

@@ -10,13 +10,13 @@ build-backend = "setuptools.build_meta"
 # ==============================================================================
 [project]
 name = "python-code-validator"
-version = "0.1.3"
-authors = [{ name = "Qu1nel", email = "covach.qn@gmail.com" }]
+version = "0.3.0"
 description = "A flexible, AST-based framework for static validation of Python code using declarative JSON rules."
+keywords = ["validation", "linter", "static analysis", "testing", "education", "ast"]
+authors = [{ name = "Qu1nel", email = "covach.qn@gmail.com" }]
 readme = "README.md"
 requires-python = ">=3.11"
 license = { file = "LICENSE" }
-keywords = ["validation", "linter", "static analysis", "testing", "education", "ast"]
 classifiers = [
     "Development Status :: 4 - Beta",
     "Intended Audience :: Developers",
@@ -40,9 +40,11 @@ dependencies = [
 "Documentation" = "https://pythoncodevalidator.readthedocs.io/en/latest/"
 "Bug Tracker" = "https://github.com/Qu1nel/PythonCodeValidator/issues"
 
+
 [project.scripts]
 validate-code = "code_validator.cli:run_from_cli"
 
+
 [project.optional-dependencies]
 dev = [
     "ruff>=0.4.0",
@@ -81,8 +83,7 @@ select = [
     "C4", # flake8-comprehensions
     "D", # pydocstyle
 ]
-ignore = [
-]
+ignore = []
 
 [tool.ruff.lint.per-file-ignores]
 "tests/*" = [
@@ -95,7 +96,7 @@ ignore = [
 ]
 "src/code_validator/components/__init__.py" = ["D104"]
 "src/code_validator/rules_library/__init__.py" = ["D104"]
-
+"src/code_validator/components/factories.py" = ["D107"]
 
 [tool.ruff.lint.pydocstyle]
 convention = "google"

{python_code_validator-0.1.3 → python_code_validator-0.3.0}/src/code_validator/__init__.py

@@ -54,4 +54,4 @@ __all__ = [
     "RuleParsingError",
 ]
 
-__version__ = "0.1.3"
+__version__ = "0.3.0"

{python_code_validator-0.1.3 → python_code_validator-0.3.0}/src/code_validator/cli.py

@@ -35,19 +35,31 @@ def setup_arg_parser() -> argparse.ArgumentParser:
         prog="validate-code",
         description="Validates a Python source file against a set of JSON rules.",
     )
+
     parser.add_argument("solution_path", type=Path, help="Path to the Python solution file to validate.")
     parser.add_argument("rules_path", type=Path, help="Path to the JSON file with validation rules.")
+
     parser.add_argument(
-        "-l",
-        "--log-level",
+        "--log",
         type=LogLevel,
-        choices=list(LogLevel),
-        default=LogLevel.WARNING,
-        help="Set the logging level (default: WARNING).",
+        default=LogLevel.ERROR,
+        help="Set the logging level for stderr (TRACE, DEBUG, INFO, WARNING, ERROR, CRITICAL). Default: ERROR.",
     )
-    parser.add_argument("--silent", action="store_true", help="Suppress stdout output, show only logs.")
-    parser.add_argument("--stop-on-first-fail", action="store_true", help="Stop after the first failed rule.")
-    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    parser.add_argument(
+        "--quiet", action="store_true", help="Suppress all stdout output (validation errors and final verdict)."
+    )
+    parser.add_argument("--no-verdict", action="store_true", help="Suppress stdout output verdict, show failed rules.")
+    parser.add_argument(
+        "--max-messages",
+        type=int,
+        default=0,
+        metavar="N",
+        help="Maximum number of error messages to display. 0 for no limit. Default: 0.",
+    )
+    parser.add_argument(
+        "-x", "--exit-on-first-error", action="store_true", help="Exit instantly on the first error found."
+    )
+    parser.add_argument("--version", "-v", action="version", version=f"%(prog)s {__version__}")
     return parser
 
 
@@ -68,35 +80,49 @@ def run_from_cli() -> None:
     parser = setup_arg_parser()
     args = parser.parse_args()
 
-    logger = setup_logging(args.log_level)
-    console = Console(logger, is_silent=args.silent)
+    logger = setup_logging(args.log)
+    console = Console(logger, is_quiet=args.quiet, show_verdict=not args.no_verdict)
+    console.print(f"Level of logging: {args.log}", level=LogLevel.DEBUG)
     config = AppConfig(
         solution_path=args.solution_path,
         rules_path=args.rules_path,
-        log_level=args.log_level,
-        is_silent=args.silent,
-        stop_on_first_fail=args.stop_on_first_fail,
+        log_level=args.log,
+        is_quiet=args.quiet,
+        exit_on_first_error=args.exit_on_first_error,
+        max_messages=args.max_messages,
     )
+    console.print(f"Config is: {config}", level=LogLevel.TRACE)
 
     try:
         console.print(f"Starting validation for: {config.solution_path}", level=LogLevel.INFO)
         validator = StaticValidator(config, console)
+
+        console.print("Start of validation..", level=LogLevel.TRACE)
         is_valid = validator.run()
+        console.print(f"End of validation with result: {is_valid = }", level=LogLevel.TRACE)
 
         if is_valid:
-            console.print("Validation successful.", level=LogLevel.INFO)
+            console.print("Validation successful.", level=LogLevel.INFO, is_verdict=True)
             sys.exit(ExitCode.SUCCESS)
         else:
-            console.print("Validation failed.", level=LogLevel.ERROR)
+            console.print("Validation failed.", level=LogLevel.WARNING, is_verdict=True)
             sys.exit(ExitCode.VALIDATION_FAILED)
 
     except CodeValidatorError as e:
-        console.print(str(e), level=LogLevel.CRITICAL)
+        console.print(
+            f"Error: An internal validator error occurred: {e}", level=LogLevel.CRITICAL, show_user=True, exc_info=True
+        )
         sys.exit(ExitCode.VALIDATION_FAILED)
     except FileNotFoundError as e:
-        console.print(f"Error: File not found - {e.strerror}: {e.filename}", level=LogLevel.CRITICAL)
+        console.print(
+            f"Error: Input file not found: {e.filename}", level=LogLevel.CRITICAL, show_user=True, exc_info=True
+        )
         sys.exit(ExitCode.FILE_NOT_FOUND)
     except Exception as e:
-        console.print(f"An unexpected error occurred: {e}", level=LogLevel.CRITICAL)
-        logger.exception("Traceback for unexpected error:")
+        console.print(
+            f"Error: An unexpected error occurred: {e.__class__.__name__}. See logs for detailed traceback.",
+            level=LogLevel.CRITICAL,
+            show_user=True,
+            exc_info=True,
+        )
         sys.exit(ExitCode.UNEXPECTED_ERROR)

{python_code_validator-0.1.3 → python_code_validator-0.3.0}/src/code_validator/components/factories.py

@@ -10,9 +10,9 @@ rules file and instantiating the appropriate handler classes from the
 import dataclasses
 from typing import Any, Type, TypeVar
 
-from ..config import ConstraintConfig, FullRuleCheck, FullRuleConfig, SelectorConfig, ShortRuleConfig
+from ..config import ConstraintConfig, FullRuleCheck, FullRuleConfig, LogLevel, SelectorConfig, ShortRuleConfig
 from ..exceptions import RuleParsingError
-from ..output import Console
+from ..output import Console, log_initialization
 from ..rules_library.basic_rules import CheckLinterRule, CheckSyntaxRule, FullRuleHandler
 from ..rules_library.constraint_logic import (
     IsForbiddenConstraint,
@@ -71,6 +71,7 @@ class RuleFactory:
         _constraint_factory (ConstraintFactory): A factory for creating constraint objects.
     """
 
+    @log_initialization(level=LogLevel.TRACE)
     def __init__(self, console: Console):
         """Initializes the RuleFactory.
 
@@ -101,8 +102,10 @@ class RuleFactory:
                 required keys, or specifies an unknown type.
         """
         rule_id = rule_config.get("rule_id")
+        self._console.print(f"Start parsing rule ({rule_id}):\n{rule_config}", level=LogLevel.TRACE)
         try:
             if "type" in rule_config:
+                self._console.print(f"Rule {rule_id} is shorted rule - {rule_config['type']}", level=LogLevel.DEBUG)
                 config = _create_dataclass_from_dict(ShortRuleConfig, rule_config)
                 return self._create_short_rule(config)
 
@@ -110,20 +113,31 @@ class RuleFactory:
                 raw_selector_cfg = rule_config["check"]["selector"]
                 raw_constraint_cfg = rule_config["check"]["constraint"]
 
-                selector = self._selector_factory.create(raw_selector_cfg)
-                constraint = self._constraint_factory.create(raw_constraint_cfg)
-
                 selector_cfg = _create_dataclass_from_dict(SelectorConfig, raw_selector_cfg)
                 constraint_cfg = _create_dataclass_from_dict(ConstraintConfig, raw_constraint_cfg)
+
+                selector = self._selector_factory.create(selector_cfg)
+                constraint = self._constraint_factory.create(constraint_cfg)
+
+                self._console.print(
+                    f"Rule {rule_id} is general rule with: selector - "
+                    f"{selector_cfg.type}, constraint - {raw_constraint_cfg['type']}",
+                    level=LogLevel.DEBUG,
+                )
+
                 check_cfg = FullRuleCheck(selector=selector_cfg, constraint=constraint_cfg)
+                self._console.print(f"Create FullRuleCheck: {check_cfg}", level=LogLevel.TRACE)
+
                 config = FullRuleConfig(
                     rule_id=rule_config["rule_id"],
                     message=rule_config["message"],
                     check=check_cfg,
                     is_critical=rule_config.get("is_critical", False),
                 )
+                self._console.print(f"Create FullRuleConfig: {config}", level=LogLevel.TRACE)
                 return FullRuleHandler(config, selector, constraint, self._console)
             else:
+                self._console.print(f"Invalid syntax of rule: {rule_id}", level=LogLevel.WARNING)
                 raise RuleParsingError("Rule must contain 'type' or 'check' key.", rule_id)
         except (TypeError, KeyError, RuleParsingError) as e:
             raise RuleParsingError(f"Invalid config for rule '{rule_id}': {e}", rule_id) from e
@@ -165,21 +179,23 @@ class SelectorFactory:
     any state.
     """
 
+    @log_initialization(level=LogLevel.TRACE)
+    def __init__(self) -> None:
+        pass
+
     @staticmethod
-    def create(selector_config: dict[str, Any]) -> Selector:
+    def create(config: SelectorConfig) -> Selector:
         """Creates a specific selector instance based on its type.
 
         This method uses the 'type' field from the selector configuration
         to determine which concrete Selector class to instantiate.
 
         Args:
-            selector_config: The 'selector' block from a JSON rule.
+            config: The 'selector' block from a JSON rule.
 
         Returns:
             An instance of a class that conforms to the Selector protocol.
         """
-        config = _create_dataclass_from_dict(SelectorConfig, selector_config)
-
         match config.type:
             case "function_def":
                 return FunctionDefSelector(name=config.name, in_scope_config=config.in_scope)
@@ -210,21 +226,23 @@ class ConstraintFactory:
     to a list of AST nodes. This class uses a static `create` method.
     """
 
+    @log_initialization(level=LogLevel.TRACE)
+    def __init__(self) -> None:
+        pass
+
     @staticmethod
-    def create(constraint_config: dict[str, Any]) -> Constraint:
+    def create(config: ConstraintConfig) -> Constraint:
         """Creates a specific constraint instance based on its type.
 
         This method uses the 'type' field from the constraint configuration
         to determine which concrete Constraint class to instantiate.
 
         Args:
-            constraint_config: The 'constraint' block from a JSON rule.
+            config: The 'constraint' block from a JSON rule.
 
         Returns:
             An instance of a class that conforms to the Constraint protocol.
         """
-        config = _create_dataclass_from_dict(ConstraintConfig, constraint_config)
-
         match config.type:
             case "is_required":
                 return IsRequiredConstraint(count=config.count)

{python_code_validator-0.1.3 → python_code_validator-0.3.0}/src/code_validator/config.py

@@ -25,6 +25,7 @@ class ExitCode(IntEnum):
 class LogLevel(StrEnum):
     """Defines the supported logging levels for the application."""
 
+    TRACE = "TRACE"
     DEBUG = "DEBUG"
     INFO = "INFO"
     WARNING = "WARNING"
@@ -40,15 +41,17 @@ class AppConfig:
         solution_path: The file path to the Python solution to be validated.
         rules_path: The file path to the JSON rules file.
         log_level: The minimum logging level for console output.
-        is_silent: If True, suppresses all non-log output to stdout.
-        stop_on_first_fail: If True, halts validation after the first failed rule.
+        is_quiet: If True, suppresses all non-log output to stdout.
+        exit_on_first_error: If True, halts validation after the first failed rule.
+        max_messages: Maximum number of error messages to display. 0 for no limit. Default: 0.
     """
 
     solution_path: Path
     rules_path: Path
     log_level: LogLevel
-    is_silent: bool
-    stop_on_first_fail: bool
+    is_quiet: bool
+    exit_on_first_error: bool
+    max_messages: int = 0
 
 
 @dataclass(frozen=True)

{python_code_validator-0.1.3 → python_code_validator-0.3.0}/src/code_validator/core.py

@@ -45,9 +45,9 @@ import json
 from .components.ast_utils import enrich_ast_with_parents
 from .components.definitions import Rule
 from .components.factories import RuleFactory
-from .config import AppConfig, LogLevel
+from .config import AppConfig, LogLevel, ShortRuleConfig
 from .exceptions import RuleParsingError
-from .output import Console
+from .output import Console, log_initialization
 
 
 class StaticValidator:
@@ -64,9 +64,10 @@ class StaticValidator:
         _source_code (str): The raw text content of the Python file being validated.
         _ast_tree (ast.Module | None): The Abstract Syntax Tree of the source code.
         _rules (list[Rule]): A list of initialized, executable rule objects.
-        _failed_rules (list[int]): A list of rule IDs that failed during the run.
+        _failed_rules (list[Rule]): A list of rules that contained IDs of failed checks during the run.
     """
 
+    @log_initialization(level=LogLevel.DEBUG)
     def __init__(self, config: AppConfig, console: Console):
         """Initializes the StaticValidator.
 
@@ -77,14 +78,15 @@ class StaticValidator:
         """
         self._config = config
         self._console = console
+
         self._rule_factory = RuleFactory(self._console)
         self._source_code: str = ""
         self._ast_tree: ast.Module | None = None
         self._rules: list[Rule] = []
-        self._failed_rules: list[int] = []
+        self._failed_rules: list[Rule] = []
 
     @property
-    def failed_rules_id(self) -> list[int]:
+    def failed_rules_id(self) -> list[Rule]:
         """list[int]: A list of rule IDs that failed during the last run."""
         return self._failed_rules
 
@@ -95,14 +97,47 @@ class StaticValidator:
             FileNotFoundError: If the source file specified in the config does not exist.
             RuleParsingError: If the source file cannot be read for any other reason.
         """
-        self._console.print(f"Reading source file: {self._config.solution_path}")
+        self._console.print(f"Reading source file: {self._config.solution_path}", level=LogLevel.DEBUG)
         try:
             self._source_code = self._config.solution_path.read_text(encoding="utf-8")
+            self._console.print(f"Source code:\n{self._source_code}\n", level=LogLevel.TRACE)
         except FileNotFoundError:
+            self._console.print("During reading source file raised FileNotFound", level=LogLevel.TRACE)
             raise
         except Exception as e:
+            self._console.print("During reading source file raised some exception..", level=LogLevel.TRACE)
             raise RuleParsingError(f"Cannot read source file: {e}") from e
 
+    def _load_and_parse_rules(self) -> None:
+        """Loads and parses the JSON file into executable Rule objects.
+
+        This method reads the JSON rules file, validates its basic structure,
+        and then uses the `RuleFactory` to instantiate a list of concrete
+        Rule objects.
+
+        Raises:
+            FileNotFoundError: If the rules file does not exist.
+            RuleParsingError: If the JSON is malformed or a rule configuration
+                is invalid.
+        """
+        self._console.print(f"Loading rules from: {self._config.rules_path}", level=LogLevel.DEBUG)
+        try:
+            rules_data = json.loads(self._config.rules_path.read_text(encoding="utf-8"))
+            self._console.print(f"Load rules:\n{rules_data}", level=LogLevel.TRACE)
+            raw_rules = rules_data.get("validation_rules")
+            if not isinstance(raw_rules, list):
+                raise RuleParsingError("`validation_rules` key not found or is not a list.")
+
+            self._console.print(f"Found {len(raw_rules)}.", level=LogLevel.DEBUG)
+            self._rules = [self._rule_factory.create(rule) for rule in raw_rules]
+            self._console.print(f"Successfully parsed {len(self._rules)} rules.", level=LogLevel.DEBUG)
+        except json.JSONDecodeError as e:
+            self._console.print("During reading file of rules raised JsonDecodeError..", level=LogLevel.TRACE)
+            raise RuleParsingError(f"Invalid JSON in rules file: {e}") from e
+        except FileNotFoundError:
+            self._console.print("During reading file of rules raised FileNotFound", level=LogLevel.TRACE)
+            raise
+
     def _parse_ast_tree(self) -> bool:
         """Parses the loaded source code into an AST and enriches it.
 
@@ -114,45 +149,65 @@ class StaticValidator:
         Returns:
             bool: True if parsing was successful, False otherwise.
         """
-        self._console.print("Parsing Abstract Syntax Tree (AST)...")
+        self._console.print("Parsing Abstract Syntax Tree (AST)...", level=LogLevel.DEBUG)
         try:
+            self._console.print("Start parse source code.", level=LogLevel.TRACE)
             self._ast_tree = ast.parse(self._source_code)
             enrich_ast_with_parents(self._ast_tree)
             return True
         except SyntaxError as e:
+            self._console.print("In source code SyntaxError..", level=LogLevel.TRACE)
             for rule in self._rules:
                 if getattr(rule.config, "type", None) == "check_syntax":
-                    self._console.print(rule.config.message, level=LogLevel.ERROR)
-                    self._failed_rules.append(rule.config.rule_id)
+                    self._console.print(rule.config.message, level=LogLevel.ERROR, show_user=True)
+                    self._console.print(f"Failed rule id: {rule.config.rule_id}", level=LogLevel.DEBUG)
+                    self._failed_rules.append(rule)
                     return False
             self._console.print(f"Syntax Error found: {e}", level=LogLevel.ERROR)
             return False
 
-    def _load_and_parse_rules(self) -> None:
-        """Loads and parses the JSON file into executable Rule objects.
+    def _report_errors(self) -> None:
+        """Formats and prints collected validation errors to the console.
+
+        This method is responsible for presenting the final list of failed
+        rules to the user. It respects the `--max-messages` configuration
+        to avoid cluttering the terminal. If the number of found errors
+        exceeds the specified limit, it truncates the output and displays
+        a summary message indicating how many more errors were found.
+
+        The method retrieves the list of failed rules from `self._failed_rules`
+        and the display limit from `self._config`. All user-facing output is
+        channeled through the `self._console` object.
+
+        It performs the following steps:
+          1. Checks if any errors were recorded. If not, it returns immediately.
+          2. Determines the subset of errors to display based on the configured
+             `max_messages` limit (a value of 0 means no limit).
+          3. Iterates through the selected error rules and prints their
+             failure messages.
+          4. If the error list was truncated, prints a summary line, e.g.,
+             "... (5 more errors found)".
+        """
+        max_errors = self._config.max_messages
+        num_errors = len(self._failed_rules)
 
-        This method reads the JSON rules file, validates its basic structure,
-        and then uses the `RuleFactory` to instantiate a list of concrete
-        Rule objects.
+        if num_errors == 0:
+            return None
 
-        Raises:
-            FileNotFoundError: If the rules file does not exist.
-            RuleParsingError: If the JSON is malformed or a rule configuration
-                is invalid.
-        """
-        self._console.print(f"Loading rules from: {self._config.rules_path}")
-        try:
-            rules_data = json.loads(self._config.rules_path.read_text(encoding="utf-8"))
-            raw_rules = rules_data.get("validation_rules")
-            if not isinstance(raw_rules, list):
-                raise RuleParsingError("`validation_rules` key not found or is not a list.")
+        errors_to_show = self._failed_rules
+        if 0 < max_errors < num_errors:
+            errors_to_show = self._failed_rules[:max_errors]
 
-            self._rules = [self._rule_factory.create(rule) for rule in raw_rules]
-            self._console.print(f"Successfully parsed {len(self._rules)} rules.")
-        except json.JSONDecodeError as e:
-            raise RuleParsingError(f"Invalid JSON in rules file: {e}") from e
-        except FileNotFoundError:
-            raise
+        for rule in errors_to_show:
+            self._console.print(rule.config.message, level=LogLevel.WARNING, show_user=True)
+
+        if 0 < max_errors < num_errors:
+            remaining_count = num_errors - max_errors
+            self._console.print(
+                f"... ({remaining_count} more error{'s' if remaining_count > 1 else ''} found)",
+                level=LogLevel.WARNING,
+                show_user=True,
+            )
 
     def run(self) -> bool:
         """Runs the entire validation process from start to finish.
@@ -172,22 +227,46 @@ class StaticValidator:
             self._load_and_parse_rules()
 
             if not self._parse_ast_tree():
+                self._report_errors()
                 return False
 
-        except (FileNotFoundError, RuleParsingError):
+            self._console.print("Lead source code, load and parse rules and parsing code - PASS", level=LogLevel.DEBUG)
+
+        except (FileNotFoundError, RuleParsingError) as e:
+            self._console.print(
+                f"In method `run` of 'StaticValidator' raised exception {e.__class__.__name__}", level=LogLevel.WARNING
+            )
             raise
 
+        self._console.print("Starting check rules..", level=LogLevel.DEBUG)
         for rule in self._rules:
             if getattr(rule.config, "type", None) == "check_syntax":
                 continue
 
-            self._console.print(f"Executing rule: {rule.config.rule_id}", level=LogLevel.DEBUG)
+            self._console.print(
+                f"Executing rule: {rule.config.rule_id}"
+                + (
+                    f" [{rule.config.check.selector.type}, {rule.config.check.constraint.type}, "
+                    f"is_critical={rule.config.is_critical}]"
+                    if not isinstance(rule.config, ShortRuleConfig)
+                    else ""
+                ),
+                level=LogLevel.INFO,
+            )
             is_passed = rule.execute(self._ast_tree, self._source_code)
             if not is_passed:
-                self._console.print(rule.config.message, level=LogLevel.ERROR)
-                self._failed_rules.append(rule.config.rule_id)
-                if getattr(rule.config, "is_critical", False) or self._config.stop_on_first_fail:
+                self._failed_rules.append(rule)
+                # self._console.print(rule.config.message, level=LogLevel.WARNING, show_user=True)
+                self._console.print(f"Rule {rule.config.rule_id} - FAIL", level=LogLevel.INFO)
+                if getattr(rule.config, "is_critical", False):
                     self._console.print("Critical rule failed. Halting validation.", level=LogLevel.WARNING)
                     break
+                elif self._config.exit_on_first_error:
+                    self._console.print("Exiting on first error.", level=LogLevel.INFO)
+                    break
+            else:
+                self._console.print(f"Rule {rule.config.rule_id} - PASS", level=LogLevel.INFO)
+
+        self._report_errors()
 
         return not self._failed_rules