kido-luci/flutter-starter-template

This system is a modular, offline-first Flutter application template designed for cross-platform mobile development on Android and iOS. It provides a structured architecture featuring isolated feature packages for authentication, bookmarks, collections, and notifications, all synchronized via a local ObjectBox database and a background sync engine. The project includes comprehensive infrastructure for CI/CD, automated code generation, and AI-assisted development workflows, along with a shared design system and robust testing suites to ensure consistency and reliability.

A new \test\_utils\ package has been introduced to centralize testing resources across the application. It provides reusable test fixtures, such as a standard \testUser\ and \testFailure\, along with a transparent 1x1 PNG image for testing image providers without network or disk I/O. The package also includes a suite of mocks and fakes for key services—including analytics, platform capabilities (image picker, permissions, sharing, video player), shared contracts (session, bookmarks, collections), and storage—allowing feature and widget tests to easily stub dependencies.

_packages/test\utils · high confidence

A new \FirebaseService\ has been introduced in the core platform layer to centralize Firebase initialization and configuration. This service handles app startup via \Firebase.initializeApp()\ using platform-specific options, registers a background message handler for Firebase Cloud Messaging (FCM) to process messages when the app is terminated or in the background, and prepares the environment for subsequent services like Crashlytics and Analytics. Users must now initialize this service via the dependency injection container (\getIt\) early in the app lifecycle, immediately after dependency configuration and before running the app.

lib/core/platform · high confidence

The lib directory now includes a new firebase\_options.dart file containing placeholder Firebase configuration values for web, Android, and iOS, allowing the template to compile and run the test suite out of the box without requiring immediate Firebase setup. Additionally, main.dart has been restructured to initialize dependencies, clear iOS Keychain data on fresh installs, and conditionally start Firebase services (Core, Remote Config, Messaging) and local notifications based on the kFirebaseEnabled flag, ensuring a clean bootstrap process that handles errors gracefully.

lib · high confidence

The Android module has been initialized with standard Flutter project structures, including Gradle build files, the AndroidManifest, and native source directories. To support secure release builds for the Google Play Store, a key.properties.example file has been added to guide developers on configuring signing credentials, while the .gitignore file ensures that sensitive keystore files and local properties are excluded from version control. Additionally, a comprehensive README.md has been introduced to document the directory structure, common tasks such as adding permissions and updating SDK versions, and best practices for building the app.

android · high confidence

The bookmarks feature's presentation layer has been extracted into its own package (\packages/features/bookmarks\), introducing a complete BLoC-based architecture for managing the bookmarks list, detail view, and creation/editing forms. This change adds dedicated state management for loading, deleting, and sharing bookmarks, as well as handling form inputs, media attachments (images and videos), and search analytics. It also includes a custom video player widget with fullscreen support and glassmorphic controls, and defines the feature's navigation routes (\/bookmarks\, \/bookmarks/new\, \/bookmarks/:id\) for integration with the app's router.

packages/features/bookmarks/lib/src/presentation · high confidence

The collections feature has been refactored into a standalone package with full offline support. Users can now create, edit, and delete collections immediately, with changes persisted locally via ObjectBox and automatically synchronized with the server in the background using the rev\_sync engine. The system handles network interruptions, conflict detection, and retry logic transparently, ensuring data consistency without blocking the UI.

packages/features/collections/lib/src · high confidence

The iOS runner has been initialized with standard Flutter platform files, including the app delegate, scene delegate, and Info.plist. This configuration enables deep linking via the FlutterDeepLinkingEnabled flag and supports background modes for fetch and remote notifications. To comply with Apple's privacy requirements, a PrivacyInfo.xcprivacy manifest has been added, declaring that the app performs no tracking and listing accessed API categories (UserDefaults, file timestamps, disk space, and system boot time) used by statically linked plugins. Additionally, entitlements are configured for push notifications (development and production environments) and associated domains for universal links.

ios/Runner · high confidence

The application now includes the necessary native entry points and interface files to run on Android and iOS. On Android, a MainActivity class is provided to host the Flutter engine, and on iOS, LaunchScreen and Main storyboards are added to define the initial view controller and launch screen layout.

