deveminsahin/starter_app

This is a cross-platform Flutter application scaffolding system that enforces a strict Clean Architecture with Domain-Driven Design principles. It provides a comprehensive foundation for building features, including automated code generation, a structured dependency injection system, and robust error handling. The system supports multi-environment configuration, real-time communication via WebSockets, and full internationalization for English and Spanish.

Users can now access a new Settings page to customize their experience. This includes selecting a light, dark, or system theme, switching the app language between English and Spanish, and logging out of the account. The feature includes full localization support for English and Spanish, with UI components for theme selection, language switching, and an authenticated-user-only logout button.

lib/features/settings · high confidence

Introduced the infrastructure layer for the new authentication feature, including a Chopper-based API service for endpoints like login, register, and token refresh, along with remote data sources and WebSocket support for real-time auth state changes. Added data models for auth responses, tokens, and request payloads, and an exception mapper to translate server errors into domain-specific authentication failures.

lib/features/auth/infrastructure · high confidence

Introduces a set of reusable UI components and a presentation model for error handling. The new \ErrorModel\ wraps domain failures to provide UI-friendly access to error information, including retry logic and localized messages via \FailureMessageService\. The widget library adds \AppTextField\ as a domain-agnostic text input with theme-driven styling, validation, and optional obscuring. Specific fields \EmailTextField\ and \PasswordTextField\ extend the base field with email/password-specific behaviors, validation, and visibility toggles. Additional utilities include \AppSnackBar\ for consistent messaging and \LoadingOverlay\ for blocking interactions during loading states. The \AdaptiveNavigationScaffold\ provides responsive navigation patterns (bottom bar, rail, drawer) based on screen size.

lib/core/presentation/widgets · high confidence

Users now have access to a new dashboard landing page that displays a responsive grid of colored boxes, adapting its column count to different screen sizes. The feature includes full localization support for English and Spanish, allowing the app bar title to be translated. The dashboard is integrated into the main shell navigation as a bottom tab bar item, providing a central hub for authenticated users.

lib/features/dashboard · high confidence

The project now includes the standard Flutter platform templates for Android, Web, and Windows. On Android, this adds the main and debug AndroidManifest files, the MainActivity, and the default launch splash screen styles. For the web, the entry point and a PWA manifest with default icons are provided. On Windows, the CMake build configuration, plugin registrant, and native window handling code are added. These files establish the baseline build and runtime environment for each target platform.

android, web, windows · high confidence

The application now includes new domain-layer value objects for validating user input: \EmailAddress\, \Name\, and \Password\. Each object enforces specific rules—such as email format, name length limits, and password complexity requirements—and returns structured failure types (e.g., \EmailTooLong\, \PasswordMissingUppercase\) to provide clear, specific error messages to the user.

_lib/core/domain/value\objects · high confidence

The authentication feature is introduced, providing application-layer use cases for checking if a user exists, retrieving the current user, logging in, logging out, refreshing tokens, registering new users, and watching authentication state changes. To support these flows, English and Spanish localization files are added, covering labels, error messages, and button text for the auth screens.

lib/features/auth/application, lib/features/auth/l10n · high confidence

The presentation layer now includes a new failure message mapping system that translates domain and infrastructure failures into user-friendly, localized messages. This includes specific mappers for email, name, and password validation failures, as well as a central mapper for infrastructure errors (server, network, cache, parse, circuit breaker, and unexpected errors). The system uses an automatic registration mechanism where each mapper registers itself with a central registry, ensuring feature-specific mappers take precedence over generic infrastructure mappers.

_lib/core/presentation/failure\message · high confidence

Added new exception classes for the infrastructure layer, including CacheException, CircuitBreakerException, NetworkException, and ServerException. These exceptions are designed to be thrown in data sources and caught in repositories, where they are converted into corresponding InfrastructureFailure types.

lib/core/error/exceptions · high confidence

A new Orders feature is introduced, providing a dedicated page and navigation route for order management. The OrdersPage widget displays a title and body text using localizations, while the OrdersRoute configures the GoRouter path and name to navigate to this page.

lib/features/orders/presentation · medium confidence

