Neosoft-Private-Limited/flutter_template

This system is a multi-package Flutter application framework designed to enforce clean architecture and modular development. It provides a standardized infrastructure for state management (BLoC and Riverpod), dependency injection, and cross-platform configuration. The codebase includes reusable core modules for data persistence, network communication, and theming, all structured to support scalable mobile and web application development.

The app/scripts directory now contains a suite of shell scripts to streamline the development workflow and CI/CD pipeline. Developers can use scripts like build.sh and run.sh to easily trigger Flutter builds and runs for different environments (dev, qa, prod) and build types. For CI/CD, new scripts handle version bumping, committing version changes, and setting environment variables for GitHub Actions, including an install\_certs.sh script to manage Apple certificates and provisioning profiles on macOS runners.

app/scripts · high confidence

The \infrastructure/network-retrofit\ package now includes a new network layer built on \dio\ and \retrofit\. This introduces a \NetworkModule\ that configures a \Dio\ HTTP client with a \PrettyDioLogger\ and interceptors, and registers a \RetrofitService\ and \NetworkAdapter\ as singletons or lazy singletons via the \injectable\ and \get\_it\ packages. A \NetworkDependencyConfigurator\ is provided to wire these dependencies into the application's dependency injection container, making the network client and its associated services available for use throughout the application.

infrastructure/network-retrofit · high confidence

Introduced the new splash screen feature, comprising the page, view, and view model components. The splash page now automatically navigates to the dashboard after a 2-second delay. The implementation integrates with the application's dependency injection and state management systems, and includes an exception handler binder to manage runtime errors during the splash phase.

app/lib/feature/splash · high confidence

The core/data, core/domain, and core/shared modules now include standard project scaffolding files: .gitignore, CHANGELOG.md, README.md, and analysis\_options.yaml. Each module also contains example and test files, providing a consistent structure for development and static analysis across the core layers.

core · high confidence

The app/web directory now includes the standard Flutter web scaffolding: an index.html template that bootstraps the Flutter engine and a manifest.json defining the app's metadata, icons, and PWA capabilities. This enables the application to run as a standalone web app with proper icons and title.

app/web · high confidence

The app directory is initialized with essential configuration files. A \.gitignore\ file is added to exclude build artifacts, IDE settings, and secret files (except for a skeleton secrets file). A \.metadata\ file is introduced to track Flutter project properties and migration state. Additionally, an \analysis\_options.yaml\ file is created to configure static code analysis, including lints from \flutter\_lints\ and exclusions for generated files.

app · high confidence

The repository was initialized with essential configuration files, including a \.gitignore\ to exclude generated and build artifacts, a \melos.yaml\ to manage the multi-package Flutter project structure, and a \sonar-project.properties\ file for code quality analysis. Additionally, a \CONTRIBUTING.md\ file was added to guide community contributions, and the \README.md\ was updated with comprehensive documentation on the project's architecture, setup, and usage.

(repo-wide) · high confidence

The infrastructure layer now includes two new packages, database-floor and network-retrofit, each at version 1.0.0. These packages provide the foundational components for database and network operations respectively, complete with standard project scaffolding (README, CHANGELOG, analysis options) and example/test files to demonstrate usage.

infrastructure · high confidence

The localisation module is introduced as a new component for managing app translations. It provides a Flutter Intl-based solution that generates Dart code from .arb files, offering a \Strings\ class and \AppLocalizationDelegate\ to handle English (en) locale support. The change includes the necessary generated code, configuration files (analysis\_options, gitignore), and documentation (README, CHANGELOG) to enable internationalization in the application.

localisation · high confidence

The statemanagement-bloc package is introduced, providing a foundational structure for state management using the BLoC pattern. It includes base classes for events, states, and view models, along with a Flutter widget that automatically provides the BLoC to the widget tree. An example application and corresponding unit tests are also included to demonstrate usage.

services, statemanagement-bloc · high confidence

The statemanagement-core module has been introduced, providing a reusable base page state class for Flutter applications. This new component simplifies screen implementation by offering a default Scaffold layout, automatic lifecycle observation, and a structured way to manage view models. Users can now extend CoreBasePageState to quickly create screens with consistent navigation handling, app bar, drawer, and bottom navigation bar support, along with a changelog and example code.

statemanagement-core · high confidence

A new 'themes' package has been added to the project, providing a \ThemeBuilder\ widget and a \ThemeManager\ to handle light/dark mode switching, multiple theme support, and status bar color updates. The package includes a \ThemeService\ for non-UI code access, integrates with \shared\_preferences\ for theme persistence, and registers its dependencies via an Injectable DI module.

themes · high confidence