android/app/src/main/kotlin, ios/Runner/Base.lproj · high confidence

Establishes the foundational project structure and tooling configuration, including the Flutter version pin (3.44.0) via FVM, Git attributes for consistent line endings, and a comprehensive .gitignore. Integrates AI-assisted development workflows by adding CodeRabbit for automated PR reviews, configuring MCP servers for CodeGraph, Dart, and Firebase, and vendoring agent skills. Sets up the analysis options extending very\_good\_analysis, defines test tags for golden tests, and initializes the changelog, contributing guidelines, and security policy.

(repo-wide) · high confidence

Developers can now scaffold a new app with a Drift/SQLite backend by running \fst create --database drift\. This adds a \database\_drift\ package containing the \AppDatabase\ definition, table classes for bookmarks, collections, activities, notifications, and sync cursors, and the corresponding entity models. The package includes schema snapshots and migration testing infrastructure to ensure database upgrades remain consistent with the generated bindings.

_packages/database\drift · high confidence

The \packages/app\_ui/lib\ area now provides a unified design system and a library of reusable UI components. It introduces centralized design tokens for spacing, radius, elevation, icon sizes, and animation durations to ensure visual consistency. The package includes a responsive \AppAdaptiveScaffold\ that renders a floating frosted-glass bottom bar on compact screens and a navigation rail on larger devices, along with a suite of themed widgets such as \AppButton\, \AppCard\, \AppConfirmDialog\, and \AppCarousel\. It also adds semantic color extensions for status indicators (success, warning, info) and utility extensions for media queries and breakpoints, allowing features to adopt a polished, consistent look without inline styling.

_packages/app\ui/lib · high confidence

The app now persists bookmarks, collections, activities, and notifications locally using ObjectBox, with a sync engine that tracks server revisions to support offline-first operation and conflict detection. At the same time, the app is now available in English and Vietnamese, with all UI strings (login, registration, home, bookmarks, profile, settings, and notifications) localized via generated AppLocalizations.

packages/database · high confidence

The notifications feature now provides an offline-first experience by caching notifications and user activity in a local ObjectBox database, ensuring the feed is always available even without a network connection. The UI presents these items in a two-tab layout: one for notifications (grouped into 'New' and 'Earlier' sections) and another for recent user activities. The system automatically syncs with the remote API in the background, pushing local read-marks and refreshing the cache, while the UI updates seamlessly after sync cycles without requiring manual pull-to-refresh.

packages/features/notifications · high confidence

The application now includes a reusable offline-first sync engine, implemented via the \rev\_sync\ package, which manages synchronization state using ObjectBox. This change introduces a new dependency injection module (\ObjectBoxModule\) to asynchronously initialize the ObjectBox store and a dedicated \ObjectBoxSyncCursorStore\ to persist sync cursors, ensuring that synchronization progress is durable alongside the synced data.

lib/core/data · high confidence

The repository now includes a suite of shell scripts in the \tool/\ directory to streamline development and release workflows. \tool/setup.sh\ provides a one-time bootstrap command that initializes git submodules, installs the FVM-pinned Flutter SDK, disables Swift Package Manager on macOS, installs dependencies, runs code generation, normalizes source formatting, and configures git hooks. \tool/codegen.sh\ centralizes \build\_runner\ execution across all feature and infrastructure packages to ensure generated files are up to date. \tool/ci-secrets-setup.sh\ automates the configuration of GitHub Actions secrets and variables for iOS and Android release pipelines via the \gh\ CLI. Additional utilities include \tool/set\_version.sh\ for stamping versions from git tags, \tool/run\_e2e.sh\ for executing end-to-end tests against a local backend, and \tool/codegen.sh\ for ensuring consistent code generation.

tool · high confidence

Added comprehensive documentation and workflow guides for Dart development and Firebase integration. The new skills cover Dart unit testing, CLI application building, test coverage collection, runtime error resolution, mock generation, package conflict management, static analysis, and pattern matching. Additionally, a new skill provides guidance on integrating Firebase AI Logic (Gemini API) into web and mobile applications.

.agents · high confidence