A new shared error page has been added to the core presentation layer to handle 404 and other routing errors. This page provides a consistent user experience for unexpected errors, featuring a localized title, error icon, and a button to navigate back to the dashboard. The implementation uses Flutter's TextTheme.of and ColorScheme.of constructors for theming and includes localization support for error messages.

lib/core/presentation/pages · high confidence

Users can now view and manage their profile information. This feature includes a domain model for user profiles, a repository to fetch profile data, and a presentation layer that displays the user's name and allows navigation to a profile page. The implementation follows a clean architecture with separate domain, application, and infrastructure layers, and supports localization for error messages in English and Spanish.

lib/features/profile · high confidence

The Orders feature has been introduced, providing a protected route accessible only when authenticated. This includes a typed route definition using \TypedGoRoute\ for compile-time safety, along with full English and Spanish localization support. The feature also includes a barrel export for the module.

lib/features/orders · high confidence

Introduced new Mason bricks to automate the creation of feature scaffolding templates. This includes templates for BLoC state management, domain entities, repository interfaces and implementations, API services, and presentation layers. The generated code follows the project's architecture guidelines, including the use of freezed for state management and CQRS patterns for use cases. A post-generation hook automatically runs the build runner to generate necessary files.

(repo-wide) · high confidence

Introduced \ThemeCubit\ and \LocaleCubit\ in \lib/core/presentation/bloc/\ to manage application-wide UI state (theme mode and locale) with automatic persistence via \HydratedCubit\. The directory also includes \AppBlocObserver\ for logging BLoC events and state changes, and a barrel export file (\bloc.dart\) to centralize access to these components. This change establishes a clean separation where presentation state management is isolated from domain logic, with configuration data remaining in their respective \core/theme/\ and \core/l10n/\ directories.

lib/core/presentation/bloc · high confidence

Added README.md and example JSON files (development, staging, production) to the config directory. These templates support environment-specific configuration via --dart-define-from-file, with actual config files gitignored for security. The documentation explains setup, usage, and CI/CD integration for each environment.

config · high confidence

Introduced a new error reporting system for the application, featuring a \NoOpErrorReporter\ for development environments that logs to the console, and a \SentryErrorReporter\ for staging and production environments. The Sentry implementation automatically filters sensitive data, maps severity levels, and handles user context, while remaining disabled in development to prevent external data transmission.

lib/core/error/reporters · high confidence

The infrastructure layer now includes concrete implementations for core domain ports, enabling the application to interact with external systems. This includes platform-specific HTTP clients with SSL pinning support, secure and token storage adapters, a circuit breaker for network resilience, session and token refresh event management, and a full WebSocket infrastructure supporting multiple concurrent connections with automatic reconnection and reconnection strategies.

lib/core/infrastructure · high confidence

The Orders feature now supports English and Spanish. Users will see the app bar title and body text translated into their preferred language, with English ('Orders', 'Deeplink protected route') and Spanish ('Pedidos', 'Ruta protegida por enlace profundo') strings provided via new localizations files.

lib/features/orders/l10n · high confidence

The app now supports English and Spanish translations for core UI elements and domain-specific validation errors, including messages for password, email, and name validation, as well as generic error states like network, server, and circuit breaker failures. This enables users to see interface text and error messages in their preferred language.

lib/core/l10n · high confidence

A new shell script has been added to automate the generation of Dart localization files for each feature (Auth, Dashboard, Profile, Settings, Orders) as well as the core app. Running this script triggers Flutter's localization generation for each module, ensuring that localizations are built from their respective ARB files into corresponding Dart classes.

scripts · high confidence

The application now provides a unified set of constants for UI design and API configuration. This includes standardized values for HTTP headers, network retry and timeout settings, pagination, and query parameters. For the user interface, it introduces consistent sizing and spacing constants for elements like buttons, avatars, cards, and dialogs, along with pre-computed widgets for padding, spacing, and border radius to ensure visual consistency across the app.

lib/core/constants · high confidence

