NeoPHP

The `Application` module is the entry point for every NeoPHP project. It is responsible for detecting the active application (based on the HTTP or CLI context), registering standard paths in the dependency container, and managing the project lifecycle through dedicated commands.

The `Asset` module manages the static file processing pipeline (CSS, JS, LESS) in NeoPHP. It automatically compiles, minifies and versions assets depending on the environment, exposes an `asset()` Twig function for views, and provides a CLI command to force recompilation.

The `Console` module is NeoPHP's CLI infrastructure. It provides the command discovery and execution engine, a typed input/output system, interactive helpers (questions, choices, confirmation, hidden input), colored terminal rendering, and a command generator.

The `Controller` module provides the base class for every web and API controller in a NeoPHP project. It relies on a dynamic extension system to inject methods and properties (such as `render()`, `redirectToRoute()`, `json()`, etc.) without rigid inheritance, through the `ExtensionManager` mechanism.

The `Cron` module allows scheduling and running recurring tasks in NeoPHP. Jobs are declared via a PHP attribute directly on class methods, discovered through automatic scanning, and run based on a standard 5-field cron expression. The module supports job locking, timezone handling, and integrates with the framework's logging system.

The `DI` (Dependency Injection) module is the heart of the NeoPHP framework. It provides an IoC (Inversion of Control) container compliant with the PSR-11 specification, capable of automatically resolving dependencies through reflection, managing singletons, interface bindings, tags, and calling callables with auto-wiring.

This module provides the entire data access layer of the NeoPHP framework: a complete Data Mapper ORM, a migration system, a form manager, and low-level database access.

The `Error` module centralizes the capture, logging, dispatching, and rendering of every error and exception occurring in NeoPHP. It distinguishes between `dev` environments (full trace) and `prod` environments (generic, safe message), and integrates with the Logger, Event, and View modules.

The `Event` module implements an event system (pub/sub) for NeoPHP. It allows decoupling components by emitting events that listeners can intercept, with priority handling, propagation stopping, automatic discovery via PHP 8 attribute, a subscriber interface, and caching in production.

The `Extension` module provides an automatic discovery and application mechanism for extensions targeting two contexts: **controllers** (`AbstractController`) and **Twig views**. It relies on the PHP 8 `#[Extension]` attribute and a recursive scan of the source code.

`Neo\Core\Http\Client\Cookie\Cookie` encapsulates PHP cookie management with automatic prefixing and centralized configuration.

`Neo\Core\Http\Client\Flash\Flash` handles ephemeral messages stored in the session and consumed on the next read (flash message pattern).

`Neo\Core\Http\Client\Session\Session` encapsulates the native PHP session with centralized configuration and a silent no-op behavior in CLI.

The `File` submodule handles secure file uploads. It relies on `UploaderManager` to validate, move, and name uploaded files.

`Neo\Core\Http\HttpClient\HttpClientManager` is a cURL-based HTTP client for making outbound requests. It returns a standard `Response` object, which allows using `toArray()` to directly decode JSON responses.

The `Http` module covers the entire request/response cycle of NeoPHP: incoming request abstraction, HTTP response types, session management, flash messages, cookies, and file uploads.

`Neo\Core\Http\Request\Request` is the immutable object representing the incoming HTTP request. The constructor is private; instances are created exclusively via static methods.

The `Response` sub-module covers the three types of HTTP responses and the `ResponseManager` that exposes them through the container and controllers.

The `Module` subsystem is the entry point for every feature of the NeoPHP framework. It defines a uniform contract (`ModuleInterface`) that every component must follow, and provides a manager (`ModuleManager`) capable of automatically discovering, ordering, and initializing every module present in the project.

The `Profiler` module is a visual debugging tool built into NeoPHP. It collects request metrics (duration, memory, SQL queries, events, routes, logs, authenticated user...) and displays them in a floating debug bar automatically injected into the HTML of responses, only in the `dev` environment.

The `Routing` module is responsible for matching incoming HTTP requests to PHP controller methods. It relies on **PHP 8 attributes** to declare routes directly on classes and methods, manages a cache system for production, and exposes helpers in controllers and Twig views.

The `Auth` submodule handles user authentication via PHP session or JWT token, role verification, and password hashing.

The `Csrf` submodule protects forms and HTTP requests against Cross-Site Request Forgery attacks via session tokens.

The `Middleware` submodule provides a declarative, attribute-based authorization pipeline for PHP 8, with built-in middlewares and support for custom middlewares.

The `Security` module brings together three complementary subsystems that secure NeoPHP applications:

The Testing module provides the complete testing infrastructure for NeoPHP applications. It builds on PHPUnit and offers four specialized base classes, a PHP 8 attribute system for declaring tests directly on business classes, as well as an automatic test file generator.

Lightweight Markdown parser with no external dependencies. Converts Markdown text (or a `.md` file) into an array of `AbstractBlock` objects, usable directly in Twig templates via the `markdown_blocks()` function and the `md_inline` filter.

The Translation module provides a complete internationalization (i18n) system for NeoPHP applications. It handles automatic locale resolution, loading of PHP translation files by domain, automatic writing of missing keys in development mode, as well as native integration with Twig and the Profiler.

The `Cache` submodule provides a caching system with several interchangeable drivers via a common interface.

The `Config` submodule loads, exposes, and allows modification of a project's PHP configuration files.

The `Logger` submodule provides a structured logging system with support for RFC 5424 levels, named channels, file rotation, and automatic archiving.

The `Notification` submodule provides a multi-channel sending system (Email, Slack, SMS) with a fluent builder pattern and automatic Profiler integration.

The `Utils` module brings together the framework's cross-cutting utilities: cache, configuration, logging, multi-channel notifications, and PHP attribute scanner.

The `Scanner` submodule provides a reflection tool for discovering and reading PHP 8 attributes on a class, its methods, its properties, and its methods' parameters.

The Validator module provides a validation system based on **PHP 8 attributes** (`#[Attribute]`). Constraints are placed directly on the properties of models or objects. The `ValidatorManager` inspects these attributes via reflection and returns an array of errors per field.

The View module integrates the **Twig** template engine into NeoPHP. It exposes the `ViewManager` for rendering templates, an extension system allowing Twig functions and filters to be added from any module, and a controller extension that injects the `render()` and `template()` methods directly into controllers.