Added a new MCP server implementation at .mcp/dart-server/server.js that exposes six tools for Dart and Flutter projects: static analysis (dart\_analyze), automated fixes (dart\_fix), code formatting (dart\_format), test execution (dart\_test), dependency resolution (dart\_pub\_get), and code generation via build\_runner (dart\_build\_runner). This enables AI agents to perform common development tasks directly within the project context.

.mcp · high confidence

The app now includes dedicated Home and Profile feature packages. The Home feature provides a dashboard screen that displays bookmark statistics, recent items, and collections, along with search and filtering capabilities. The Profile feature presents an account settings screen where users can manage their appearance (theme and color scheme), view app version information, sign out, change their password, and delete their account. Both features are structured as independent micro-packages with their own dependency injection modules and presentation layers.

packages/features/profile · high confidence

This change introduces two new micro-packages: \packages/network\ and \packages/storage\. The network package provides a configured Dio HTTP client that automatically attaches Bearer tokens, transparently refreshes them on 401 errors using a single-flight mechanism, retries transient failures with exponential backoff, and records performance metrics via Firebase Performance. The storage package manages secure token persistence using \flutter\_secure\_storage\ and includes a \KeychainResetOnReinstall\ utility to clear stale iOS Keychain data after app reinstalls. Both packages are integrated into the app's dependency injection graph via generated modules (\NetworkPackageModule\ and \StoragePackageModule\).

packages/network · high confidence

The \app\_platform\ package now provides a unified layer for device capabilities, wrapping \camera\, \image\_picker\, \video\_player\, \permission\_handler\, \share\_plus\, \flutter\_local\_notifications\, \firebase\_messaging\, and \firebase\_crashlytics\ behind app-facing services. It includes a \CrashReporter\ port (defaulting to Firebase Crashlytics, swappable to a no-op) and a \NotificationsService\ for local scheduling and tap-to-navigate. Additionally, a new \analytics\ package introduces an \AnalyticsService\ port (defaulting to Firebase Analytics, swappable to a no-op) with a \NavigatorObserver\ for automatic screen-view logging and typed tracking extensions for auth, theme, and bookmark events. Both packages are registered as DI micro-modules, with \app\_platform\ depending on \analytics\ in the composition order.

_packages/app\platform · high confidence

This change introduces the \shared\_contracts\ and \shared\_ui\ packages to decouple feature modules. \shared\_contracts\ defines lightweight domain contracts (such as \Session\, \AuthUser\, \BookmarkSummary\, and \CollectionSummary\) and an \ActivityNotifier\ event bus, allowing features like Home, Bookmarks, and Collections to communicate and display data without direct dependencies on each other's internal domains. \shared\_ui\ provides the corresponding presentation layer, including a \SessionScope\ widget for accessing the session state in the widget tree and a \collection\_visuals\ module that manages a fixed palette of icon/color presets for collection cards, ensuring consistent visual rendering across features.

_packages/shared\contracts · high confidence

The splash feature package now provides a bootstrap screen that displays while the user's session is restored. It enforces a minimum display duration of two seconds to prevent flashing, then invokes a callback to hand control back to the host app for navigation. The visual presentation includes the app logo, title, and a pulsing loading indicator, all styled using the shared UI theme.

packages/features/splash · high confidence

A new \sync\_connectivity\_plus\ package has been added to provide a concrete platform adapter for the offline-first \sync\ engine. It implements the \ConnectivitySource\ port by wrapping the \connectivity\_plus\ plugin, collapsing multiple network links into a single online/offline signal for the sync scheduler. The package includes a dependency-injection module (\SyncConnectivityPlusPackageModule\) that apps can register to wire up the \Connectivity\ client and the source implementation.

_packages/sync\_connectivity\plus · high confidence

Added Fastlane configuration files (Appfile, Fastfile, .env.example) and store metadata templates to enable building and uploading Android app bundles to Google Play. The setup supports multiple app flavors (dev, staging, prod) with distinct package names and tracks, handles release signing via external keystore properties, and manages build numbers using CI variables or git commit counts. It includes lanes for internal testing (beta) and production releases (release) with staged rollout capabilities, requiring users to configure environment variables for the Play Store service account key and base package name.