The application now uses a structured dependency injection setup for core services, organizing BLoC observers, error reporting, logging, navigation, network clients, platform info, and storage into dedicated modules. This provides a global BLoC observer for debugging, environment-specific error reporters (NoOp in dev, Sentry in staging/prod), a console logger, a GoRouter-based navigation system, a Chopper HTTP client with interceptors (auth, refresh, circuit breaker), and secure/shared preferences storage.

lib/core/di/modules · high confidence

The API layer now includes a suite of HTTP client interceptors for the Chopper HTTP client. These provide automatic Bearer token authentication, API key injection, and automatic access token refresh on 401 responses. Resilience is handled via a circuit breaker pattern and standardized error conversion to domain exceptions. Additionally, all HTTP traffic is logged with automatic redaction of sensitive headers and body fields, and network errors are consistently mapped to a \NetworkException\.

lib/core/api · high confidence

The application now supports light and dark themes using Material Design 3 principles via the FlexColorScheme library. Users can switch between light, dark, and system default modes, with the app's color palette, typography, and component styling (buttons, cards, dialogs) updated to follow the new design system. The theme configuration is centralized in the \lib/core/theme\ directory, providing consistent visual feedback for states like success, warning, and error across both themes.

lib/core/theme · high confidence

The application layer is now a distinct module in \lib/core/application\, providing centralized orchestration for app startup and runtime behavior. \BootstrapService\ coordinates the initialization of state persistence, BLoC observers, and SSL certificates. \AppMonitoringService\ handles Sentry SDK initialization and startup diagnostics, while \AppErrorHandlingService\ configures global error handlers for Flutter, platform, and zone errors. Additionally, \AppNavigationLoggingService\ subscribes to navigation events to log route changes, and \AppEnvironment\ manages compile-time configuration for development, staging, and production environments.

lib/core/application · high confidence

Added the foundational domain model for the authentication feature, including the \User\ and \AuthCredentials\ entities, along with value objects for \AuthToken\ and \RefreshToken\. This change introduces the \IAuthRepository\ interface defining the contract for login, registration, and session management, as well as domain events (\UserLoggedIn\, \UserRegistered\, etc.) and failure types (\AuthFailure\, \TokenFailure\) to handle authentication-specific errors.

lib/features/auth/domain · high confidence

Added a new error handling module in \lib/core/error\ that provides a generic \ExceptionHandler\ for converting infrastructure exceptions (e.g., \ServerException\, \NetworkException\) into domain-specific \Failure\ types. The module includes a \SensitiveDataFilter\ that automatically redacts sensitive fields (such as passwords, tokens, and API keys) before error data is sent to external reporting systems like Sentry. Additionally, an \IExceptionMapper\ interface is introduced to allow feature-specific mapping of HTTP status codes to domain failures.

lib/core/error · high confidence

Added a new feature flag infrastructure in lib/core/feature\_flags that allows the application to toggle capabilities such as dark mode, push notifications, and analytics via a central service. The system supports a three-tier priority: local development overrides, remote configuration values, and default enum values. It includes an interface (IFeatureFlagService) and a concrete implementation (FeatureFlagService) that integrates with remote config services like Firebase or LaunchDarkly, while restricting debug-only override methods to debug mode for security.

_lib/core/feature\flags · high confidence

Users can now log in or register using an email-first flow, where the app checks if the email exists to show either a login or registration form. The feature provides full authentication capabilities including login, registration, token refresh, and logout, managed via a BLoC state machine. It supports secure token storage, automatic token refresh, and real-time session updates via WebSocket, with all domain, application, and infrastructure layers co-located in the auth feature directory.

lib/features/auth · high confidence

Added the presentation layer for the authentication feature, including the AuthBloc to manage login, registration, and session state, along with the corresponding AuthEvent and AuthState classes. The new AuthPage provides a responsive form interface that switches between email entry, login, and registration views, while a dedicated mapper converts auth-specific failures into user-friendly, localized error messages.

lib/features/auth/presentation · high confidence