The library now provides foundational components for building pages and view models using Riverpod. This includes a \BaseWidget\ that wraps a \Consumer\ to manage a model's lifecycle, abstract classes for \BasePage\ and \BaseViewModel\ to standardize page structure, and an example entry point. These additions enable developers to create consistent, reusable page implementations with integrated state management.

statemanagement-riverpod/lib · high confidence

Adds a new dependency injection module that enforces construction-based dependency injection using the GetIt service locator. The change introduces core abstractions including the \DependencyConfigurator\ interface and \DependencyConfigurationContext\ to manage dependency registration, alongside example code and a basic test suite to demonstrate the pattern.

dependency-injection · high confidence

The core/domain module now exposes a new domain layer that separates concerns by defining repository contracts (e.g., UserRepository) and use-case abstractions (e.g., LoginUseCase). Users interacting with the application will see a structured approach to user authentication, where the LoginUseCase handles email/phone and password validation, leveraging the UserRepository for data operations. This change introduces a clear separation between domain logic and infrastructure, enabling easier testing and maintenance of the login flow.

core/domain · high confidence

The app now supports distinct configurations for development, QA, and production environments, each with its own API base URL and secrets. A new error handling system has been introduced, featuring multiple error presenters (toast, snackbar, and alert) that display user-friendly messages based on the exception type. Additionally, a generic Resource wrapper and RequestManager are added to standardize the handling of loading, success, and error states across the application.

app/lib · high confidence

Adds a new local database layer using the Floor library, defining the AppDatabase schema with a User entity and a corresponding UserDao for data access. The change includes database configuration, migration support for schema versioning, and a persistence adapter that implements the DatabasePort interface to bridge the local storage with the application's data layer.

infrastructure/database-floor · high confidence

The core/shared module now includes a new set of classes and utilities for managing application errors and data transformation. This includes an ErrorType enum and an ErrorInfo model to represent error details, alongside an AppError class that wraps exceptions with specific error types. The module also introduces a BaseLayerDataTransformer abstract class and a LayerDataTransformer interface to facilitate data transformation between different layers, as well as a Validator utility for email validation and empty string checks. These changes provide a standardized way to handle errors and transform data within the application.

core/shared · high confidence

The iOS native project has been initialized with standard Flutter configuration files, including the Xcode project structure, workspace settings, and build schemes for development, QA, and production environments. This includes the necessary manifest files, resource assets, and build configurations required to compile and run the app on iOS devices.

app/ios · high confidence

A new pre-commit hook has been added to the app/scripts/hooks directory. This script automatically runs static analysis using Melos before each commit. If the analysis fails, it attempts to fix issues using 'dart fix' and 'flutter format' via Melos, ensuring code quality and consistency across the multi-package project.

app/scripts/hooks · high confidence

The core/data module now provides a structured data layer built on a ports-and-adapters architecture. New abstractions (DatabasePort, NetworkPort) define the interface for data access, while UserRepositoryImpl implements these ports to handle user-related operations. A new DataModule registers the repository as a lazy singleton, and a DataDependencyConfigurator wires up the dependency injection using the injectable and get\_it packages. This change shifts the data layer toward a more modular, testable structure by separating concerns and explicitly configuring dependencies.

core/data · high confidence

Added placeholder test for state management; Added smoke test for the main application widget.

Added the foundational build configuration files for the Android and iOS platforms, including Gradle scripts and Podfile, alongside the main application's pubspec.yaml and its internal module manifests. This establishes the project's dependency graph, specifying versions for libraries such as Flutter, Riverpod, Bloc, and various internal path-based packages, effectively defining the technical stack and environment constraints for the application.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 54 → 65 (+11.0)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 100 → 94 (-6.4)
• Architecture 100 → 92 (-8.5)
• Maturity 50 → 66 (+16.4)
• Readiness 46 → 55 (+9.2)
• Security 45 → 66 (+20.5)
• Domain Modelling 100 → 100 (+0.0)

• Coverage not included — suite not readable by the collector
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• LLM evaluation failed
• No exposed public API
• PR-triggered workflow without a permissions block
• Test reliability not included
• complexity unreadable for .dart, .kt, .swift — churn × complexity hotspots could not be measured
• …and 1 more

• Dependency hygiene PARTLY measured — Maven/Gradle declarations read, no dependency graph resolved
• Documentation: no contributor guidance (README.md)
• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• Low cohesion: CoreBasePageState (LCOM4 5) (statemanagement-core/lib/src/base_page_state.dart)
• Low cohesion: _ThemeBuilderState (LCOM4 4) (themes/lib/src/theme_builder.dart)
• …and 27 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

Neosoft-Private-Limited/flutter_template was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.