android/fastlane · high confidence

Added a complete Fastlane configuration for iOS, enabling builds for dev, staging, and prod flavors to be uploaded to TestFlight or the App Store. The setup uses App Store Connect API keys for authentication and match for centralized code signing via a private git repository. It includes lanes for beta (TestFlight) and release (App Store) submissions, automatic dSYM upload to Firebase Crashlytics, and placeholder metadata files for the App Store listing.

ios/fastlane · high confidence

The iOS native project has been scaffolded to support distinct build configurations for development, staging, and production environments. This change introduces specific Xcode schemes (dev, staging, prod) that map to corresponding build configurations (e.g., Debug-dev, Release-prod), enabling developers to easily switch between environments. The project also integrates CocoaPods for dependency management, includes a privacy manifest for App Store compliance, and configures the build system to prepare the Flutter framework automatically upon launch.

ios/Runner.xcodeproj · high confidence

The bookmarks feature now uses a dedicated dependency injection module (\FeatureBookmarksPackageModule\) to register its services, use cases, and presentation blocs. This change isolates the bookmarks feature's internal wiring (including remote data sources, local storage, sync controllers, and analytics integration) from the host application, allowing the host app to wire the feature via \externalPackageModulesBefore\ rather than manually configuring each component.

packages/features/bookmarks/lib/src · high confidence

The bookmarks and collections features have been refactored into separate, self-contained packages (\packages/features/bookmarks/lib\ and \packages/features/collections/lib\). Each package now exposes a specific public surface via its main library file: the bookmarks package exports its dependency injection module, the \Bookmark\ entity, the sync controller, and its presentation screens (list, detail, and form); the collections package similarly exports its DI module, \Collection\ entity, sync controller, and screens, while additionally exposing reusable UI widgets (\CollectionsListView\ and \AddToCollectionSheet\) for consumption by other features. Internal repositories, use cases, and data layers remain private to each package, enforcing a clean separation of concerns and allowing the host app to wire these features independently.

packages/features/bookmarks/lib, packages/features/collections/lib · high confidence

The \lib/app\ directory now serves as the central configuration layer, wiring together core systems (theming, routing, localization) and optional feature packages (auth, bookmarks, collections, notifications) into a unified \MaterialApp\. The new \App\ widget manages global state providers, configures \go\_router\ for declarative routing with shell branches, and handles session-based synchronization lifecycles. Routing is now driven by \FeatureModule\ interfaces, allowing features to contribute their own routes and sync controllers without modifying the core app shell. Deep-link support is added via \DeepLinkScope\ to handle cold-start URIs and session restoration. A \BootstrapErrorApp\ provides a fallback UI if initialization fails, and Firebase integration is now optional via the \kFirebaseEnabled\ flag.

lib/app · high confidence

The app now uses an adaptive navigation shell that hosts persistent bottom tabs for Home, Bookmarks, Notifications, and Profile. The Notifications tab displays a red badge when there are unread items, and the app automatically fetches notifications on startup to ensure the badge is visible immediately. Additionally, the navigation icons have been updated to use Font Awesome icons instead of the previous Material icons.

lib/app/widgets · high confidence

The bookmarks feature has been refactored to operate offline-first: all reads are served immediately from the local ObjectBox store, and writes are committed locally before triggering a background sync to the server. This ensures the UI remains responsive regardless of network state. The implementation includes a generic sync engine that handles delta pulls, conflict detection (via server revisions), and retry policies for transient errors. Users will see badges for bookmarks pending sync, conflicts requiring resolution, or failed syncs. Additionally, media attachments (images and videos) are uploaded in parallel before the bookmark metadata is synced, and the system supports soft-deletes with tombstones to ensure consistent deletion across devices.

packages/features/bookmarks/lib/src/data, packages/features/bookmarks/lib/src/domain · high confidence

A new AppServicesModule has been introduced in the dependency injection layer to register generic, app-wide primitives such as the UUID generator. This change consolidates the registration of shared third-party services that are not owned by any specific feature, ensuring that feature packages can resolve these common dependencies from the shared GetIt graph at runtime.