Added a comprehensive responsive design system for the presentation layer, including an \AdaptiveLayoutBuilder\ widget, a \ScreenSize\ enum with five breakpoints (compact, medium, expanded, large, extra-large), and \BuildContext\ extensions for querying screen size and retrieving responsive padding, spacing, and grid column counts. The system also provides ready-to-use widgets like \ResponsiveContainer\, \ResponsiveGrid\, \ResponsivePadding\, and \ResponsiveSpacing\ that automatically adapt to the current screen size, enabling developers to build adaptive UIs that follow Material Design 3 guidelines.

lib/core/presentation/responsive · high confidence

The application now uses a structured dependency injection system via GetIt and Injectable, with a generated configuration file and modular organization (BLoC, error, logging, navigation, network, platform, and storage modules). This enables automatic registration of dependencies, environment-specific registrations (development, staging, production), and lifecycle management (singleton, lazy singleton, factory) for improved testability and separation of concerns.

lib/core/di · high confidence

Developers can now use a unified \IAppLogger\ interface to log messages across the application. The system is environment-aware: in development, logs are printed to the console with color-coding and emojis; in staging and production, errors are automatically reported to Sentry. The logging model includes five severity levels (debug, info, warning, error, fatal) and supports structured data and tags for better traceability.

lib/core/logging · high confidence

The application now uses a typed error handling system where errors are returned as values rather than thrown as exceptions. A new \Failure\ base class and a \TechnicalFailure\ abstract class (with \isRetryable\ and \stackTrace\ properties) have been introduced. Specific error types like \InfrastructureFailure\ (covering server, network, cache, parse, circuit breaker, and unexpected states) and \ValueFailure\ (for domain validation) are now available for pattern matching in the UI and repository layers.

lib/core/error/failures · high confidence

The domain layer now includes a comprehensive set of base classes and interfaces to support Domain-Driven Design (DDD) and CQRS patterns. This includes \Command\ and \Query\ base classes for write and read operations respectively, as well as \Entity\, \AggregateRoot\, and \DomainEvent\ foundations. An \IEventDispatcher\ interface and \EventDispatcher\ implementation are added to enable decoupled, event-driven communication between features. Additionally, a \Specification\ pattern base class is introduced for encapsulating business rules, and \UniqueId\ with format validation is provided for consistent identifier handling.

lib/core/domain/base · high confidence

Users will now see localized, user-friendly error messages for domain failures. A new FailureMessageService translates technical failures into readable text using a registry of mappers, and a new BuildContext extension provides a convenient showSnackBar method to display these messages in the UI.

lib/core/presentation/extensions, lib/core/presentation/services · medium confidence

Added new port interfaces in the domain layer to decouple infrastructure dependencies. This includes \ICertificateService\ for SSL/TLS certificate management, \IErrorReporter\ for production error tracking and crash reporting, \IDataFilter\ for sanitizing sensitive data, \IMonitoringInitializer\ for SDK initialization, \INavigationTrackingService\ for unified navigation events, \IPlatformInfo\ for cross-platform details, \ISecureStorage\ for secure key-value storage, \ISessionManager\ for session lifecycle events, \ITokenRefreshNotifier\ for token refresh events, \ITokenStorage\ for authentication tokens, and \IWebSocketConnection\/\IWebSocketManager\ for managing WebSocket connections. These interfaces define contracts that allow the application layer to interact with infrastructure implementations without direct coupling.

lib/core/domain/ports · high confidence

The iOS and macOS native project files have been added to the repository, establishing the standard Flutter build configurations, Xcode project structures, and default app icons. This includes the Xcode workspace and scheme files, build configuration files (Debug/Release), and asset catalogs for launch screens and application icons, enabling the project to be built and run on iOS and macOS out of the box.

ios, macos · high confidence

The application now uses a shared \bootstrap\ function in \lib/bootstrap.dart\ to initialize the Flutter engine, configure dependency injection, set up error tracking (Sentry), and handle global errors. This is invoked by new environment-specific entry points (\main\_development.dart\, \main\_staging.dart\, and \main\_production.dart\), each configuring the app for its respective environment (development, staging, or production) with distinct settings for logging, API URLs, and error tracking.

lib · high confidence