lib/core/di · high confidence

The auth logic is now packaged as a standalone feature module (\packages/features/auth\) that exposes a DI module, presentation screens (login, register, change password), and routing definitions. The package implements a robust session restoration flow that attempts to refresh tokens on launch and optimistically restores the session for offline users, preventing forced re-logins. It also adds specific error handling to map malformed server responses during sign-in and registration to user-visible failures instead of crashes.

packages/features/auth · high confidence

A new pre-push hook has been added to catch formatting, analyzer, and code-generation issues before pushing to the remote. The script first runs build\_runner to generate code (mirroring CI behavior), then checks Dart formatting and runs flutter analyze on tracked files. It also handles environment isolation by unsetting GIT\_DIR to prevent FVM from failing, and excludes submodule contents from checks to avoid false failures.

.githooks · high confidence

The CLI and rev\_sync submodules have been moved into a new top-level published/ directory. This structural change groups these published packages together, simplifying the repository layout and making it easier to locate and manage the published components.

published · high confidence

The \lib/core/extensions\ module now provides a thin shim that re-exports localization accessors (including \AppLocalizations\ and the \context.l10n\ extension) from \package:localization\. This change maintains backward compatibility for existing in-app imports while allowing feature packages to import the localization package directly, effectively decoupling the core extension layer from the specific localization implementation details.

lib/core/extensions · high confidence

The dependency injection layer now supports scaffolding apps with optional features (such as bookmarks and collections) excluded. When these features are omitted, the system registers null-object fallbacks for their shared data readers, ensuring that core components like the home dashboard continue to function with empty data rather than failing to resolve dependencies.

lib/app/di · high confidence

The iOS project has been updated to support multiple build environments (Dev, Staging, Prod) with unique display names and bundle identifiers. This allows users to install and run different versions of the app side-by-side, with the Dev and Staging variants clearly labeled in the app icon to distinguish them from the production build.

ios/Flutter · high confidence

Add app-level integration test and test utilities; Add shared mock classes for auth and notifications in test utilities; Added architecture guardrail tests to enforce package boundaries and configuration integrity; Added comprehensive test coverage for the Collections feature; Added initial iOS unit test scaffold; Added screenshot capture driver for documentation; Added tests for splash screen and authentication redirect logic; Added unit and widget tests for the bookmarks feature; Added widget tests and golden snapshots for app\_ui components; Replace mock-based integration tests with a real-backend end-to-end journey.

The Android build system now uses Gradle 9.6.1 (via the wrapper) instead of the previous version. This update ensures the project builds with the latest Gradle release, which may include performance improvements, bug fixes, and new features in the build toolchain.

android/gradle · high confidence

This change introduces the foundational dependency manifests and lockfiles for the project. It establishes a Flutter workspace structure with multiple packages (analytics, app\_platform, app\_ui, architecture, config, database, features, network, storage, etc.) pinned to specific versions of third-party libraries such as Firebase, BLoC, go\_router, and injectable. It also adds a Node.js MCP server dependency (\@modelcontextprotocol/sdk\) and a Swift Package Manager lockfile for the Xcode setup tooling, alongside Android/iOS build configuration files (Gradle, CocoaPods) that define the platform-specific dependency environment.

(dependencies) · high confidence

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

• CAI 76 → 78 (+2.0)
• Rubric changed (rubric-2026.08.17 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 100 → 97 (-3.4)
• Architecture 100 → 94 (-5.8)
• Maturity 76 → 73 (-3.6)
• Readiness 71 → 79 (+8.3)
• Security 71 → 76 (+5.1)
• Domain Modelling 100 → 100 (+0.0)

• Coverage not included — suite not readable by the collector
• Dependency hygiene not measured — no supported dependency manifest was read
• Further sole-owners (lower concentration)
• 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)
• High: security finding (details withheld)
• High: security finding (details withheld)
• High: security finding (details withheld)
• …and 24 more