The navigation module now includes a centralized \NavigationTrackingService\ that captures all navigation events—including shell branch switches and in-branch pushes—through a single stream for logging and analytics. Additionally, the \AppRouter\ now supports reactive authentication-based redirects via \AuthChangeNotifier\, ensuring that users are automatically redirected to or from the login page when the authentication state changes.

lib/core/navigation · high confidence

A new file, lib/core/types/types.dart, has been added to the application's core types. This file introduces several type aliases, including Json, JsonList, Result, FutureResult, StreamResult, VoidResult, FutureVoidResult, TypedResult, FutureTypedResult, and DependencyResolver. These aliases are designed to improve code readability and provide semantic meaning to commonly used types, particularly for functional programming patterns with Either types. This change is a behavioral change as it modifies the existing codebase by adding new type definitions.

lib/core/types · high confidence

The application now includes the OrdersLocalizations delegate in the root MaterialApp configuration. This ensures that the Orders feature's user interface text is properly localized alongside other features like Auth, Dashboard, Profile, and Settings.

lib/app · high confidence

Added comprehensive test infrastructure and performance benchmarks; Added comprehensive tests for auth feature presentation layer; Added comprehensive tests for the Profile feature; Added integration test infrastructure and end-to-end test suites; Added localization tests for the Orders feature; Added test templates for new code generation bricks; Added tests for auth exception mapping; Added tests for dashboard localization and page rendering; Added tests for settings localization and UI components; Added unit tests for auth infrastructure datasources; Added unit tests for authentication domain entities and services; Added unit tests for authentication infrastructure models; Added unit tests for authentication use cases and repository implementation.

The project has been updated to support Flutter SDK ^3.41.2 and Dart SDK ^3.11.0. Key dependencies have been upgraded, including go\_router to 17.1.0, sentry\_flutter to 9.15.0, and build\_runner to 2.13.0, alongside various other package version bumps in the pubspec and lockfiles.

(dependencies) · high confidence

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

• CAI 72 → 75 (+3.4)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 100 → 95 (-4.5)
• Architecture 100 → 94 (-6.2)
• Maturity 84 → 78 (-5.8)
• Readiness 61 → 65 (+4.1)
• Security 67 → 79 (+12.4)
• Domain Modelling 100 → 100 (+0.0)
• Event Sourcing 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)
• No exposed public API
• Off-boarding risk: anonymized user #1
• Test reliability not included
• The AI-ready architecture section lists 23 rules but does not explain what any of them are or how to apply them. (README.md)
• complexity unreadable for .dart, .swift — churn × complexity hotspots could not be measured

• Dependency hygiene PARTLY measured — Maven/Gradle declarations read, no dependency graph resolved
• Documentation: no installation or build instructions (README.md)
• Documentation: no project overview (README.md)
• Documentation: written for insiders (lib/core/domain/README.md)
• Documentation: written for insiders (lib/core/feature_flags/README.md)
• Documentation: written for insiders (lib/core/presentation/bloc/README.md)
• Documentation: written for insiders (lib/features/auth/README.md)
• Documentation: written for insiders (lib/features/dashboard/README.md)
• Dormant codebase
• Duplicated block (13 lines × 2) (lib/core/presentation/widgets/adaptive_navigation_scaffold.dart)
• Duplicated block (13 lines × 2) (lib/features/auth/presentation/bloc/auth_bloc.dart)
• Duplicated block (14 lines × 2) (lib/features/profile/l10n/profile_localizations_en.dart)
• Duplicated block (15–16 lines × 2) (lib/features/auth/presentation/widgets/login_form.dart)
• Duplicated block (26 lines × 2) (lib/features/settings/l10n/settings_localizations_en.dart)
• Duplicated block (58 lines × 2) (lib/features/auth/l10n/auth_localizations_en.dart)
• Duplicated block (76 lines × 2) (lib/core/l10n/arb/app_localizations_en.dart)
• Duplicated block (8 lines × 2) (lib/core/error/exceptions/cache_exception.dart)
• Duplicated block (9 lines × 3) (lib/features/dashboard/presentation/routes/dashboard_routes.dart)
• High: security finding (details withheld)
• High: security finding (details withheld)
• …and 85 more

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

deveminsahin/starter_app 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.