• (anonymous) (cognitive 18) (.mcp/dart-server/server.js)
• AppButton.build (cognitive 17) (packages/app_ui/lib/src/widgets/app_button.dart)
• AppButton.build (cyclomatic 17) (packages/app_ui/lib/src/widgets/app_button.dart)
• Change coupling: auth_repository_impl.dart ↔ bookmarks_sync_service.dart (packages/features/auth/lib/src/data/repositories/auth_repository_impl.dart)
• Change coupling: bookmark_detail_widgets.dart ↔ bookmarks_list_widgets.dart (packages/features/bookmarks/lib/src/presentation/widgets/bookmark_detail_widgets.dart)
• Change coupling: bookmark_detail_widgets.dart ↔ profile_widgets.dart (packages/features/bookmarks/lib/src/presentation/widgets/bookmark_detail_widgets.dart)
• Change-coupling hub: bookmarks_list_bloc.dart → bookmark_form_bloc.dart, bookmark_detail_widgets.dart, profile_widgets.dart (packages/features/bookmarks/lib/src/presentation/bloc/bookmarks_list/bookmarks_list_bloc.dart)
• Documentation: no installation or build instructions (README.md)
• Documentation: no project overview (README.md)
• Duplicated block (10–11 lines × 3) (packages/features/auth/lib/src/presentation/screens/register_screen.dart)
• Duplicated block (12 lines × 2) (packages/app_ui/lib/src/widgets/app_empty_view.dart)
• Duplicated block (13 lines × 2) (packages/features/bookmarks/lib/src/presentation/widgets/bookmark_form_fields.dart)
• Duplicated block (14 lines × 2) (packages/features/bookmarks/lib/src/data/sync/bookmarks_sync_service.dart)
• Duplicated block (16 lines × 2) (packages/features/auth/lib/src/data/repositories/auth_repository_impl.dart)
• Duplicated block (16 lines × 2) (packages/features/bookmarks/lib/src/data/repositories/bookmarks_repository_impl.dart)
• Duplicated block (18 lines × 2) (packages/features/bookmarks/lib/src/data/repositories/bookmarks_repository_impl.dart)
• Duplicated block (18 lines × 2) (packages/features/bookmarks/lib/src/data/sync/bookmarks_sync_adapter.dart)
• Duplicated block (18 lines × 2) (packages/features/bookmarks/lib/src/presentation/widgets/bookmark_detail_widgets.dart)
• Duplicated block (19 lines × 2) (packages/features/bookmarks/lib/src/data/sync/bookmarks_sync_adapter.dart)
• Duplicated block (29 lines × 2) (packages/features/auth/lib/src/presentation/screens/login_screen.dart)
• …and 69 more

• 15 commits — 9 feature/other, 6 fixes

• .github/workflows — 5 commits
• (repo) — 4 commits
• packages/features — 2 commits
• .githooks/pre-push — 1 commit
• .mcp/dart-server — 1 commit
• android/build.gradle.kts — 1 commit
• packages/database_drift — 1 commit

• fix: fix(ci): mark the placeholder-credential steps as Firebase-only (#198)
• fix: fix(ci): mark the scaffolding that only this repository needs (#196)
• fix: fix: leave scaffolds formatted, and gate on it (#195)
• fix: fix: let the pre-push hook run under git's hook environment (#204)
• fix: fix: make every scaffold configuration compile, analyze and test clean (#194)
• fix: fix: regenerate stale di.module.dart across four packages (#202)
• change: Merge pull request #190 from kido-luci/dependabot/bundler/android/bundler-7931bf9ce8
• change: Merge pull request #191 from kido-luci/dependabot/gradle/android/gradle-minor-and-patch-2314945e7c
• change: Merge pull request #193 from kido-luci/dependabot/npm_and_yarn/dot-mcp/dart-server/npm_and_yarn-c3809050de
• change: Merge pull request #199 from kido-luci/dependabot/github_actions/github-actions-d2809b2831
• change: chore(deps): bump body-parser
• change: chore(deps): bump github/codeql-action in the github-actions group
• change: chore(deps): bump the gradle-minor-and-patch group across 1 directory with 2 updates
• change: chore(deps): bump the pub-minor-and-patch group, capping drift at 2.34.0 (#200)
• change: chore: gate di.module.dart against generator drift (#203)

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

kido-luci/flutter-starter-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.